helper methods for printing to stdout

- drucke letzte Summe Kreditjahr nach Ablauf

Darlehenberechner.java

@@ -1,5 +1,9 @@
+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;
@@ -12,11 +16,13 @@ class Darlehenberechner {
    private static final class Konfiguration {
 
       private BigDecimal darlehenswert;
-      private BigDecimal zinssatzProzent;
+      private BigDecimal zinssatzReal;
       private BigDecimal monatlicheRate;
-      private Integer laufzeitJahre;
+      private Integer laufzeitMonate;
+      private BigDecimal restschuld;
       private Integer tilgungsfreieZeit;
       private YearMonth anfangsmonat;
+      private BigDecimal sondertilgungReal;
 
 
       public BigDecimal getDarlehenswert() {
@@ -30,13 +36,13 @@ class Darlehenberechner {
       }
 
 
-      public BigDecimal getZinssatzProzent() {
+      public BigDecimal getZinssatz() {
-         return zinssatzProzent;
+         return zinssatzReal;
       }
 
 
       public Konfiguration setZinssatzProzent(BigDecimal zinssatzProzent) {
-         this.zinssatzProzent = zinssatzProzent;
+         this.zinssatzReal = zinssatzProzent.divide(EINHUNDERT, MathContext.DECIMAL128);
          return this;
       }
 
@@ -52,13 +58,30 @@ class Darlehenberechner {
       }
 
 
-      public Integer getLaufzeitJahre() {
+      public Integer getLaufzeitMonate() {
-         return laufzeitJahre;
+         return laufzeitMonate;
       }
 
 
-      public Konfiguration setLaufzeitJahre(Integer laufzeitJahre) {
+      public Konfiguration setLaufzeitMonate(Integer laufzeitMonate) {
-         this.laufzeitJahre = laufzeitJahre;
+         this.laufzeitMonate = laufzeitMonate;
+         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;
       }
 
@@ -83,128 +106,304 @@ class Darlehenberechner {
          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);
 
-      public static void main(String[] args) throws ParseException {
+   private final Integer laufzeitMonate;
-         /*berechneWerte(new Konfiguration()
+   private final BigDecimal restschuld;
-            .setDarlehenswert(BigDecimal.valueOf(168_000))
+   private final BigDecimal zinssatz;
-            .setZinssatzProzent(BigDecimal.valueOf(3.73))
+   private BigDecimal sondertilgung;
-            .setMonatlicheRate(BigDecimal.valueOf(1_500))
+   private int summeMonate = 0;
-            .setTilgungsfreieZeit(0)
+   private BigDecimal aktRestschuld;
-            .setAnfangsmonat(YearMonth.of(2024, Month.SEPTEMBER)));
+   private BigDecimal aktMonatlicheRate;
-         return;*/
+   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;
 
-         /*berechneWerte(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)));
-         return;*/
 
-         var konfig = new Konfiguration();
+   public static void main(String[] args) throws ParseException, IOException {
-         int count = 0;
+      /*new Darlehenberechner(new Konfiguration()
-         DECIMAL_FORMAT.setParseBigDecimal(true);
+         .setDarlehenswert(BigDecimal.valueOf(168_000))
-         while (count < args.length) {
+         .setZinssatzProzent(BigDecimal.valueOf(3.73))
-            String arg = args[count];
+         .setMonatlicheRate(BigDecimal.valueOf(1_500))
-            if (arg.equals("-hilfe")) {
+         .setTilgungsfreieZeit(0)
-               System.out.println("-darlehenswert 1000,00 -zinssatz 3,73 -monatlicheRate 30,00 -anfangsmonat 2024-09"
+         .setAnfangsmonat(YearMonth.of(2024, Month.SEPTEMBER))
-                  + "[-laufzeitJahre 11] [-tilgungsfreieZeit 5]");
+         .setSondertilgungProzent(BigDecimal.valueOf(2.5))
-            }
+      ).berechneWerte();*/
-            if (arg.equals("-darlehenswert")) {
+
-               count++;
+      /*new Darlehenberechner(new Konfiguration()
-               konfig.setDarlehenswert((BigDecimal) DECIMAL_FORMAT.parse(args[count]));
+         .setDarlehenswert(BigDecimal.valueOf(168_000))
-            }
+         .setZinssatzProzent(BigDecimal.valueOf(3.73))
-            if (arg.equals("-zinssatz")) {
+         .setMonatlicheRate(BigDecimal.valueOf(1_500))
-               count++;
+         .setTilgungsfreieZeit(0)
-               konfig.setZinssatzProzent((BigDecimal) DECIMAL_FORMAT.parse(args[count]));
+         .setLaufzeitJahre(11)
-            }
+         .setAnfangsmonat(YearMonth.of(2024, Month.SEPTEMBER))
-            if (arg.equals("-monatlicheRate")) {
+      ).berechneWerte();*/
-               count++;
+
-               konfig.setMonatlicheRate((BigDecimal) DECIMAL_FORMAT.parse(args[count]));
+      if (args.length == 0) {
-            }
+         askParametersAndRun();
-            if (arg.equals("-tilgungsfreieZeit")) {
+      } else {
-               count++;
+         parseParametersAndRun(args);
-               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++;
-         }
-         berechneWerte(konfig);
    }
 
 
-   private static void berechneWerte(Konfiguration konfig) {
+   private static void askParametersAndRun() throws IOException {
-      BigDecimal zinssatzReal = konfig.getZinssatzProzent().divide(BigDecimal.valueOf(100), MathContext.DECIMAL128);
+      DECIMAL_FORMAT.setParseBigDecimal(true);
-      BigDecimal monatlicheRate = konfig.getMonatlicheRate();
+
-      Integer laufzeitJahre = konfig.getLaufzeitJahre();
+      var konfig = new Konfiguration();
-      Integer tilgungsfreieZeit = konfig.getTilgungsfreieZeit();
+      var br = new BufferedReader(new InputStreamReader(System.in, StandardCharsets.UTF_8));
-      BigDecimal restschuld = konfig.getDarlehenswert();
+      System.out.print("Darlehenswert: ");
-      YearMonth aktuellerMonat = konfig.getAnfangsmonat();
+      konfig.setDarlehenswert((BigDecimal) DECIMAL_FORMAT.parse(br.readLine()));
-      BigDecimal summeZinsen = BigDecimal.ZERO;
+      System.out.print("Zinssatz: ");
-      BigDecimal summeTilgung = BigDecimal.ZERO;
+      konfig.setZinssatzProzent((BigDecimal) DECIMAL_FORMAT.parse(br.readLine()));
-      BigDecimal jahressummeRatenKalenderjahr = BigDecimal.ZERO;
+      System.out.print("Monatliche Rate: ");
-      BigDecimal jahressummeRatenKreditjahr = BigDecimal.ZERO;
+      konfig.setMonatlicheRate((BigDecimal) DECIMAL_FORMAT.parse(br.readLine()));
-      BigDecimal summeRaten = BigDecimal.ZERO;
+      System.out.print("Monat erste Rate(z.B. 2007-12): ");
-      int laufzeitMonate = 0;
+      konfig.setAnfangsmonat(YearMonth.parse(br.readLine()));
-      System.out.println("Monat:   Rate     = Zinsen + Tilgung| Restschuld");
+      System.out.print("Laufzeit in Jahren(optional Jahre:Monate): ");
-      while ((laufzeitJahre == null || laufzeitMonate < (laufzeitJahre * 12)) && restschuld.signum() > 0) {
+      String in = br.readLine();
-         // berechne Beträge/ aktualisiere Restschuld
+      if (in != null && !in.isBlank()) {
-         BigDecimal zinsbetrag = restschuld.multiply(zinssatzReal).divide(ZWOELF, MathContext.DECIMAL128);
+         String[] split = in.split(":");
-         if (monatlicheRate.compareTo(restschuld) > 0) {
+         konfig.setLaufzeit(Integer.parseInt(split[0]), Integer.parseInt(split[1]));
-            monatlicheRate = restschuld.add(zinsbetrag); // die letzte Rate ist gleich der Restschuld + Zinsen
+      } else {
-         }
+         System.out.print("Restschuld(optional): ");
-         BigDecimal tilgungsbetrag = tilgungsfreieZeit != null && tilgungsfreieZeit > 0 ? BigDecimal.ZERO : monatlicheRate.subtract(zinsbetrag);
+         in = br.readLine();
-         restschuld = restschuld.subtract(tilgungsbetrag);
+         if (in != null && !in.isBlank()) {
-         System.out.println(aktuellerMonat + ": " + DECIMAL_FORMAT.format(monatlicheRate) + " = " + DECIMAL_FORMAT.format(zinsbetrag)
+            konfig.setRestschuld((BigDecimal) DECIMAL_FORMAT.parse(in));
-            + " + " + DECIMAL_FORMAT.format(tilgungsbetrag) + " | " + DECIMAL_FORMAT.format(restschuld));
-         // berechne Summen für Zusammenfassung
-         summeZinsen = summeZinsen.add(zinsbetrag);
-         summeTilgung = summeTilgung.add(tilgungsbetrag);
-         jahressummeRatenKalenderjahr = jahressummeRatenKalenderjahr.add(monatlicheRate);
-         jahressummeRatenKreditjahr = jahressummeRatenKreditjahr.add(monatlicheRate);
-         summeRaten = summeRaten.add(monatlicheRate);
-         boolean kreditjahrVergangen = laufzeitMonate > 0 && laufzeitMonate % 11 == 0;
-         if (kreditjahrVergangen || aktuellerMonat.getMonthValue() == 12) {
-            BigDecimal jahressummeRaten;
-            String desc;
-            if (kreditjahrVergangen) {
-               jahressummeRaten = jahressummeRatenKreditjahr;
-               jahressummeRatenKreditjahr = BigDecimal.ZERO;
-               desc = "Kreditjahr";
-            } else {
-               jahressummeRaten = jahressummeRatenKalenderjahr;
-               jahressummeRatenKalenderjahr = BigDecimal.ZERO;
-               desc = "Kalenderjahr";
-            }
-            System.out.println("Summe " + desc + ":\n" + DECIMAL_FORMAT.format(jahressummeRaten) + " = "
-               + DECIMAL_FORMAT.format(summeZinsen) + " + " + DECIMAL_FORMAT.format(summeTilgung));
-         }
-         // aktualisiere Werte für den nächsten Lauf
-         aktuellerMonat = aktuellerMonat.plusMonths(1);
-         laufzeitMonate++;
-         if (tilgungsfreieZeit != null) {
-            tilgungsfreieZeit--;
          }
       }
-      // letzte Zusammenfassung
+      System.out.print("Anzahl tilgungsfreier Monate(optional): ");
-      System.out.println("Summe:\n" + DECIMAL_FORMAT.format(summeRaten) + " = "
+      in = br.readLine();
-         + DECIMAL_FORMAT.format(summeZinsen) + " + " + DECIMAL_FORMAT.format(summeTilgung));
+      if (in != null && !in.isBlank()) {
-      // Ausgabe Laufzeit + Restschuld
+         konfig.setTilgungsfreieZeit(Integer.parseInt(in));
-      laufzeitJahre = laufzeitJahre == null ? laufzeitMonate / 12 : laufzeitJahre;
+      }
-      int laufzeitMonateTeil = laufzeitMonate - (laufzeitJahre * 12);
+      System.out.print("Sondertilgungssatz(optional): ");
-      System.out.println("Laufzeit: " + laufzeitJahre + " Jahre " + laufzeitMonateTeil + " Monate");
+      in = br.readLine();
-      System.out.println("Restschuld: " + DECIMAL_FORMAT.format(restschuld));
+      if (in != null && !in.isBlank()) {
+         konfig.setSondertilgungProzent((BigDecimal) DECIMAL_FORMAT.parse(in));
+      }
+      new Darlehenberechner(konfig).berechneWerte();
+   }
+
+
+   private static void parseParametersAndRun(String[] args) {
+      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()));
    }
 }

FabianUtil.java

@@ -2,7 +2,7 @@ package de.vorsorge.theo.util;
 
 import java.io.IOException;
 import java.math.BigDecimal;
-import java.math.RoundingMode;
+import java.math.MathContext;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Paths;
@@ -10,14 +10,16 @@ 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 {
 
-   public static String ENDING_TXT = "txt";
+   private static final String STD_DIR_TEMP = "/FIXME/temp/";
-   public static String ENDING_JSON = "json";
+   public static final String ENDING_TXT = "txt";
-   public static String ENDING_HTML = "html";
+   public static final String ENDING_JSON = "json";
-   public static String ENDING_PDF = "pdf";
+   public static final String ENDING_HTML = "html";
-   public static String ENDING_TIFF = "tiff";
+   public static final String ENDING_PDF = "pdf";
+   public static final String ENDING_TIFF = "tiff";
 
 
    private FabianUtil() {}
@@ -26,73 +28,126 @@ public class 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(int logDistance) {
+      public ProgressHandler() {
-         startTime = ZonedDateTime.now();
+         this(DEFAULT_LOG_DISTANCE, DEFAULT_TIME_LOG_DISTANCE);
-         if (logDistance < 1) {
-            throw new RuntimeException("Log-Distanz darf nicht 0 oder negativ sein.");
-         }
-         this.logDistance = BigDecimal.valueOf(logDistance);
       }
 
 
-      protected BigDecimal getCounter() {
+      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;
       }
 
 
-      public void tickAndLog() {
+      protected synchronized int getTimeLogDistance() {
+         return timeLogDistance;
+      }
+
+
+      public synchronized void tickAndLog() {
          tick();
          logIf();
       }
 
 
-      protected void tick() {
+      protected synchronized void tick() {
          counter = counter.add(BigDecimal.ONE);
       }
 
 
-      public void logAndTick() {
+      public synchronized void logAndTick() {
          logIf();
          tick();
       }
 
 
-      public void logIf() {
+      public synchronized void logIf() {
-         if (counter.remainder(logDistance).signum() == 0) {
+         if (shouldLog()) {
             log();
          }
       }
 
 
-      public void log() {
+      protected synchronized boolean shouldLog() {
-         Duration timePassed = getTimePassed();
+         return counter.remainder(logDistance).signum() == 0 || isBored();
-         System.out.println(counter + " Stück erledigt. " + formatDuration(timePassed) + " vergangen.");
       }
 
 
-      protected Duration getTimePassed() {
+      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 formatLong(dur.toHours()) + ":" + formatInt(dur.toMinutesPart()) + ":" + formatInt(dur.toSecondsPart());
+         return formatNumber(dur.toHours()) + ":" + formatNumber(dur.toMinutesPart()) + ":" + formatNumber(dur.toSecondsPart());
       }
 
 
-      private String formatLong(long n) {
+      protected String formatNumber(Number n) {
-         return TIME_DECIMAL_FORMAT.format(n);
+         return TIME_DECIMAL_FORMAT.format(n == null ? 0 : n);
       }
 
 
-      private String formatInt(int n) {
+      public synchronized void logFinal() {
-         return TIME_DECIMAL_FORMAT.format(n);
+         Duration timePassed = getTimePassed();
+         System.out.println(counter + " Stück (100 %) erledigt. " + formatDuration(timePassed) + " vergangen.");
       }
    }
 
@@ -104,39 +159,66 @@ public class FabianUtil {
       private final BigDecimal total;
 
 
+      public ProgressHandlerWithTotal(int total) {
+         this(DEFAULT_LOG_DISTANCE, DEFAULT_TIME_LOG_DISTANCE, total);
+      }
+
+
       public ProgressHandlerWithTotal(int logDistance, int total) {
-         super(logDistance);
+         this(logDistance, DEFAULT_TIME_LOG_DISTANCE, total);
-         if (total < 1) {
+      }
-            throw new RuntimeException("Maximale Anzahl darf nicht 0 oder negativ sein.");
+
-         }
+
-         this.total = BigDecimal.valueOf(total);
+      public ProgressHandlerWithTotal(int logDistance, int timeLogDistance, int total) {
+         super(logDistance, timeLogDistance);
+         this.total = validateBD(total, "Gesamt-Anzahl");
       }
 
 
       @Override
-      public void log() {
+      protected synchronized boolean shouldLog() {
-         BigDecimal counter = getCounter();
+         return super.shouldLog() && getCounter().compareTo(total) <= 0;
-         BigDecimal percentage = BigDecimal.valueOf(100).divide(total, 15, RoundingMode.HALF_UP).multiply(counter);
+      }
 
+
+      @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, 15, RoundingMode.HALF_UP).multiply(total);
+            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";
          }
 
-         System.out.println(counter + " Stück von " + total + " (" + PERCENTAGE_FORMAT.format(percentage.doubleValue()) + " %) erledigt. "
+         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 logFinal() {
+      public void logContinuouslyTimeBased() {
-         Duration timePassed = getTimePassed();
+         new Thread(this::logTimeBased).start();
-         System.out.println(total + " Stück (100 %) erledigt. " + formatDuration(timePassed) + " vergangen.");
+      }
+
+
+      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;
+            }
+         }
       }
    }
 
@@ -152,7 +234,7 @@ public class FabianUtil {
 
 
    public static void writeTestOutput(String filename, String ending, byte[] content) {
-      writeToFile("C:/theo_dev/temp/testOutput/", filename, ending, content);
+      writeToFile(STD_DIR_TEMP + "testOutput/", filename, ending, content);
    }
 
 
@@ -162,7 +244,7 @@ public class FabianUtil {
 
 
    public static void writeDump(String ending, byte[] content) {
-      writeToFile("C:/theo_dev/temp/", "dump", ending, content);
+      writeToFile(STD_DIR_TEMP, "dump", ending, content);
    }
 
 
@@ -172,7 +254,7 @@ public class FabianUtil {
 
 
    public static void writeDump(String filename, String ending, byte[] content) {
-      writeToFile("C:/theo_dev/temp/", filename, ending, content);
+      writeToFile(STD_DIR_TEMP, filename, ending, content);
    }
 
 

LoadingBar.java

@@ -1,29 +1,40 @@
+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.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.concurrent.TimeUnit;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
-class LoadingBar {
+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][0-9]|2[0-4]):[0-5][0-9]");
+   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 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 DEFAULT_NUMBER_WORK_MINS_BEFORE_LUNCH = 5 * 60;
+   private static final int MINS_PER_HOUR = 60;
-   private static final int MAX_NUMBER_WORK_MINS_WITHOUT_LUNCH = 6 * 60;
+   private static final long DEFAULT_NUMBER_WORK_MINS_BEFORE_LUNCH = 5L * MINS_PER_HOUR;
-   private static final int MAX_NUMBER_WORK_MINS = 8 * 60;
+   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 enum DaySection {
+
+   private enum DaySection {
       MITTAG("-m", "Mittag"),
       ZAPFENSTREICH("-z", "Zapfenstreich");
 
@@ -31,7 +42,7 @@ class LoadingBar {
       private final String description;
 
 
-      private DaySection(String param, String description) {
+      DaySection(String param, String description) {
          this.param = param;
          this.description = description;
       }
@@ -53,15 +64,90 @@ class LoadingBar {
    }
 
 
-   public static void main(String[] args) {
+   public static void main(String[] args) throws IOException {
-      if (args.length > 0 && Objects.equals(args[0], "--help")) {
+      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: ");
+      String startTimeRaw = br.readLine();
+      var startTime = LocalTime.parse(startTimeRaw, TIME_FORMATTER).truncatedTo(ChronoUnit.MINUTES);
+      handleMittagspause(br, startTime);
+      handleZapfenstreich(br, startTime);
+   }
+
+
+   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, LocalTime startTime) throws IOException {
+      print("Mittagspause verschieben um (optional): ");
+      String mittagspauseOffsetRaw = br.readLine();
+      if (mittagspauseOffsetRaw != null && !mittagspauseOffsetRaw.isBlank()) {
+         var mittagspauseOffset = Integer.parseInt(mittagspauseOffsetRaw);
+         showLoadingBarMittagspause(startTime, 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);
+         showLoadingBarMittagspause(startTime, manualMittagspause);
+      } else {
+         showLoadingBarMittagspause(startTime);
+      }
+   }
+
+
+   private static void handleZapfenstreich(BufferedReader br, LocalTime startTime) throws IOException {
+      print("Mittagspause hat gedauert (optional): ");
+      String mittagspauseDurationRaw = br.readLine();
+      Integer mittagspauseDuration = null;
+      if (mittagspauseDurationRaw != null && !mittagspauseDurationRaw.isBlank()) {
+         mittagspauseDuration = Integer.valueOf(mittagspauseDurationRaw);
+      }
+      print("Feierabend verschieben um (optional): ");
+      String zapfenstreichOffsetRaw = br.readLine();
+      Integer zapfenstreichOffset = null;
+      if (zapfenstreichOffsetRaw != null && !zapfenstreichOffsetRaw.isBlank()) {
+         zapfenstreichOffset = Integer.valueOf(zapfenstreichOffsetRaw);
+         showLoadingBarZapfenstreich(startTime, 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);
+         showLoadingBarZapfenstreich(startTime, mittagspauseDuration, manualZapfenstreich);
+         return;
+      }
+      showLoadingBarZapfenstreich(startTime, mittagspauseDuration);
+   }
+
+
+   private static void parseParametersAndRun(String[] args) {
+      String nextArg = args[0];
+      if ("--help".equals(nextArg)) {
          printHelp();
          return;
       }
       verifyMinimumNumberOfArgs(args);
-      String nextArg = args[0];
       verifyTimeFormat(nextArg, "Erstes Argument");
-      var startTime = LocalTime.parse(nextArg, TIME_FORMATTER);
+      var startTime = LocalTime.parse(nextArg, TIME_FORMATTER).truncatedTo(ChronoUnit.MINUTES);
       nextArg = args[1];
       var section = DaySection.byParam(nextArg);
       verifyDaySection(section, nextArg);
@@ -79,23 +165,27 @@ class LoadingBar {
          return;
       }
       String nextArg = args[2];
+      if (OFFSET_PATTERN.matcher(nextArg).matches()) {
+         showLoadingBarMittagspause(startTime, Integer.parseInt(nextArg));
+         return;
+      }
       verifyTimeFormat(nextArg, "Argument nach " + DaySection.MITTAG.getParam());
-      var maxMittagspause = LocalTime.parse(nextArg, TIME_FORMATTER);
+      var manualMittagspause = LocalTime.parse(nextArg, TIME_FORMATTER).truncatedTo(ChronoUnit.MINUTES);
-      showLoadingBarMittagspause(startTime, maxMittagspause);
+      showLoadingBarMittagspause(startTime, manualMittagspause);
    }
 
 
    private static void handleZapfenstreich(String[] args, LocalTime startTime) {
-      Integer lunchDuration = null;
       if (args.length == 2) {
-         showLoadingBarZapfenstreich(startTime, lunchDuration);
+         showLoadingBarZapfenstreich(startTime);
          return;
       }
       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);
+         maxZapfenstreich = LocalTime.parse(nextArg, TIME_FORMATTER).truncatedTo(ChronoUnit.MINUTES);
       } else if (OFFSET_PATTERN.matcher(nextArg).matches()) {
          endTimeOffset = Integer.parseInt(nextArg);
       } else {
@@ -114,12 +204,12 @@ class LoadingBar {
       }
       nextArg = args[3];
       if (lunchDuration == null) {
-         System.out.println("Letztes Argument darf nur auf Mittagspausendauer folgen.");
+         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);
+         maxZapfenstreich = LocalTime.parse(nextArg, TIME_FORMATTER).truncatedTo(ChronoUnit.MINUTES);
          showLoadingBarZapfenstreich(startTime, lunchDuration, maxZapfenstreich);
          return;
       }
@@ -133,7 +223,7 @@ class LoadingBar {
       if (args.length >= 2) {
          return;
       }
-      System.out.println("Mindestens 2 Argumente müssen gegeben sein.");
+      println("Mindestens 2 Argumente müssen gegeben sein.");
       printHelp();
       System.exit(1);
    }
@@ -158,9 +248,9 @@ class LoadingBar {
       if (pattern.matcher(param).matches()) {
          return;
       } // FSFIXME fine tune message -> HH:mm, mm, -+mm
-      var firstInputPart = timeInput ? "Uhrzeitformat ("+ TIME_FORMAT + ")" : "Minutenanzahl (" + LUNCH_DURATION_PATTERN + ")";
+      var firstInputPart = timeInput ? "Uhrzeitformat (" + TIME_FORMAT + ")" : "Minutenanzahl (" + LUNCH_DURATION_PATTERN + ")";
-      var possibleTimeInputPart = !timeInput && timeInputPossible ? " oder Uhrzeitformat ("+ TIME_FORMAT + ")" : "";
+      var possibleTimeInputPart = !timeInput && timeInputPossible ? " oder Uhrzeitformat (" + TIME_FORMAT + ")" : "";
-      System.out.println(errMsgPrefix + " \"" + param + "\" muss " + firstInputPart + possibleTimeInputPart + " entsprechen.");
+      println(errMsgPrefix + " \"" + param + "\" muss " + firstInputPart + possibleTimeInputPart + " entsprechen.");
       System.exit(1);
    }
 
@@ -170,39 +260,41 @@ class LoadingBar {
          return;
       }
       List<String> sectionDescs = Arrays.stream(DaySection.values()).map((DaySection ds) -> ds.getDescription() + " (" + ds.getParam() + ")")
-            .collect(Collectors.toList());
+          .collect(Collectors.toList());
       String sectionDescsJoined = String.join(" oder ", sectionDescs);
-      System.out.println("Argument nach Startzeit \"" + param + "\" muss Angabe für " + sectionDescsJoined + " sein.");
+      println("Argument nach Startzeit \"" + param + "\" muss Angabe für " + sectionDescsJoined + " sein.");
       System.exit(1);
    }
 
 
    private static void printHelp() {
-      System.out.println(new StringBuilder().append("Mögliche Argumente für LoadingBar:\n")
+      println("Mögliche Argumente für LoadingBar:\n"
-            .append("Normalfall Vormittag (Mittagspause <= ").append(LATEST_LUNCH_TIME).append(")\n")
+          + "Normalfall Vormittag (Mittagspause <= " + LATEST_LUNCH_TIME + ")\n"
-            .append(TIME_FORMAT).append(" ").append(DaySection.MITTAG.getParam()).append("\n")
+          + TIME_FORMAT + " " + DaySection.MITTAG.getParam() + "\n"
-            .append("Vormittag mit expliziter Mittagspause (<= ").append(LATEST_LUNCH_TIME).append(")\n")
+          + "Vormittag mit expliziter Mittagspause (<= " + LATEST_LUNCH_TIME + ")\n"
-            .append(TIME_FORMAT).append(" ").append(DaySection.MITTAG.getParam()).append(" ").append(TIME_FORMAT).append("\n")
+          + TIME_FORMAT + " " + DaySection.MITTAG.getParam() + " " + TIME_FORMAT + "\n"
-            .append("Normalfall Nachmittag (Mittagspause ").append(MIN_LUNCH_DURATION).append(" min)\n")
+          + "Vormittag mit abweichender Minutenanzahl Arbeitszeit\n"
-            .append(TIME_FORMAT).append(" ").append(DaySection.ZAPFENSTREICH.getParam()).append("\n")
+          + TIME_FORMAT + " " + DaySection.MITTAG.getParam() + " -+mm\n"
-            .append("Nachmittag mit expliziter Länge Mittagspause (Mittagspause unter ").append(MIN_LUNCH_DURATION).append(" min wird auf ").append(MIN_LUNCH_DURATION).append(" min korrigiert)\n")
+          + "Normalfall Nachmittag (Mittagspause " + MIN_LUNCH_DURATION + " min)\n"
-            .append(TIME_FORMAT).append(" ").append(DaySection.ZAPFENSTREICH.getParam()).append(" mm\n")
+          + TIME_FORMAT + " " + DaySection.ZAPFENSTREICH.getParam() + "\n"
-            .append("Nachmittag mit explizitem Feierabend (Mittagspause je nach Minimum (s.u.))\n")
+          + "Nachmittag mit expliziter Länge Mittagspause (Mittagspause unter " + MIN_LUNCH_DURATION + " min wird auf " + MIN_LUNCH_DURATION + " min korrigiert)\n"
-            .append(TIME_FORMAT).append(" ").append(DaySection.ZAPFENSTREICH.getParam()).append(" ").append(TIME_FORMAT).append("\n")
+          + TIME_FORMAT + " " + DaySection.ZAPFENSTREICH.getParam() + " mm\n"
-            .append("Nachmittag mit abweichender Minutenanzahl Arbeitszeit\n")
+          + "Nachmittag mit explizitem Feierabend (Mittagspause je nach Minimum (s.u.))\n"
-            .append(TIME_FORMAT).append(" ").append(DaySection.ZAPFENSTREICH.getParam()).append(" -+mm\n")
+          + TIME_FORMAT + " " + DaySection.ZAPFENSTREICH.getParam() + " " + TIME_FORMAT + "\n"
-            .append("Nachmittag mit explizitem Feierabend u. expliziter Länge Mittagspause (Mittagspause unter Minimum (s.u.) wird auf Minimum korrigiert)\n")
+          + "Nachmittag mit abweichender Minutenanzahl Arbeitszeit\n"
-            .append(TIME_FORMAT).append(" ").append(DaySection.ZAPFENSTREICH.getParam()).append(" mm ").append(TIME_FORMAT).append("\n")
+          + TIME_FORMAT + " " + DaySection.ZAPFENSTREICH.getParam() + " -+mm\n"
-            .append("Nachmittag mit explizitem Feierabend u. abweichender Minutenanzahl Arbeitszeit\n")
+          + "Nachmittag mit explizitem Feierabend u. expliziter Länge Mittagspause (Mittagspause unter Minimum (s.u.) wird auf Minimum korrigiert)\n"
-            .append(TIME_FORMAT).append(" ").append(DaySection.ZAPFENSTREICH.getParam()).append(" ").append(TIME_FORMAT).append(" -+mm\n\n")
+          + TIME_FORMAT + " " + DaySection.ZAPFENSTREICH.getParam() + " mm " + TIME_FORMAT + "\n"
-            .append("Mittagspause minimum in Minuten:\n")
+          + "Nachmittag mit explizitem Feierabend u. abweichender Minutenanzahl Arbeitszeit\n"
-            .append(" - bis ").append(MAX_NUMBER_WORK_MINS_WITHOUT_LUNCH).append(" min (")
+          + TIME_FORMAT + " " + DaySection.ZAPFENSTREICH.getParam() + " " + TIME_FORMAT + " -+mm\n\n"
-               .append(MAX_NUMBER_WORK_MINS_WITHOUT_LUNCH / 60).append(" std):  0\n")
+          + "Mittagspause minimum in Minuten:\n"
-            .append(" - bis ").append(MAX_NUMBER_WORK_MINS_WITHOUT_LUNCH).append(" min + ")
+          + " - bis " + MAX_NUMBER_WORK_MINS_WITHOUT_LUNCH + " min ("
-               .append(MIN_LUNCH_DURATION).append(" min: Arbeitszeit - ").append(MAX_NUMBER_WORK_MINS_WITHOUT_LUNCH).append(" min\n")
+          + MAX_NUMBER_WORK_MINS_WITHOUT_LUNCH / MINS_PER_HOUR + " std):  0\n"
-            .append(" - ab  ").append(MAX_NUMBER_WORK_MINS_WITHOUT_LUNCH).append(" min + ").append(MIN_LUNCH_DURATION).append(" min: ")
+          + " - bis " + MAX_NUMBER_WORK_MINS_WITHOUT_LUNCH + " min + "
-               .append(MIN_LUNCH_DURATION).append(" min\n")
+          + MIN_LUNCH_DURATION + " min: Arbeitszeit - " + MAX_NUMBER_WORK_MINS_WITHOUT_LUNCH + " min\n"
-            .toString());
+          + " - ab  " + MAX_NUMBER_WORK_MINS_WITHOUT_LUNCH + " min + " + MIN_LUNCH_DURATION + " min: "
+          + MIN_LUNCH_DURATION + " min\n"
+      );
    }
 
 
@@ -211,6 +303,13 @@ class LoadingBar {
    }
 
 
+   private static void showLoadingBarMittagspause(LocalTime startTime, int endTimeOffset) {
+      LocalTime endTime = startTime.plusMinutes(DEFAULT_NUMBER_WORK_MINS_BEFORE_LUNCH + endTimeOffset);
+      LocalTime trueEndTime = endTime.isAfter(LATEST_LUNCH_TIME) ? LATEST_LUNCH_TIME : endTime;
+      showLoadingBar(startTime, trueEndTime);
+   }
+
+
    private static void showLoadingBarMittagspause(LocalTime startTime, LocalTime manualEndTime) {
       LocalTime endTime = manualEndTime != null ? manualEndTime : startTime.plusMinutes(DEFAULT_NUMBER_WORK_MINS_BEFORE_LUNCH);
       LocalTime trueEndTime = endTime.isAfter(LATEST_LUNCH_TIME) ? LATEST_LUNCH_TIME : endTime;
@@ -218,14 +317,19 @@ class LoadingBar {
    }
 
 
+   private static void showLoadingBarZapfenstreich(LocalTime startTime) {
+      showLoadingBarZapfenstreich(startTime, -1, 0);
+   }
+
+
    private static void showLoadingBarZapfenstreich(LocalTime startTime, Integer manualLunchDuration) {
       showLoadingBarZapfenstreich(startTime, manualLunchDuration, 0);
    }
 
 
    private static void showLoadingBarZapfenstreich(LocalTime startTime, Integer manualLunchDuration, int endTimeOffset) {
-      int minLunchDuration = getMinLunchDuration(startTime, endTimeOffset);
+      long minLunchDuration = getMinLunchDuration(endTimeOffset);
-      int realLunchDuration = getRealLunchDuration(manualLunchDuration, minLunchDuration);
+      long realLunchDuration = getRealLunchDuration(manualLunchDuration, minLunchDuration);
       LocalTime trueEndTime = startTime.plusMinutes(MAX_NUMBER_WORK_MINS + realLunchDuration + endTimeOffset);
       realShowLoadingBarZapfenstreich(startTime, realLunchDuration, trueEndTime);
    }
@@ -233,8 +337,8 @@ class LoadingBar {
 
    private static void showLoadingBarZapfenstreich(LocalTime startTime, Integer manualLunchDuration, LocalTime manualEndTime) {
       LocalTime trueEndTime = manualEndTime;
-      int minLunchDuration = getMinLunchDuration(startTime, trueEndTime);
+      long minLunchDuration = getMinLunchDuration(startTime, trueEndTime);
-      int realLunchDuration = getRealLunchDuration(manualLunchDuration, minLunchDuration);
+      long realLunchDuration = getRealLunchDuration(manualLunchDuration, minLunchDuration);
       if (trueEndTime == null) {
          trueEndTime = startTime.plusMinutes(MAX_NUMBER_WORK_MINS + realLunchDuration);
       }
@@ -242,17 +346,17 @@ class LoadingBar {
    }
 
 
-   private static int getMinLunchDuration(LocalTime startTime, int endTimeOffset) {
+   private static long getMinLunchDuration(int endTimeOffset) {
       if (endTimeOffset == 0) {
          return MIN_LUNCH_DURATION;
       }
-      int totalDuration = MAX_NUMBER_WORK_MINS + endTimeOffset;
+      long totalDuration = MAX_NUMBER_WORK_MINS + endTimeOffset;
-      int effectiveLunchDuration = totalDuration - MAX_NUMBER_WORK_MINS_WITHOUT_LUNCH;
+      long effectiveLunchDuration = totalDuration - MAX_NUMBER_WORK_MINS_WITHOUT_LUNCH;
       return getMinLunchDuration(effectiveLunchDuration);
    }
 
 
-   private static int getMinLunchDuration(LocalTime startTime, LocalTime endTime) {
+   private static long getMinLunchDuration(LocalTime startTime, LocalTime endTime) {
       if (endTime == null) {
          return MIN_LUNCH_DURATION;
       }
@@ -262,40 +366,40 @@ class LoadingBar {
    }
 
 
-   private static int getMinLunchDuration(int effectiveLunchDuration) {
+   private static long getMinLunchDuration(long effectiveLunchDuration) {
       if (effectiveLunchDuration < 0) {
          effectiveLunchDuration = 0;
       }
-      return effectiveLunchDuration < MIN_LUNCH_DURATION ? effectiveLunchDuration : MIN_LUNCH_DURATION;
+      return Math.min(effectiveLunchDuration, MIN_LUNCH_DURATION);
    }
 
 
-   private static int getRealLunchDuration(Integer manualLunchDuration, int minLunchDuration) {
+   private static long getRealLunchDuration(Integer manualLunchDuration, long minLunchDuration) {
       return manualLunchDuration != null && manualLunchDuration >= minLunchDuration ? manualLunchDuration : minLunchDuration;
    }
 
 
-   private static void realShowLoadingBarZapfenstreich(LocalTime startTime, int manualLunchDuration, LocalTime endTime) {
+   private static void realShowLoadingBarZapfenstreich(LocalTime startTime, long manualLunchDuration, LocalTime endTime) {
       if (manualLunchDuration > 0) {
          var totalWorkTime = LocalTime.MIDNIGHT.plusMinutes(startTime.until(endTime, ChronoUnit.MINUTES) - manualLunchDuration);
-         System.out.print("Arbeitszeit: " + TIME_FORMATTER.format(totalWorkTime) + "; ");
+         print("Arbeitszeit: " + TIME_FORMATTER.format(totalWorkTime) + "; ");
       }
       showLoadingBar(startTime, endTime);
    }
 
 
    private static void showLoadingBar(LocalTime startTime, LocalTime endTime) {
-      long initialMinutes = startTime.until(endTime, ChronoUnit.MINUTES);
+      long totalMinutes = startTime.until(endTime, ChronoUnit.MINUTES);
-      System.out.print(minutesToTimeString(initialMinutes) + " gesamt; Endzeit: " + TIME_FORMATTER.format(endTime) + "\n");
+      long passedMinutes = startTime.until(LocalTime.now().truncatedTo(ChronoUnit.MINUTES), ChronoUnit.MINUTES);
-      long passedMinutes = startTime.until(LocalTime.now(), ChronoUnit.MINUTES);
+      if (passedMinutes > totalMinutes) {
-      if (passedMinutes > initialMinutes) {
+         passedMinutes = totalMinutes;
-         passedMinutes = initialMinutes;
       } else if (passedMinutes < 0) {
-         System.out.println(fillLoadingBar(initialMinutes, 0, false));
+         var now = LocalTime.now().truncatedTo(ChronoUnit.SECONDS);
-         return;
+         println("!ACHTUNG! Startzeit \"" + startTime + ":00\" liegt in der Zukunft von jetzt an (" + now + ") gesehen.");
       }
-      while (passedMinutes < initialMinutes) {
+      println(minutesToTimeString(totalMinutes) + " gesamt; Endzeit: " + TIME_FORMATTER.format(endTime));
-         System.out.print(fillLoadingBar(initialMinutes, passedMinutes, true));
+      while (passedMinutes < totalMinutes) {
+         print(fillLoadingBar(totalMinutes, passedMinutes, true));
          try {
             var now = LocalTime.now();
             var oneMinuteLater = now.plusMinutes(1).truncatedTo(ChronoUnit.MINUTES);
@@ -307,24 +411,27 @@ class LoadingBar {
          }
          passedMinutes++;
       }
-      System.out.println(fillLoadingBar(initialMinutes, passedMinutes, false));
+      println(fillLoadingBar(totalMinutes, passedMinutes, false));
    }
 
 
-   private static String fillLoadingBar(long initialMinutes, long passedMinutes, boolean progressive) {
+   private static String fillLoadingBar(long totalMinutes, long passedMinutes, boolean progressive) {
-      double wholePercentage = ((double) passedMinutes / initialMinutes) * 100;
+      var nonNegativePassedMinutes = passedMinutes < 0 ? 0 : passedMinutes;
-      long remainingMinutes = initialMinutes - passedMinutes;
+      BigDecimal wholePercentage = BigDecimal.valueOf(100)
-      int numberOfEquals = (int) wholePercentage;
+         .multiply( // kind of reverse dreisatz to avoid to have e.g. 99.9999 instead of 100 %
+            BigDecimal.valueOf(nonNegativePassedMinutes).divide(BigDecimal.valueOf(totalMinutes), MathContext.DECIMAL64));
+      int numberOfEquals = wholePercentage.intValue();
       var sb = new StringBuilder("[");
-      for (int i = 0; i < 100; i++) {
+      for (int i = 0; i < LINE_LENGTH; i++) {
          if (i < numberOfEquals) {
             sb.append("=");
          } else {
             sb.append("-");
          }
       }
+      long remainingMinutes = totalMinutes - nonNegativePassedMinutes;
       sb.append("] ").append(PERCENTAGE_FORMAT.format(wholePercentage)).append("% ")
-         .append(minutesToTimeString(passedMinutes)).append(" - ").append(minutesToTimeString(remainingMinutes));
+          .append(minutesToTimeString(nonNegativePassedMinutes)).append(" - ").append(minutesToTimeString(remainingMinutes));
       if (progressive) {
          sb.append("\r");
       }
@@ -333,6 +440,8 @@ class LoadingBar {
 
 
    private static String minutesToTimeString(long minutes) {
-      return LocalTime.of((int) minutes / 60, (int) minutes % 60).format(TIME_FORMATTER);
+      var minutesBD = BigDecimal.valueOf(minutes);
+      BigDecimal[] hoursAndMinutes = minutesBD.divideAndRemainder(BigDecimal.valueOf(MINS_PER_HOUR), MC_INTEGER);
+      return LocalTime.of(hoursAndMinutes[0].intValue(), hoursAndMinutes[1].intValue()).format(TIME_FORMATTER);
    }
 }

SimpleLoadingBar.java

@@ -1,3 +1,6 @@
+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;
@@ -6,12 +9,15 @@ import java.util.Objects;
 import java.util.concurrent.TimeUnit;
 import java.util.regex.Pattern;
 
-class SimpleLoadingBar {
+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][0-9]|2[0-4]):[0-5][0-9]");
+   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 int LINE_LENGTH = 100;
+   private static final MathContext MC_INTEGER = new MathContext(1, RoundingMode.HALF_EVEN);
 
 
    public static void main(String[] args) {
@@ -29,7 +35,7 @@ class SimpleLoadingBar {
       if (args.length > 1) {
          startTime = firstTime;
          nextArg = args[1];
-         if (nextArg.equals("-msg")) {
+         if ("-msg".equals(nextArg)) {
             title = args.length > 2 ? args[2] : title;
          } else {
             verifyTimeFormat(nextArg, "Zweites Argument");
@@ -47,7 +53,7 @@ class SimpleLoadingBar {
          return;
       }
       // if there are 3 arguments, the third will be discarded.
-      boolean hasTitleArg = args.length > 3 && args[2].equals("-msg");
+      boolean hasTitleArg = args.length > 3 && "-msg".equals(args[2]);
       title = hasTitleArg ? args[3] : title;
       title = title.isBlank() ? fallbackTitle : title;
       showLoadingBar(startTime, endTime, title);
@@ -55,11 +61,11 @@ class SimpleLoadingBar {
 
 
    private static void printHelp() {
-      System.out.println(new StringBuilder().append("Mögliche Argumente für LoadingBar:\n")
+      System.out.println("Mögliche Argumente für LoadingBar:\n"
-         .append("Startzeit, Endzeit, Endnachricht (Optional)\n")
+          + "Startzeit, Endzeit, Endnachricht (Optional)\n"
-         .append(TIME_FORMAT).append(" ").append(TIME_FORMAT).append("-msg <Nachricht>\n")
+          + TIME_FORMAT + " " + TIME_FORMAT + " -msg <Nachricht>\n"
-         .append("Endzeit (Startzeit = jetzt), Endnachricht (Optional)\n")
+          + "Endzeit (Startzeit = jetzt), Endnachricht (Optional)\n"
-         .append(TIME_FORMAT).append("-msg <Nachricht>\n")
+          + TIME_FORMAT + " -msg <Nachricht>\n"
       );
    }
 
@@ -78,12 +84,11 @@ class SimpleLoadingBar {
       if (TIME_PATTERN.matcher(param).matches()) {
          return;
       }
-      System.out.println(errMsgPrefix + " \"" + param + "\" muss Uhrzeitformat ("+ TIME_FORMAT + ") entsprechen.");
+      System.out.println(errMsgPrefix + " \"" + param + "\" muss Uhrzeitformat (" + TIME_FORMAT + ") entsprechen.");
       System.exit(1);
    }
 
 
-
    public static void showLoadingBar(LocalTime startTime, LocalTime endTime, String title) {
       long initialMinutes = startTime.until(endTime, ChronoUnit.MINUTES);
       System.out.print(minutesToTimeString(initialMinutes) + " gesamt; Endzeit: " + TIME_FORMATTER.format(endTime) + "\n");
@@ -113,11 +118,13 @@ class SimpleLoadingBar {
 
 
    private static String fillLoadingBar(long initialMinutes, long passedMinutes, boolean progressive) {
-      double wholePercentage = ((double) passedMinutes / initialMinutes) * 100;
+      BigDecimal wholePercentage = BigDecimal.valueOf(100)
+         .multiply(BigDecimal.valueOf(passedMinutes) // kind of reverse dreisatz to avoid to have e.g. 99.9999 instead of 100 %
+         .divide(BigDecimal.valueOf(initialMinutes), MathContext.DECIMAL64));
       long remainingMinutes = initialMinutes - passedMinutes;
-      int numberOfEquals = (int) wholePercentage;
+      int numberOfEquals = wholePercentage.intValue();
       var sb = new StringBuilder("[");
-      for (int i = 0; i < 100; i++) {
+      for (int i = 0; i < LINE_LENGTH; i++) {
          if (i < numberOfEquals) {
             sb.append("=");
          } else {
@@ -125,7 +132,7 @@ class SimpleLoadingBar {
          }
       }
       sb.append("] ").append(PERCENTAGE_FORMAT.format(wholePercentage)).append("% ")
-         .append(minutesToTimeString(passedMinutes)).append(" - ").append(minutesToTimeString(remainingMinutes));
+          .append(minutesToTimeString(passedMinutes)).append(" - ").append(minutesToTimeString(remainingMinutes));
       if (progressive) {
          sb.append("\r");
       }
@@ -134,15 +141,14 @@ class SimpleLoadingBar {
 
 
    private static String minutesToTimeString(long minutes) {
-      return LocalTime.of((int) minutes / 60, (int) minutes % 60).format(TIME_FORMATTER);
+      var minutesBD = BigDecimal.valueOf(minutes);
+      BigDecimal[] hoursAndMinutes = minutesBD.divideAndRemainder(BigDecimal.valueOf(MINS_PER_HOUR), MC_INTEGER);
+      return LocalTime.of(hoursAndMinutes[0].intValue(), hoursAndMinutes[1].intValue()).format(TIME_FORMATTER);
    }
 
 
    private static String formatTitle(String title) {
-      var sb = new StringBuilder();
+      String separator = "*".repeat(title.length());
-      for (int i = 0; i < title.length(); i++) {
+      return separator + "\n" + title + "\n" + separator;
-         sb.append("*");
-      }
-      return sb.toString() + "\n" + title + "\n" + sb.toString();
    }
 }