fabian/zeitlaeufer
1
0
Fork 0
Code Pull Requests Activity

removed everything not explicitly zeitlaeufer

Browse Source
This commit is contained in:
fszimnau
2025-09-04 10:24:57 +02:00
parent 378ab4c026
commit 7aae2f018b
6 changed files with 0 additions and 1714 deletions
Download Patch File Download Diff File Expand all files Collapse all files

415
Darlehenberechner.java
View File

@@ -1,415 +0,0 @@
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.math.BigDecimal;
import java.math.MathContext;
import java.nio.charset.StandardCharsets;
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.text.ParseException;
import java.time.Month;
import java.time.YearMonth;
import java.util.Locale;
class Darlehenberechner {
private static final class Konfiguration {
private BigDecimal darlehenswert;
private BigDecimal zinssatzReal;
private BigDecimal monatlicheRate;
private Integer laufzeitMonate;
private BigDecimal restschuld;
private Integer tilgungsfreieZeit;
private YearMonth anfangsmonat;
private BigDecimal sondertilgungReal;
public BigDecimal getDarlehenswert() {
return darlehenswert;
}
public Konfiguration setDarlehenswert(BigDecimal darlehenswert) {
this.darlehenswert = darlehenswert;
return this;
}
public BigDecimal getZinssatz() {
return zinssatzReal;
}
public Konfiguration setZinssatzProzent(BigDecimal zinssatzProzent) {
this.zinssatzReal = zinssatzProzent.divide(EINHUNDERT, MathContext.DECIMAL128);
return this;
}
public BigDecimal getMonatlicheRate() {
return monatlicheRate;
}
public Konfiguration setMonatlicheRate(BigDecimal monatlicheRate) {
this.monatlicheRate = monatlicheRate;
return this;
}
public Integer getLaufzeitMonate() {
return laufzeitMonate;
}
public Konfiguration setLaufzeitMonate(Integer laufzeitMonate) {
this.laufzeitMonate = laufzeitMonate;
return this;
}
public Konfiguration setLaufzeitJahre(Integer jahre) {
this.laufzeitMonate = (jahre * 12);
return this;
}
public Konfiguration setLaufzeit(Integer jahre, Integer monate) {
this.laufzeitMonate = (jahre * 12) + monate;
return this;
}
public BigDecimal getRestschuld() {
return restschuld;
}
public Konfiguration setRestschuld(BigDecimal restschuld) {
this.restschuld = restschuld;
return this;
}
public Integer getTilgungsfreieZeit() {
return tilgungsfreieZeit;
}
public Konfiguration setTilgungsfreieZeit(Integer tilgungsfreieZeit) {
this.tilgungsfreieZeit = tilgungsfreieZeit;
return this;
}
public YearMonth getAnfangsmonat() {
return anfangsmonat;
}
public Konfiguration setAnfangsmonat(YearMonth anfangsmonat) {
this.anfangsmonat = anfangsmonat;
return this;
}
public BigDecimal getSondertilgung() {
return sondertilgungReal;
}
public Konfiguration setSondertilgungProzent(BigDecimal sondertilgungProzent) {
this.sondertilgungReal = sondertilgungProzent.divide(EINHUNDERT, MathContext.DECIMAL128);
return this;
}
}
private static final DecimalFormat DECIMAL_FORMAT = new DecimalFormat("#,##0.00", new DecimalFormatSymbols(Locale.GERMAN));
private static final BigDecimal ZWOELF = BigDecimal.valueOf(12);
private static final BigDecimal EINHUNDERT = BigDecimal.valueOf(100);
private final Integer laufzeitMonate;
private final BigDecimal restschuld;
private final BigDecimal zinssatz;
private BigDecimal sondertilgung;
private int summeMonate = 0;
private BigDecimal aktRestschuld;
private BigDecimal aktMonatlicheRate;
private BigDecimal aktZinsbetrag;
private BigDecimal aktTilgungsbetrag;
private Integer aktTilgungsfreieZeit;
private YearMonth aktMonat;
private BigDecimal jahressummeZinsenKalenderjahr = BigDecimal.ZERO;
private BigDecimal jahressummeZinsenKreditjahr = BigDecimal.ZERO;
private BigDecimal summeZinsen = BigDecimal.ZERO;
private BigDecimal jahressummeTilgungKalenderjahr = BigDecimal.ZERO;
private BigDecimal jahressummeTilgungKreditjahr = BigDecimal.ZERO;
private BigDecimal summeTilgung = BigDecimal.ZERO;
private BigDecimal jahressummeRatenKalenderjahr = BigDecimal.ZERO;
private BigDecimal jahressummeRatenKreditjahr = BigDecimal.ZERO;
private BigDecimal summeRaten = BigDecimal.ZERO;
public static void main(String[] args) throws ParseException, IOException {
/*new Darlehenberechner(new Konfiguration()
.setDarlehenswert(BigDecimal.valueOf(168_000))
.setZinssatzProzent(BigDecimal.valueOf(3.73))
.setMonatlicheRate(BigDecimal.valueOf(1_500))
.setTilgungsfreieZeit(0)
.setAnfangsmonat(YearMonth.of(2024, Month.SEPTEMBER))
.setSondertilgungProzent(BigDecimal.valueOf(2.5))
).berechneWerte();*/
/*new Darlehenberechner(new Konfiguration()
.setDarlehenswert(BigDecimal.valueOf(168_000))
.setZinssatzProzent(BigDecimal.valueOf(3.73))
.setMonatlicheRate(BigDecimal.valueOf(1_500))
.setTilgungsfreieZeit(0)
.setLaufzeitJahre(11)
.setAnfangsmonat(YearMonth.of(2024, Month.SEPTEMBER))
).berechneWerte();*/
if (args.length == 0) {
askParametersAndRun();
} else {
parseParametersAndRun(args);
}
}
private static void askParametersAndRun() throws ParseException, IOException {
DECIMAL_FORMAT.setParseBigDecimal(true);
var konfig = new Konfiguration();
var br = new BufferedReader(new InputStreamReader(System.in, StandardCharsets.UTF_8));
System.out.print("Darlehenswert: ");
konfig.setDarlehenswert((BigDecimal) DECIMAL_FORMAT.parse(br.readLine()));
System.out.print("Zinssatz: ");
konfig.setZinssatzProzent((BigDecimal) DECIMAL_FORMAT.parse(br.readLine()));
System.out.print("Monatliche Rate: ");
konfig.setMonatlicheRate((BigDecimal) DECIMAL_FORMAT.parse(br.readLine()));
System.out.print("Monat erste Rate(z.B. 2007-12): ");
konfig.setAnfangsmonat(YearMonth.parse(br.readLine()));
System.out.print("Laufzeit in Jahren(optional Jahre:Monate): ");
String in = br.readLine();
if (in != null && !in.isBlank()) {
String[] split = in.split(":");
konfig.setLaufzeit(Integer.parseInt(split[0]), Integer.parseInt(split[1]));
} else {
System.out.print("Restschuld(optional): ");
in = br.readLine();
if (in != null && !in.isBlank()) {
konfig.setRestschuld((BigDecimal) DECIMAL_FORMAT.parse(in));
}
}
System.out.print("Anzahl tilgungsfreier Monate(optional): ");
in = br.readLine();
if (in != null && !in.isBlank()) {
konfig.setTilgungsfreieZeit(Integer.parseInt(in));
}
System.out.print("Sondertilgungssatz(optional): ");
in = br.readLine();
if (in != null && !in.isBlank()) {
konfig.setSondertilgungProzent((BigDecimal) DECIMAL_FORMAT.parse(in));
}
new Darlehenberechner(konfig).berechneWerte();
}
private static void parseParametersAndRun(String[] args) throws ParseException {
var konfig = new Konfiguration();
int count = 0;
DECIMAL_FORMAT.setParseBigDecimal(true);
while (count < args.length) {
String arg = args[count];
if (arg.equals("-hilfe")) {
System.out.println("-darlehenswert 1000,00 -zinssatz 3,73 -monatlicheRate 30,00 -anfangsmonat 2024-09"
+ "[-laufzeitJahre 11] [-aktTilgungsfreieZeit 5]");
}
if (arg.equals("-darlehenswert")) {
count++;
konfig.setDarlehenswert((BigDecimal) DECIMAL_FORMAT.parse(args[count]));
}
if (arg.equals("-zinssatz")) {
count++;
konfig.setZinssatzProzent((BigDecimal) DECIMAL_FORMAT.parse(args[count]));
}
if (arg.equals("-sondertilgung")) {
count++;
konfig.setSondertilgungProzent((BigDecimal) DECIMAL_FORMAT.parse(args[count]));
}
if (arg.equals("-monatlicheRate")) {
count++;
konfig.setMonatlicheRate((BigDecimal) DECIMAL_FORMAT.parse(args[count]));
}
if (arg.equals("-aktTilgungsfreieZeit")) {
count++;
konfig.setTilgungsfreieZeit(Integer.parseInt(args[count]));
}
if (arg.equals("-laufzeitJahre")) {
count++;
konfig.setLaufzeitJahre(Integer.parseInt(args[count]));
}
if (arg.equals("-anfangsmonat")) {
count++;
konfig.setAnfangsmonat(YearMonth.parse(args[count]));
}
count++;
}
new Darlehenberechner(konfig).berechneWerte();
}
private Darlehenberechner(Konfiguration konfig) {
laufzeitMonate = konfig.getLaufzeitMonate();
restschuld = konfig.getRestschuld();
zinssatz = konfig.getZinssatz();
sondertilgung = konfig.getSondertilgung() != null ? konfig.getSondertilgung().multiply(konfig.getDarlehenswert()) : BigDecimal.ZERO;
aktRestschuld = konfig.getDarlehenswert();
if (restschuld != null) {
aktRestschuld = aktRestschuld.subtract(restschuld);
}
aktMonatlicheRate = konfig.getMonatlicheRate();
aktTilgungsfreieZeit = konfig.getTilgungsfreieZeit();
aktMonat = konfig.getAnfangsmonat();
}
private void berechneWerte() {
druckeUeberschrift();
while (laufzeitNichtVorbei()) {
erhoeheSummeMonate();
zahleSondertilgung();
berechneBeitragAufteilung();
berechneRestschuld();
druckeAktuelleMonatswerte();
berechneSummen();
druckeJahressumeBedingt();
aktualisiereZeitwerte();
}
druckeFinaleSummen();
druckeLaufzeitUndRestschuld();
}
private void druckeUeberschrift() {
System.out.println("Monat: Rate = Zinsen + Tilgung| Restschuld");
}
private boolean laufzeitNichtVorbei() {
return laufzeitMonate != null ? summeMonate < laufzeitMonate : aktRestschuld.signum() > 0;
}
private boolean laufzeitVorbei() {
return !laufzeitNichtVorbei();
}
private void erhoeheSummeMonate() {
summeMonate++;
}
private void zahleSondertilgung() {
if (sondertilgung == null || sondertilgung.signum() == 0) {
return;
}
boolean sondertilgungFaellingErstesJahr = summeMonate < 12 && aktMonat.getMonth() == Month.DECEMBER;
if (sondertilgungFaellingErstesJahr || summeMonate > 1 && aktMonat.getMonth() == Month.JANUARY) {
aktRestschuld = aktRestschuld.compareTo(sondertilgung) > 0 ? aktRestschuld.subtract(sondertilgung) : aktRestschuld;
System.out.println(aktMonat + ": " + DECIMAL_FORMAT.format(sondertilgung) + " = 0,00 + " + DECIMAL_FORMAT.format(sondertilgung) + " | " + DECIMAL_FORMAT.format(getRealeRestschuld()));
}
}
private BigDecimal getRealeRestschuld() {
return restschuld != null ? aktRestschuld.add(restschuld) : aktRestschuld;
}
private void berechneBeitragAufteilung() {
aktZinsbetrag = getRealeRestschuld().multiply(zinssatz)
.divide(ZWOELF, MathContext.DECIMAL128);
if (aktMonatlicheRate.compareTo(aktRestschuld) > 0) {
aktMonatlicheRate = aktRestschuld.add(aktZinsbetrag); // die letzte Rate ist gleich der Restschuld + Zinsen
}
aktTilgungsbetrag = aktTilgungsfreieZeit != null && aktTilgungsfreieZeit > 0 ? BigDecimal.ZERO : aktMonatlicheRate.subtract(aktZinsbetrag);
}
private void berechneRestschuld() {
aktRestschuld = aktRestschuld.subtract(aktTilgungsbetrag);
}
private void druckeAktuelleMonatswerte() {
System.out.println(aktMonat + ": " + DECIMAL_FORMAT.format(aktMonatlicheRate) + " = " + DECIMAL_FORMAT.format(aktZinsbetrag)
+ " + " + DECIMAL_FORMAT.format(aktTilgungsbetrag) + " | " + DECIMAL_FORMAT.format(getRealeRestschuld()));
}
private void berechneSummen() {
jahressummeZinsenKalenderjahr = jahressummeZinsenKalenderjahr.add(aktZinsbetrag);
jahressummeZinsenKreditjahr = jahressummeZinsenKreditjahr.add(aktZinsbetrag);
summeZinsen = summeZinsen.add(aktZinsbetrag);
jahressummeTilgungKalenderjahr = jahressummeTilgungKalenderjahr.add(aktTilgungsbetrag);
jahressummeTilgungKreditjahr = jahressummeTilgungKreditjahr.add(aktTilgungsbetrag);
summeTilgung = summeTilgung.add(aktTilgungsbetrag);
jahressummeRatenKalenderjahr = jahressummeRatenKalenderjahr.add(aktMonatlicheRate);
jahressummeRatenKreditjahr = jahressummeRatenKreditjahr.add(aktMonatlicheRate);
summeRaten = summeRaten.add(aktMonatlicheRate);
}
private void druckeJahressumeBedingt() {
boolean kreditjahrVergangen = summeMonate > 1 && summeMonate % 12 == 0 || laufzeitVorbei();
boolean kalenderjahrVergangen = aktMonat.getMonth() == Month.DECEMBER;
if (kreditjahrVergangen || kalenderjahrVergangen) {
if (kreditjahrVergangen) {
String desc = "Kreditjahr " + (summeMonate + 11) / 12; // + 11 weil integerdivision und X Jahre plus 1 Monat soll X + 1 tes Kreditjahr ergeben
druckeJahressumme(desc, jahressummeRatenKreditjahr, jahressummeZinsenKreditjahr, jahressummeTilgungKreditjahr);
jahressummeRatenKreditjahr = BigDecimal.ZERO;
jahressummeZinsenKreditjahr = BigDecimal.ZERO;
jahressummeTilgungKreditjahr = BigDecimal.ZERO;
}
if (kalenderjahrVergangen) {
String desc = "Kalenderjahr " + aktMonat.getYear();
druckeJahressumme(desc, jahressummeRatenKalenderjahr, jahressummeZinsenKalenderjahr, jahressummeTilgungKalenderjahr);
jahressummeZinsenKalenderjahr = BigDecimal.ZERO;
jahressummeTilgungKalenderjahr = BigDecimal.ZERO;
jahressummeRatenKalenderjahr = BigDecimal.ZERO;
}
}
}
private void druckeJahressumme(String desc, BigDecimal jahressummeRaten, BigDecimal jahressummeZinsen, BigDecimal jahressummeTilgung) {
System.out.println("Summe " + desc + ":\n" + DECIMAL_FORMAT.format(jahressummeRaten) + " = " + DECIMAL_FORMAT.format(jahressummeZinsen)
+ " + " + DECIMAL_FORMAT.format(jahressummeTilgung));
}
private void aktualisiereZeitwerte() {
aktMonat = aktMonat.plusMonths(1);
if (aktTilgungsfreieZeit != null) {
aktTilgungsfreieZeit--;
}
}
private void druckeFinaleSummen() {
System.out.println("Summe:\n" + DECIMAL_FORMAT.format(summeRaten) + " = " + DECIMAL_FORMAT.format(summeZinsen)
+ " + " + DECIMAL_FORMAT.format(summeTilgung));
}
private void druckeLaufzeitUndRestschuld() {
int laufzeitJahreFinal = summeMonate / 12;
int teillaufzeitMonateFinal = summeMonate % 12;
System.out.println("Laufzeit: " + laufzeitJahreFinal + " Jahre " + teillaufzeitMonateFinal + " Monate");
System.out.println("Restschuld: " + DECIMAL_FORMAT.format(getRealeRestschuld()));
}
}

165
DrinkingBar.java
View File

@@ -1,165 +0,0 @@
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;
import java.nio.charset.StandardCharsets;
import java.text.DecimalFormat;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.concurrent.TimeUnit;
public class DrinkingBar {
private static final DateTimeFormatter TIME_FORMATTER = DateTimeFormatter.ofPattern("HH:mm");
private static final int MINS_PER_HOUR = 60;
private static final int MINS_PER_HALF_HOUR = MINS_PER_HOUR / 2;
private static final int MINUTES_BEFORE_PAUSE = 4 * MINS_PER_HOUR + MINS_PER_HALF_HOUR;
private static final int MINUTES_WITH_PAUSE = 6 * MINS_PER_HOUR;
private static final int DEFAULT_TOTAL_TIME = 8 * MINS_PER_HOUR + MINS_PER_HALF_HOUR;
private static final BigDecimal DEFAULT_TOTAL_TIME_BD = BigDecimal.valueOf(DEFAULT_TOTAL_TIME);
private static final BigDecimal DEFAULT_TOTAL_LITRES = BigDecimal.valueOf(2.0);
private static final BigDecimal QUARTER_LITRE = BigDecimal.valueOf(0.25);
private static final DecimalFormat LITRE_FORMAT = new DecimalFormat("0.00");
private static final DecimalFormat PERCENTAGE_FORMAT = new DecimalFormat("00.00");
private static final BigDecimal MINS_PER_HOUR_BD = BigDecimal.valueOf(MINS_PER_HOUR);
private static final MathContext MC_INTEGER = new MathContext(1, RoundingMode.HALF_EVEN);
private final LocalTime startTime;
private LocalTime endTime;
private long totalMinutes;
private BigDecimal totalMinutesBD;
private BigDecimal totalLitres;
private DrinkingBar(LocalTime startTime) {
this.startTime = startTime;
this.totalMinutes = DEFAULT_TOTAL_TIME;
this.totalMinutesBD = BigDecimal.valueOf(totalMinutes);
this.endTime = startTime.plusMinutes(totalMinutes);
this.totalLitres = DEFAULT_TOTAL_LITRES;
}
public static void main(String[] args) throws IOException {
var br = new BufferedReader(new InputStreamReader(System.in, StandardCharsets.UTF_8));
print("Ankunftszeit: ");
var startTime = LocalTime.parse(br.readLine(), TIME_FORMATTER).truncatedTo(ChronoUnit.MINUTES);
var db = new DrinkingBar(startTime);
db.showLoadingBar();
}
private static void println(Object o) {
System.out.println(o);
}
private static void print(Object o) {
System.out.print(o);
}
protected long getPassedMinutes() {
return startTime.until(LocalTime.now().truncatedTo(ChronoUnit.MINUTES), ChronoUnit.MINUTES);
}
private void setEndTime(LocalTime endTime) {
this.endTime = endTime;
this.totalMinutes = startTime.until(endTime, ChronoUnit.MINUTES);
this.totalMinutesBD = BigDecimal.valueOf(totalMinutes);
extraInitEndTimeTotalMinutes();
}
protected void extraInitEndTimeTotalMinutes() {
// correct necessary litres to drink based on the end time.
// lower the volume in quarter litre steps
BigDecimal calcTotalLitres = DEFAULT_TOTAL_LITRES;
BigDecimal totalLitresFromMinutes = DEFAULT_TOTAL_LITRES
.multiply(totalMinutesBD) // reverse dreisatz
.divide(DEFAULT_TOTAL_TIME_BD, MathContext.DECIMAL64);
do {
calcTotalLitres = calcTotalLitres.subtract(QUARTER_LITRE);
} while (calcTotalLitres.compareTo(totalLitresFromMinutes) >= 0);
// add quarter since we always did a step "too many", due to the do ... while loop
this.totalLitres = calcTotalLitres.add(QUARTER_LITRE);
}
private void showLoadingBar() {
long passedMinutes = getPassedMinutes();
// long passedMinutes = 0; // DEBUG
if (passedMinutes > totalMinutes) {
passedMinutes = totalMinutes;
} else if (passedMinutes < 0) {
var now = LocalTime.now().truncatedTo(ChronoUnit.SECONDS);
println("!ACHTUNG! Startzeit \"" + startTime + ":00\" liegt in der Zukunft von jetzt an (" + now + ") gesehen.");
}
println(minutesToTimeString(totalMinutesBD) + " gesamt; Endzeit: " + TIME_FORMATTER.format(endTime));
while (passedMinutes < totalMinutes) {
print(fillLoadingBar(passedMinutes, true));
waitUntilNextMinute();
passedMinutes++;
}
println(fillLoadingBar(passedMinutes, false));
}
private String fillLoadingBar(long passedMinutes, boolean progressive) {
long effectivePassedMinutes = passedMinutes < 0 ? 0 : passedMinutes;
if (totalMinutes > MINUTES_WITH_PAUSE && passedMinutes > MINUTES_BEFORE_PAUSE && passedMinutes <= MINUTES_WITH_PAUSE) {
effectivePassedMinutes = MINUTES_BEFORE_PAUSE;
}
var effectivePassedMinutesBD = BigDecimal.valueOf(effectivePassedMinutes);
BigDecimal currentLitres = totalLitres
.multiply(effectivePassedMinutesBD) // reverse dreisatz
.divide(totalMinutesBD, MathContext.DECIMAL64)
.add(QUARTER_LITRE);
BigDecimal printedLitres = currentLitres.subtract(currentLitres.remainder(QUARTER_LITRE, MathContext.DECIMAL64));
/* BigDecimal currentProgressToNextStep = ONE_HUNDRED_PERCENT
.multiply(currentLitres.subtract(printedLitres)) // reverse dreisatz
.divide(QUARTER_LITRE, MathContext.DECIMAL64); */
BigDecimal minutesToNextStep = getMinutesToNextStep(currentLitres);
String progressivePart = progressive ? "\r" : "";
return progressivePart + "Aktuelles Volumen: " + LITRE_FORMAT.format(printedLitres) + "L - "
// + PERCENTAGE_FORMAT.format(currentProgressToNextStep) + "% - "
+ minutesToTimeString(minutesToNextStep);
}
private BigDecimal getMinutesToNextStep(BigDecimal currentLitres) {
// berechne Liter benötigt bis zum nächsten 0.25er Schritt
BigDecimal litresToNextStep = QUARTER_LITRE.subtract(currentLitres.remainder(QUARTER_LITRE));
// berechne Minuten benötigt für 1 Liter
BigDecimal minutesPerLitre = totalMinutesBD.divide(totalLitres, MathContext.DECIMAL64);
// berechne Minuten benötigt bis zum nächsten 0.25er Schritt
// runde auf ganze Zahl, da wir nur ganze Minuten anzeigen und damit 1.999 = 2 Minuten sind
return minutesPerLitre.multiply(litresToNextStep).setScale(0, RoundingMode.HALF_EVEN);
}
private String minutesToTimeString(BigDecimal minutes) {
BigDecimal[] hoursAndMinutes = minutes.divideAndRemainder(MINS_PER_HOUR_BD, MC_INTEGER);
return LocalTime.of(hoursAndMinutes[0].intValue(), hoursAndMinutes[1].intValue()).format(TIME_FORMATTER);
}
private void waitUntilNextMinute() {
try {
var now = LocalTime.now();
var oneMinuteLater = now.plusMinutes(1).truncatedTo(ChronoUnit.MINUTES);
/* We wait whole seconds to not make it overly complicated.
That results in cut milliseconds: if we would have to wait 1 second and 526 milliseconds, we wait only 1 second.
So, adjust for ignored milliseconds, add +1 second as it is better to switch between 00 and 01 as between 59 and 00 */
TimeUnit.SECONDS.sleep(now.until(oneMinuteLater, ChronoUnit.SECONDS) + 1);
// TimeUnit.MILLISECONDS.sleep(100L); // DEBUG
} catch (InterruptedException ie) {
Thread.currentThread().interrupt();
throw new RuntimeException(ie);
}
}
}

268
FabianUtil.java
View File

@@ -1,268 +0,0 @@
package de.vorsorge.theo.util;
import java.io.IOException;
import java.math.BigDecimal;
import java.math.MathContext;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.text.DecimalFormat;
import java.time.Duration;
import java.time.ZonedDateTime;
import java.time.temporal.ChronoUnit;
import java.util.concurrent.TimeUnit;
public class FabianUtil {
private static final String STD_DIR_TEMP = "/FIXME/temp/";
public static final String ENDING_TXT = "txt";
public static final String ENDING_JSON = "json";
public static final String ENDING_HTML = "html";
public static final String ENDING_PDF = "pdf";
public static final String ENDING_TIFF = "tiff";
private FabianUtil() {}
public static class ProgressHandler {
private static final DecimalFormat TIME_DECIMAL_FORMAT = new DecimalFormat("00");
protected static final int DEFAULT_LOG_DISTANCE = 50;
protected static final int DEFAULT_TIME_LOG_DISTANCE = 15;
private final ZonedDateTime startTime;
private final BigDecimal logDistance;
private final int timeLogDistance;
private BigDecimal counter = BigDecimal.ZERO;
private ZonedDateTime lastLoggedAt;
public ProgressHandler() {
this(DEFAULT_LOG_DISTANCE, DEFAULT_TIME_LOG_DISTANCE);
}
public ProgressHandler(int logDistance) {
this(logDistance, DEFAULT_TIME_LOG_DISTANCE);
}
public ProgressHandler(int logDistance, int timeLogDistance) {
startTime = ZonedDateTime.now();
this.logDistance = validateBD(logDistance, "Log-Distanz");
this.timeLogDistance = validateInt(timeLogDistance, "Zeitbasierte Log-Distanz");
}
protected BigDecimal validateBD(int bd, String name) {
return BigDecimal.valueOf(validateInt(bd, name));
}
protected int validateInt(int n, String name) {
if (n < 1) {
throw new RuntimeException(name + " darf nicht 0 oder negativ sein.");
}
return n;
}
protected synchronized BigDecimal getCounter() {
return counter;
}
protected synchronized int getTimeLogDistance() {
return timeLogDistance;
}
public synchronized void tickAndLog() {
tick();
logIf();
}
protected synchronized void tick() {
counter = counter.add(BigDecimal.ONE);
}
public synchronized void logAndTick() {
logIf();
tick();
}
public synchronized void logIf() {
if (shouldLog()) {
log();
}
}
protected synchronized boolean shouldLog() {
return counter.remainder(logDistance).signum() == 0 || isBored();
}
private synchronized boolean isBored() {
return getTimeSinceLastLogged() >= timeLogDistance;
}
protected synchronized long getTimeSinceLastLogged() {
ZonedDateTime time = lastLoggedAt == null ? startTime : lastLoggedAt;
return time.until(ZonedDateTime.now(), ChronoUnit.SECONDS);
}
public synchronized void log() {
Duration timePassed = getTimePassed();
System.out.println(counter + " Stück erledigt. " + formatDuration(timePassed) + " vergangen.");
updateLastLoggedAt();
}
protected synchronized void updateLastLoggedAt() {
lastLoggedAt = ZonedDateTime.now();
}
protected synchronized Duration getTimePassed() {
return Duration.ofSeconds(startTime.until(ZonedDateTime.now(), ChronoUnit.SECONDS));
}
protected String formatDuration(Duration dur) {
return formatNumber(dur.toHours()) + ":" + formatNumber(dur.toMinutesPart()) + ":" + formatNumber(dur.toSecondsPart());
}
protected String formatNumber(Number n) {
return TIME_DECIMAL_FORMAT.format(n == null ? 0 : n);
}
public synchronized void logFinal() {
Duration timePassed = getTimePassed();
System.out.println(counter + " Stück (100 %) erledigt. " + formatDuration(timePassed) + " vergangen.");
}
}
public static class ProgressHandlerWithTotal extends ProgressHandler {
private static final DecimalFormat PERCENTAGE_FORMAT = new DecimalFormat("00.00");
private final BigDecimal total;
public ProgressHandlerWithTotal(int total) {
this(DEFAULT_LOG_DISTANCE, DEFAULT_TIME_LOG_DISTANCE, total);
}
public ProgressHandlerWithTotal(int logDistance, int total) {
this(logDistance, DEFAULT_TIME_LOG_DISTANCE, total);
}
public ProgressHandlerWithTotal(int logDistance, int timeLogDistance, int total) {
super(logDistance, timeLogDistance);
this.total = validateBD(total, "Gesamt-Anzahl");
}
@Override
protected synchronized boolean shouldLog() {
return super.shouldLog() && getCounter().compareTo(total) <= 0;
}
@Override
public synchronized void log() {
BigDecimal counter = getCounter();
BigDecimal percentage = BigDecimal.valueOf(100).divide(total, MathContext.DECIMAL64).multiply(counter);
Duration timePassed = getTimePassed();
String remainingTimePart = "";
if (counter.signum() != 0) {
BigDecimal secondsPassed = BigDecimal.valueOf(timePassed.getSeconds());
BigDecimal totalSeconds = secondsPassed.divide(counter, MathContext.DECIMAL64).multiply(total);
BigDecimal secondsToGo = totalSeconds.subtract(secondsPassed);
Duration timeToGo = Duration.of(secondsToGo.longValue(), ChronoUnit.SECONDS);
remainingTimePart = ", " + formatDuration(timeToGo) + " verbleibend";
}
String counterPrint = total.compareTo(BigDecimal.TEN) >= 0 ? formatNumber(counter) : counter.toString();
System.out.println(counterPrint + " Stück von " + total + " (" + PERCENTAGE_FORMAT.format(percentage) + " %) erledigt. "
+ formatDuration(timePassed) + " vergangen" + remainingTimePart + ".");
updateLastLoggedAt();
}
public void logContinuouslyTimeBased() {
new Thread(this::logTimeBased).start();
}
private synchronized void logTimeBased() {
while (getCounter().compareTo(total) != 0) {
logIf();
long timeSinceLastLogged = getTimeSinceLastLogged();
try {
TimeUnit.SECONDS.sleep(timeSinceLastLogged - getTimeLogDistance());
} catch (InterruptedException ie) {
Thread.currentThread().interrupt();
return;
}
}
}
}
public static void writeTestOutput(String filename, String ending, String content) {
writeTestOutput(filename, ending, strToBytes(content));
}
public static byte[] strToBytes(String str) {
return str.getBytes(StandardCharsets.UTF_8);
}
public static void writeTestOutput(String filename, String ending, byte[] content) {
writeToFile(STD_DIR_TEMP + "testOutput/", filename, ending, content);
}
public static void writeDump(String ending, String content) {
writeDump(ending, strToBytes(content));
}
public static void writeDump(String ending, byte[] content) {
writeToFile(STD_DIR_TEMP, "dump", ending, content);
}
public static void writeDump(String filename, String ending, String content) {
writeDump(filename, ending, strToBytes(content));
}
public static void writeDump(String filename, String ending, byte[] content) {
writeToFile(STD_DIR_TEMP, filename, ending, content);
}
public static void writeToFile(String path, String filename, String ending, byte[] content) {
try {
Files.write(Paths.get(path + filename + "." + ending), content);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

164
Java11.java
View File

@@ -1,164 +0,0 @@
import java.awt.Point;
import java.io.IOException;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.*;
import java.util.function.Predicate;
import java.util.stream.Collectors;
class Java11 {
public static void main(String[] args) {
////////
// 1. //
////////
// if the resource is referenced by a final or effectively final variable,
// a try-with-resources statement can manage a resource without a new variable being declared:
MyAutoCloseable mac = new MyAutoCloseable();
try (mac) {
// do some stuff with mac
}
////////
// 2. //
////////
// use diamond operator in conjunction with anonymous inner classes
List<Integer> fc = new ArrayList<>(1) {}; // anonymous inner class
List<? extends Integer> fc0 = new ArrayList<>(1) {
// anonymous inner class
};
List<?> fc1 = new ArrayList<>(1) {}; // anonymous inner class
////////
// 4. //
////////
// Local Variable Type Inference
var message = "Hello, Java 10";
var point = new Point(1, 2);
////////
// 5. //
////////
// immutable Collections/ Maps
Map<String, Integer> meineMap = Map.of();
Set<String> meinSet = Set.of("key1", "key2", "key3");
List<String> meineListe = List.copyOf(meinSet);
////////
// 6. //
////////
// Optional to Stream Optional.stream() gives us an easy way to you use the power of Streams on Optional elements
List<String> filteredList = new ArrayList<Optional<String>>().stream()
.flatMap(Optional::stream)
.collect(Collectors.toList());
////////
// 7. //
////////
// Collectors get additional methods to collect a Stream into unmodifiable List, Map or Set:
List<Integer> evenList = new ArrayList<Integer>().stream()
.filter(i -> i % 2 == 0)
.collect(Collectors.toUnmodifiableList());
////////
// 8. //
////////
// Optional got a new method orElseThrow() which doesn’t take any argument and throws NoSuchElementException if no value is present:
Integer firstEven = List.of(1, 2, 3).stream()
.filter(i -> i % 2 == 0)
.findFirst()
.orElseThrow();
////////
// 9. //
////////
// Java 11 adds a few new methods to the String class
var multilineString = "Baeldung helps \n \n developers \n explore Java.";
List<String> lines = multilineString.lines().collect(Collectors.toList());
assert " ".isBlank();
assert " x ".strip().equals("x");
assert " x ".stripLeading().equals("x ");
assert " x ".stripTrailing().equals(" x");
assert "x".repeat(5).equals("xxxxx");
/////////
// 10. //
/////////
// We can use the new readString and writeString static methods from the Files class:
String fileContent = null;
try {
Path filePath = Files.writeString(Files.createTempFile("demo", ".txt"), "Sample text");
fileContent = Files.readString(filePath);
} catch (IOException ioe) {}
assert fileContent.equals("Sample text");
/////////
// 11. //
/////////
// The java.util.Collection interface contains a new default toArray method which takes an IntFunction argument.
List<String> sampleList = List.of("Java", "Kotlin");
String[] sampleArray = sampleList.toArray(String[]::new);
/////////
// 12. //
/////////
// A static not method has been added to the Predicate interface.
sampleList = List.of("Java", "\n \n", "Kotlin", " ");
List<String> withoutBlanks = sampleList.stream()
.filter(Predicate.not(String::isBlank))
.collect(Collectors.toList());
// While not(isBlank) reads more naturally than isBlank.negate(), the big advantage is that we can also use not with method references,
// like not(String::isBlank).
/////////
// 13. //
/////////
// Support for using the local variable syntax (var keyword) in lambda parameters was added in Java 11.
// We can make use of this feature to apply modifiers to our local variables, like defining a type annotation:
sampleList = List.of("Java", "Kotlin");
String resultString = sampleList.stream()
.map((@Nonnull var x) -> x.toUpperCase())
.collect(Collectors.joining(", "));
assert resultString.equals("JAVA, KOTLIN");
}
}
class MyAutoCloseable implements AutoCloseable {
public void close() {}
}
////////
// 3. //
////////
// Interfaces in the upcoming JVM version can have private methods, which can be used to split lengthy default methods
interface InterfaceWithPrivateMethods {
private static String staticPrivate() {
return "static private";
}
private String instancePrivate() {
return "instance private";
}
default void check() {
String result = staticPrivate();
InterfaceWithPrivateMethods pvt = new InterfaceWithPrivateMethods() {
// anonymous class
};
result = pvt.instancePrivate();
}
}
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.PARAMETER)
@interface Nonnull {}

502
LoadingBar.java
View File

@@ -1,502 +0,0 @@
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;
import java.nio.charset.StandardCharsets;
import java.text.DecimalFormat;
import java.time.format.DateTimeFormatter;
import java.time.LocalTime;
import java.time.temporal.ChronoUnit;
import java.util.Arrays;
import java.util.concurrent.TimeUnit;
import java.util.List;
import java.util.Objects;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
public class LoadingBar {
private static final String TIME_FORMAT = "HH:mm";
private static final DateTimeFormatter TIME_FORMATTER = DateTimeFormatter.ofPattern(TIME_FORMAT);
private static final Pattern TIME_PATTERN = Pattern.compile("(?>[01]\\d|2[0-4]):[0-5]\\d");
private static final Pattern LUNCH_DURATION_PATTERN = Pattern.compile("\\d+");
private static final Pattern OFFSET_PATTERN = Pattern.compile("[+-]\\d+");
private static final DecimalFormat PERCENTAGE_FORMAT = new DecimalFormat("00.00");
private static final int MIN_LUNCH_DURATION = 30;
private static final LocalTime LATEST_LUNCH_TIME = LocalTime.of(13, 30);
private static final int MINS_PER_HOUR = 60;
private static final BigDecimal MINS_PER_HOUR_BD = BigDecimal.valueOf(MINS_PER_HOUR);
private static final long DEFAULT_NUMBER_WORK_MINS_BEFORE_LUNCH = 5L * MINS_PER_HOUR;
private static final int MAX_NUMBER_WORK_MINS_WITHOUT_LUNCH = 6 * MINS_PER_HOUR;
private static final long MAX_NUMBER_WORK_MINS = 8L * MINS_PER_HOUR;
private static final int LINE_LENGTH = 100;
private static final MathContext MC_INTEGER = new MathContext(1, RoundingMode.HALF_EVEN);
private static final BigDecimal ONE_HUNDRED_PERCENT = BigDecimal.valueOf(100);
private enum DaySection {
MITTAG("-m", "Mittag"),
ZAPFENSTREICH("-z", "Zapfenstreich");
private final String param;
private final String description;
DaySection(String param, String description) {
this.param = param;
this.description = description;
}
public static DaySection byParam(String param) {
return Arrays.stream(DaySection.values()).filter((DaySection section) -> section.getParam().equals(param)).findFirst().orElse(null);
}
public String getParam() {
return param;
}
public String getDescription() {
return description;
}
}
private final LocalTime startTime;
private LocalTime endTime;
private long totalMinutes;
private BigDecimal totalMinutesBD;
private LoadingBar(LocalTime startTime) {
this.startTime = startTime;
}
public static void main(String[] args) throws IOException {
if (args.length == 0) {
askParametersAndRun();
} else {
parseParametersAndRun(args);
}
}
private static void askParametersAndRun() throws IOException {
var br = new BufferedReader(new InputStreamReader(System.in, StandardCharsets.UTF_8));
print("Ankunftszeit: ");
var startTime = LocalTime.parse(br.readLine(), TIME_FORMATTER).truncatedTo(ChronoUnit.MINUTES);
var lb = new LoadingBar(startTime);
if (lb.hasMittagspauseArrived()) {
handleMittagspause(br, lb);
lb.showLoadingBar();
}
handleZapfenstreich(br, lb);
lb.showLoadingBar();
}
private static void println(Object o) {
System.out.println(o);
}
private static void print(Object o) {
System.out.print(o);
}
private static void handleMittagspause(BufferedReader br, LoadingBar lb) throws IOException {
print("Mittagspause verschieben um (optional): ");
String mittagspauseOffsetRaw = br.readLine();
if (mittagspauseOffsetRaw != null && !mittagspauseOffsetRaw.isBlank()) {
var mittagspauseOffset = Integer.parseInt(mittagspauseOffsetRaw);
lb.initMittagspause(mittagspauseOffset);
return;
}
print("Mittagspause um (optional): ");
String manualMittagspauseRaw = br.readLine();
if (manualMittagspauseRaw != null && !manualMittagspauseRaw.isBlank()) {
var manualMittagspause = LocalTime.parse(manualMittagspauseRaw, TIME_FORMATTER).truncatedTo(ChronoUnit.MINUTES);
lb.initMittagspause(manualMittagspause);
} else {
lb.initMittagspause();
}
}
private static void handleZapfenstreich(BufferedReader br, LoadingBar lb) throws IOException {
print("Mittagspause hat gedauert (optional): ");
String mittagspauseDurationRaw = br.readLine();
Integer mittagspauseDuration = null;
if (mittagspauseDurationRaw != null && !mittagspauseDurationRaw.isBlank()) {
mittagspauseDuration = Integer.valueOf(mittagspauseDurationRaw);
}
LocalTime vorlaeufigeEndzeit = lb.startTime.plusMinutes(MAX_NUMBER_WORK_MINS)
.plusMinutes(mittagspauseDuration != null ? mittagspauseDuration : MIN_LUNCH_DURATION);
println("Endzeit: " + TIME_FORMATTER.format(vorlaeufigeEndzeit));
print("Feierabend verschieben um (optional): ");
String zapfenstreichOffsetRaw = br.readLine();
Integer zapfenstreichOffset = null;
if (zapfenstreichOffsetRaw != null && !zapfenstreichOffsetRaw.isBlank()) {
zapfenstreichOffset = Integer.valueOf(zapfenstreichOffsetRaw);
lb.initZapfenstreich(mittagspauseDuration, zapfenstreichOffset);
return;
}
print("Manuelle Uhrzeit Feierabend (optional): ");
String manualZapfenstreichRaw = br.readLine();
LocalTime manualZapfenstreich = null;
if (manualZapfenstreichRaw != null && !manualZapfenstreichRaw.isBlank()) {
manualZapfenstreich = LocalTime.parse(manualZapfenstreichRaw, TIME_FORMATTER).truncatedTo(ChronoUnit.MINUTES);
lb.initZapfenstreich(mittagspauseDuration, manualZapfenstreich);
} else {
lb.initZapfenstreich(mittagspauseDuration);
}
}
private static void parseParametersAndRun(String[] args) {
LoadingBar lb = getLoadingBarFromCLI(args);
lb.showLoadingBar();
}
private static LoadingBar getLoadingBarFromCLI(String[] args) {
String nextArg = args[0];
if ("--help".equals(nextArg)) {
printHelp();
System.exit(1);
}
verifyMinimumNumberOfArgs(args);
verifyTimeFormat(nextArg, "Erstes Argument");
var startTime = LocalTime.parse(nextArg, TIME_FORMATTER).truncatedTo(ChronoUnit.MINUTES);
nextArg = args[1];
var section = DaySection.byParam(nextArg);
verifyDaySection(section, nextArg);
return section == DaySection.MITTAG ? getLoadingBarMittagspause(args, startTime) : getLoadingBarZapfenstreich(args, startTime);
}
private static LoadingBar getLoadingBarMittagspause(String[] args, LocalTime startTime) {
var lb = new LoadingBar(startTime);
if (args.length == 2) {
lb.initMittagspause();
return lb;
}
String nextArg = args[2];
if (OFFSET_PATTERN.matcher(nextArg).matches()) {
lb.initMittagspause(Integer.parseInt(nextArg));
return lb;
}
verifyTimeFormat(nextArg, "Argument nach " + DaySection.MITTAG.getParam());
var manualMittagspause = LocalTime.parse(nextArg, TIME_FORMATTER).truncatedTo(ChronoUnit.MINUTES);
lb.initMittagspause(manualMittagspause);
return lb;
}
private static LoadingBar getLoadingBarZapfenstreich(String[] args, LocalTime startTime) {
var lb = new LoadingBar(startTime);
if (args.length == 2) {
lb.initZapfenstreich();
return lb;
}
String nextArg = args[2];
LocalTime maxZapfenstreich = null;
int endTimeOffset = 0;
Integer lunchDuration = null;
if (TIME_PATTERN.matcher(nextArg).matches()) {
maxZapfenstreich = LocalTime.parse(nextArg, TIME_FORMATTER).truncatedTo(ChronoUnit.MINUTES);
} else if (OFFSET_PATTERN.matcher(nextArg).matches()) {
endTimeOffset = Integer.parseInt(nextArg);
} else {
verifyDurationFormat(nextArg, "Argument nach " + DaySection.ZAPFENSTREICH.getParam());
lunchDuration = Integer.parseInt(nextArg);
}
if (args.length == 3) {
if (maxZapfenstreich == null && endTimeOffset == 0) {
lb.initZapfenstreich(lunchDuration);
} else if (maxZapfenstreich == null) {
lb.initZapfenstreich(lunchDuration, endTimeOffset);
} else {
lb.initZapfenstreich(lunchDuration, maxZapfenstreich);
}
return lb;
}
nextArg = args[3];
if (lunchDuration == null) {
println("Letztes Argument darf nur auf Mittagspausendauer folgen.");
System.exit(1);
}
if (maxZapfenstreich == null && !OFFSET_PATTERN.matcher(nextArg).matches()) {
verifyTimeFormat(nextArg, "Letztes Argument nach " + DaySection.ZAPFENSTREICH.getParam() + " und Mittagspausendauer");
maxZapfenstreich = LocalTime.parse(nextArg, TIME_FORMATTER).truncatedTo(ChronoUnit.MINUTES);
lb.initZapfenstreich(lunchDuration, maxZapfenstreich);
return lb;
}
verifyOffsetFormat(nextArg, "Letztes Argument nach " + DaySection.ZAPFENSTREICH.getParam() + " und Enduhrzeit");
endTimeOffset = Integer.parseInt(nextArg);
lb.initZapfenstreich(lunchDuration, endTimeOffset);
return lb;
}
private static void verifyMinimumNumberOfArgs(String[] args) {
if (args.length >= 2) {
return;
}
println("Mindestens 2 Argumente müssen gegeben sein.");
printHelp();
System.exit(1);
}
private static void verifyTimeFormat(String param, String errMsgPrefix) {
verifyInputFormat(TIME_PATTERN, param, errMsgPrefix, "Uhrzeitformat (" + TIME_FORMAT + ")", false);
}
private static void verifyDurationFormat(String param, String errMsgPrefix) {
verifyInputFormat(LUNCH_DURATION_PATTERN, param, errMsgPrefix, "Minutenanzahl (ganze Zahl)", true);
}
private static void verifyOffsetFormat(String param, String errMsgPrefix) {
verifyInputFormat(OFFSET_PATTERN, param, errMsgPrefix, "Minutendifferenz (ganze Zahl mit Vorzeichen)", false);
}
private static void verifyInputFormat(Pattern pattern, String param, String errMsgPrefix, String firstInputPart, boolean timeInputPossible) {
if (pattern.matcher(param).matches()) {
return;
}
var possibleTimeInputPart = timeInputPossible ? " oder Uhrzeitformat (" + TIME_FORMAT + ")" : "";
println(errMsgPrefix + " \"" + param + "\" muss " + firstInputPart + possibleTimeInputPart + " entsprechen.");
System.exit(1);
}
private static void verifyDaySection(DaySection section, String param) {
if (section != null) {
return;
}
List<String> sectionDescs = Arrays.stream(DaySection.values()).map((DaySection ds) -> ds.getDescription() + " (" + ds.getParam() + ")")
.collect(Collectors.toList());
String sectionDescsJoined = String.join(" oder ", sectionDescs);
println("Argument nach Startzeit \"" + param + "\" muss Angabe für " + sectionDescsJoined + " sein.");
System.exit(1);
}
private static void printHelp() {
println("Mögliche Argumente für LoadingBar:\n"
+ "Normalfall Vormittag (Mittagspause <= " + LATEST_LUNCH_TIME + ")\n"
+ TIME_FORMAT + " " + DaySection.MITTAG.getParam() + "\n"
+ "Vormittag mit expliziter Mittagspause (<= " + LATEST_LUNCH_TIME + ")\n"
+ TIME_FORMAT + " " + DaySection.MITTAG.getParam() + " " + TIME_FORMAT + "\n"
+ "Vormittag mit abweichender Minutenanzahl Arbeitszeit\n"
+ TIME_FORMAT + " " + DaySection.MITTAG.getParam() + " -+mm\n"
+ "Normalfall Nachmittag (Mittagspause " + MIN_LUNCH_DURATION + " min)\n"
+ TIME_FORMAT + " " + DaySection.ZAPFENSTREICH.getParam() + "\n"
+ "Nachmittag mit expliziter Länge Mittagspause (Mittagspause unter " + MIN_LUNCH_DURATION + " min wird auf " + MIN_LUNCH_DURATION + " min korrigiert)\n"
+ TIME_FORMAT + " " + DaySection.ZAPFENSTREICH.getParam() + " mm\n"
+ "Nachmittag mit explizitem Feierabend (Mittagspause je nach Minimum (s.u.))\n"
+ TIME_FORMAT + " " + DaySection.ZAPFENSTREICH.getParam() + " " + TIME_FORMAT + "\n"
+ "Nachmittag mit abweichender Minutenanzahl Arbeitszeit\n"
+ TIME_FORMAT + " " + DaySection.ZAPFENSTREICH.getParam() + " -+mm\n"
+ "Nachmittag mit explizitem Feierabend u. expliziter Länge Mittagspause (Mittagspause unter Minimum (s.u.) wird auf Minimum korrigiert)\n"
+ TIME_FORMAT + " " + DaySection.ZAPFENSTREICH.getParam() + " mm " + TIME_FORMAT + "\n"
+ "Nachmittag mit explizitem Feierabend u. abweichender Minutenanzahl Arbeitszeit\n"
+ TIME_FORMAT + " " + DaySection.ZAPFENSTREICH.getParam() + " " + TIME_FORMAT + " -+mm\n\n"
+ "Mittagspause minimum in Minuten:\n"
+ " - bis " + MAX_NUMBER_WORK_MINS_WITHOUT_LUNCH + " min ("
+ MAX_NUMBER_WORK_MINS_WITHOUT_LUNCH / MINS_PER_HOUR + " std): 0\n"
+ " - bis " + MAX_NUMBER_WORK_MINS_WITHOUT_LUNCH + " min + "
+ MIN_LUNCH_DURATION + " min: Arbeitszeit - " + MAX_NUMBER_WORK_MINS_WITHOUT_LUNCH + " min\n"
+ " - ab " + MAX_NUMBER_WORK_MINS_WITHOUT_LUNCH + " min + " + MIN_LUNCH_DURATION + " min: "
+ MIN_LUNCH_DURATION + " min\n"
);
}
protected long getPassedMinutes() {
return startTime.until(LocalTime.now().truncatedTo(ChronoUnit.MINUTES), ChronoUnit.MINUTES);
}
private void setEndTime(LocalTime endTime) {
this.endTime = endTime;
this.totalMinutes = startTime.until(endTime, ChronoUnit.MINUTES);
this.totalMinutesBD = BigDecimal.valueOf(totalMinutes);
}
private boolean hasMittagspauseArrived() {
return startTime.until(LocalTime.now(), ChronoUnit.MINUTES) < DEFAULT_NUMBER_WORK_MINS_BEFORE_LUNCH;
}
private void initMittagspause() {
LocalTime defaultEndTime = startTime.plusMinutes(DEFAULT_NUMBER_WORK_MINS_BEFORE_LUNCH);
realInitMittagspause(defaultEndTime);
}
private void initMittagspause(int endTimeOffset) {
LocalTime offsetEndTime = startTime.plusMinutes(DEFAULT_NUMBER_WORK_MINS_BEFORE_LUNCH + endTimeOffset);
realInitMittagspause(offsetEndTime);
}
private void initMittagspause(LocalTime manualEndTime) {
LocalTime effectiveEndTime = manualEndTime != null ? manualEndTime : startTime.plusMinutes(DEFAULT_NUMBER_WORK_MINS_BEFORE_LUNCH);
realInitMittagspause(effectiveEndTime);
}
private void realInitMittagspause(LocalTime theoreticalEndTime) {
setEndTime(theoreticalEndTime.isAfter(LATEST_LUNCH_TIME) ? LATEST_LUNCH_TIME : theoreticalEndTime);
}
private void initZapfenstreich() {
LocalTime trueEndTime = startTime.plusMinutes(MAX_NUMBER_WORK_MINS + MIN_LUNCH_DURATION);
realInitZapfenstreich(MIN_LUNCH_DURATION, trueEndTime);
}
private void initZapfenstreich(Integer manualLunchDuration) {
initZapfenstreich(manualLunchDuration, 0);
}
private void initZapfenstreich(Integer manualLunchDuration, int endTimeOffset) {
long minLunchDuration = getMinLunchDuration(endTimeOffset);
long realLunchDuration = getRealLunchDuration(manualLunchDuration, minLunchDuration);
LocalTime trueEndTime = startTime.plusMinutes(MAX_NUMBER_WORK_MINS + realLunchDuration + endTimeOffset);
realInitZapfenstreich(realLunchDuration, trueEndTime);
}
private void initZapfenstreich(Integer manualLunchDuration, LocalTime manualEndTime) {
LocalTime trueEndTime = manualEndTime;
long minLunchDuration = getMinLunchDuration(trueEndTime);
long realLunchDuration = getRealLunchDuration(manualLunchDuration, minLunchDuration);
if (trueEndTime == null) {
trueEndTime = startTime.plusMinutes(MAX_NUMBER_WORK_MINS + realLunchDuration);
}
realInitZapfenstreich(realLunchDuration, trueEndTime);
}
private long getMinLunchDuration(int endTimeOffset) {
if (endTimeOffset == 0) {
return MIN_LUNCH_DURATION;
}
long totalDuration = MAX_NUMBER_WORK_MINS + endTimeOffset;
return getMinLunchDuration(totalDuration);
}
private long getMinLunchDuration(LocalTime manualEndTime) {
if (manualEndTime == null) {
return MIN_LUNCH_DURATION;
}
long totalDuration = startTime.until(manualEndTime, ChronoUnit.MINUTES);
return getMinLunchDuration(totalDuration);
}
private long getMinLunchDuration(long precalculatedTotalDuration) {
long effectiveLunchDuration = precalculatedTotalDuration - MAX_NUMBER_WORK_MINS_WITHOUT_LUNCH;
if (effectiveLunchDuration < 0) {
effectiveLunchDuration = 0;
}
return Math.min(effectiveLunchDuration, MIN_LUNCH_DURATION);
}
private long getRealLunchDuration(Integer manualLunchDuration, long minLunchDuration) {
return manualLunchDuration != null && manualLunchDuration >= minLunchDuration ? manualLunchDuration : minLunchDuration;
}
private void realInitZapfenstreich(long effectiveLunchDuration, LocalTime effectiveEndTime) {
if (effectiveLunchDuration > 0) {
var totalWorkTime = LocalTime.MIDNIGHT.plusMinutes(startTime.until(effectiveEndTime, ChronoUnit.MINUTES) - effectiveLunchDuration);
print("Arbeitszeit: " + TIME_FORMATTER.format(totalWorkTime) + "; ");
}
setEndTime(effectiveEndTime);
}
private void showLoadingBar() {
long passedMinutes = getPassedMinutes();
// long passedMinutes = 0; // DEBUG
if (passedMinutes > totalMinutes) {
passedMinutes = totalMinutes;
} else if (passedMinutes < 0) {
var now = LocalTime.now().truncatedTo(ChronoUnit.SECONDS);
println("!ACHTUNG! Startzeit \"" + startTime + ":00\" liegt in der Zukunft von jetzt an (" + now + ") gesehen.");
}
println(minutesToTimeString(totalMinutesBD) + " gesamt; Endzeit: " + TIME_FORMATTER.format(endTime));
while (passedMinutes < totalMinutes) {
print(fillLoadingBar(passedMinutes, true));
waitUntilNextMinute();
passedMinutes++;
}
println(fillLoadingBar(passedMinutes, false));
}
private void waitUntilNextMinute() {
try {
var now = LocalTime.now();
var oneMinuteLater = now.plusMinutes(1).truncatedTo(ChronoUnit.MINUTES);
/* We wait whole seconds to not make it overly complicated.
That results in cut milliseconds: if we would have to wait 1 second and 526 milliseconds, we wait only 1 second.
So, adjust for ignored milliseconds, add +1 second as it is better to switch between 00 and 01 as between 59 and 00 */
TimeUnit.SECONDS.sleep(now.until(oneMinuteLater, ChronoUnit.SECONDS) + 1);
// TimeUnit.MILLISECONDS.sleep(100L); // DEBUG
} catch (InterruptedException ie) {
Thread.currentThread().interrupt();
throw new RuntimeException(ie);
}
}
private String fillLoadingBar(long passedMinutes, boolean progressive) {
var nonNegativePassedMinutes = BigDecimal.valueOf(passedMinutes < 0 ? 0 : passedMinutes);
BigDecimal wholePercentage = ONE_HUNDRED_PERCENT
// kind of reverse dreisatz to avoid having e.g. 99.9999 instead of 100 %
.multiply(nonNegativePassedMinutes)
.divide(totalMinutesBD, MathContext.DECIMAL64);
int numberOfEquals = wholePercentage.intValue();
var sb = new StringBuilder("[");
for (int i = 0; i < LINE_LENGTH; i++) {
if (i < numberOfEquals) {
sb.append("=");
} else {
sb.append("-");
}
}
BigDecimal remainingMinutes = totalMinutesBD.subtract(nonNegativePassedMinutes);
sb.append("] ").append(PERCENTAGE_FORMAT.format(wholePercentage)).append("% ")
.append(minutesToTimeString(nonNegativePassedMinutes)).append(" - ").append(minutesToTimeString(remainingMinutes));
if (progressive) {
sb.append("\r");
}
return sb.toString();
}
private String minutesToTimeString(BigDecimal minutes) {
BigDecimal[] hoursAndMinutes = minutes.divideAndRemainder(MINS_PER_HOUR_BD, MC_INTEGER);
return LocalTime.of(hoursAndMinutes[0].intValue(), hoursAndMinutes[1].intValue()).format(TIME_FORMATTER);
}
}

200
SimpleLoadingBar.java
View File

@@ -1,200 +0,0 @@
import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.Objects;
import java.util.concurrent.TimeUnit;
import java.util.regex.Pattern;
public class SimpleLoadingBar {
private static final String TIME_FORMAT = "HH:mm";
private static final DateTimeFormatter TIME_FORMATTER = DateTimeFormatter.ofPattern(TIME_FORMAT);
private static final Pattern TIME_PATTERN = Pattern.compile("(?>[01]\\d|2[0-4]):[0-5]\\d");
private static final DecimalFormat PERCENTAGE_FORMAT = new DecimalFormat("00.00");
private static final int MINS_PER_HOUR = 60;
private static final BigDecimal MINS_PER_HOUR_BD = BigDecimal.valueOf(MINS_PER_HOUR);
private static final int LINE_LENGTH = 100;
private static final MathContext MC_INTEGER = new MathContext(1, RoundingMode.HALF_EVEN);
private static final BigDecimal ONE_HUNDRED_PERCENT = BigDecimal.valueOf(100);
private final String title;
private final LocalTime startTime;
private LocalTime endTime;
private long totalMinutes;
private BigDecimal totalMinutesBD;
private SimpleLoadingBar(LocalTime startTime, LocalTime endTime, String title) {
this.startTime = startTime;
setEndTime(endTime);
this.title = initTitle(title);
}
public static void main(String[] args) {
if (args.length > 0 && Objects.equals(args[0], "--help")) {
printHelp();
return;
}
verifyMinimumNumberOfArgs(args);
String nextArg = args[0];
verifyTimeFormat(nextArg, "Erstes Argument");
var firstTime = LocalTime.parse(nextArg, TIME_FORMATTER);
LocalTime startTime = null;
String title = "";
LocalTime endTime = null;
if (args.length > 1) {
nextArg = args[1];
if ("-msg".equals(nextArg)) {
title = args.length > 2 ? args[2] : title;
} else {
verifyTimeFormat(nextArg, "Zweites Argument");
endTime = LocalTime.parse(nextArg, TIME_FORMATTER);
}
}
if (endTime == null) {
startTime = LocalTime.now();
endTime = firstTime;
} else {
startTime = firstTime;
}
if (args.length == 2 || !title.isBlank()) {
new SimpleLoadingBar(startTime, endTime, title).showLoadingBar();
return;
}
// if there are 3 arguments, the third will be discarded.
boolean hasTitleArg = args.length > 3 && "-msg".equals(args[2]);
title = hasTitleArg ? args[3] : title;
new SimpleLoadingBar(startTime, endTime, title).showLoadingBar();
}
private static void println(Object o) {
System.out.println(o);
}
private static void print(Object o) {
System.out.print(o);
}
private static void printHelp() {
println("Mögliche Argumente für LoadingBar:\n"
+ "Startzeit, Endzeit, Endnachricht (Optional)\n"
+ TIME_FORMAT + " " + TIME_FORMAT + " -msg <Nachricht>\n"
+ "Endzeit (Startzeit = jetzt), Endnachricht (Optional)\n"
+ TIME_FORMAT + " -msg <Nachricht>\n"
);
}
private static void verifyMinimumNumberOfArgs(String[] args) {
if (args.length >= 1) {
return;
}
println("Mindestens 1 Argument muss gegeben sein.");
printHelp();
System.exit(1);
}
private static void verifyTimeFormat(String param, String errMsgPrefix) {
if (TIME_PATTERN.matcher(param).matches()) {
return;
}
println(errMsgPrefix + " \"" + param + "\" muss Uhrzeitformat (" + TIME_FORMAT + ") entsprechen.");
System.exit(1);
}
protected long getPassedMinutes() {
return startTime.until(LocalTime.now().truncatedTo(ChronoUnit.MINUTES), ChronoUnit.MINUTES);
}
private void setEndTime(LocalTime endTime) {
this.endTime = endTime;
this.totalMinutes = startTime.until(endTime, ChronoUnit.MINUTES);
this.totalMinutesBD = BigDecimal.valueOf(totalMinutes);
}
private String initTitle(String inputTitle) {
String fallbackTitle = "Ende! Endzeit " + TIME_FORMATTER.format(endTime) + " erreicht.";
String effectiveTitle = inputTitle == null || inputTitle.isBlank() ? fallbackTitle : inputTitle;
String separator = "*".repeat(effectiveTitle.length());
return separator + "\n" + effectiveTitle + "\n" + separator;
}
private void showLoadingBar() {
long passedMinutes = getPassedMinutes();
// long passedMinutes = 0; // DEBUG
if (passedMinutes > totalMinutes) {
passedMinutes = totalMinutes;
} else if (passedMinutes < 0) {
var now = LocalTime.now().truncatedTo(ChronoUnit.SECONDS);
println("!ACHTUNG! Startzeit \"" + startTime + ":00\" liegt in der Zukunft von jetzt an (" + now + ") gesehen.");
}
println(minutesToTimeString(totalMinutesBD) + " gesamt; Endzeit: " + TIME_FORMATTER.format(endTime));
while (passedMinutes < totalMinutes) {
print(fillLoadingBar(passedMinutes, true));
waitUntilNextMinute();
passedMinutes++;
}
println(fillLoadingBar(passedMinutes, false));
println(title);
}
private String fillLoadingBar(long passedMinutes, boolean progressive) {
var nonNegativePassedMinutes = BigDecimal.valueOf(passedMinutes < 0 ? 0 : passedMinutes);
BigDecimal wholePercentage = ONE_HUNDRED_PERCENT
// kind of reverse dreisatz to avoid having e.g. 99.9999 instead of 100 %
.multiply(nonNegativePassedMinutes)
.divide(totalMinutesBD, MathContext.DECIMAL64);
int numberOfEquals = wholePercentage.intValue();
var sb = new StringBuilder("[");
for (int i = 0; i < LINE_LENGTH; i++) {
if (i < numberOfEquals) {
sb.append("=");
} else {
sb.append("-");
}
}
BigDecimal remainingMinutes = totalMinutesBD.subtract(nonNegativePassedMinutes);
sb.append("] ").append(PERCENTAGE_FORMAT.format(wholePercentage)).append("% ")
.append(minutesToTimeString(nonNegativePassedMinutes)).append(" - ").append(minutesToTimeString(remainingMinutes));
if (progressive) {
sb.append("\r");
}
return sb.toString();
}
private String minutesToTimeString(BigDecimal minutes) {
BigDecimal[] hoursAndMinutes = minutes.divideAndRemainder(MINS_PER_HOUR_BD, MC_INTEGER);
return LocalTime.of(hoursAndMinutes[0].intValue(), hoursAndMinutes[1].intValue()).format(TIME_FORMATTER);
}
private void waitUntilNextMinute() {
try {
var now = LocalTime.now();
var oneMinuteLater = now.plusMinutes(1).truncatedTo(ChronoUnit.MINUTES);
/* We wait whole seconds to not make it overly complicated.
That results in cut milliseconds: if we would have to wait 1 second and 526 milliseconds, we wait only 1 second.
So, adjust for ignored milliseconds, add +1 second as it is better to switch between 00 and 01 as between 59 and 00 */
TimeUnit.SECONDS.sleep(now.until(oneMinuteLater, ChronoUnit.SECONDS) + 1);
// TimeUnit.MILLISECONDS.sleep(100L); // DEBUG
} catch (InterruptedException ie) {
Thread.currentThread().interrupt();
throw new RuntimeException(ie);
}
}
}