Alter (Laufzeit) berechnen

[EricB2]

Guten Tag werte Damen und Herren,

ich habe ein Programm geschrieben welches den Zeitpunkt des Programmstartes festhält und mir dann die Differenz zur aktuellen Zeit in Jahr, Monat, Tag, Stunde,Minute,Sekunde ausgeben kann. Die Methode "LifeTime" aus der Klasse "DatumUhrzeit" welche Sie hier sehen wird über eine Schleife alle 1000 Millis ausgeführt.
Wenn ich jetzt das Programm bei z.B. aktueller Sekunde 40 starte bekomme ich logischerweise bei Beginn einer neuen Minute Negativwerte. Um das zu ändern habe ich bei Negativwerten einfach 60 addiert.
Jetzt zum Problem:
Führe ich den Code aus fehlt mir bei der Ausgabe die Sekunde in der das Ergebnis von "positiver Zahl" zu "negativer Zah"l+60 wechselt und dafür wird am Ende der Minute mehrmals die 0 ausgegeben. bei Sekunden ist das von mir aus nicht so schlimm aber das Problem setzt sich bei Minuten, Stunden ,Tagen etc fort.

Seit vier Tagen suche ich schon nach einer Lösung die Laufzeit eines Programmes auszugeben,damit zu rechnen und es zb im Datumsformat auszugeben aber inzwischen ist der Knoten im Kopf so groß dass ich mich im Staduim "TryAndError" befinde und nach einer externen Meinung fragen muss.
Ich bin ziehmlicher Anfänger darum entschuldige ich mich schonmal im voraus für den vermutlich etwas unsauberen Code.

import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
import java.util.Calendar;


class DatumUhrzeit {

      int U;
      String Datum;
      String Uhrzeit;
      String RunAge;
      int Lebensalter;
    
            
            
                    Calendar jetzt = Calendar.getInstance(); //Instanziert die Objekte aus der javainternen Klasse Calendar
                    
                    
                    int Sekunde =         jetzt.get(Calendar.SECOND);            //Aktuelle Senkunden
                    int Minute =         jetzt.get(Calendar.MINUTE);            //Aktuelle Minuten
                    //int Hour12 =         jetzt.get(Calendar.HOUR);            //Stunde des Tages 12er Zyklus
                    int Stunde =         jetzt.get(Calendar.HOUR_OF_DAY);    //Stunde des Tages 24-er Zyklus
                    
                    int Tag =             jetzt.get(Calendar.DATE);            //Aktuelle Tageszahl im Monat
                    int Monat =         jetzt.get(Calendar.MONTH) + 1;            //Aktueller Monat
                    int Jahr =             jetzt.get(Calendar.YEAR);            //Aktuelles Jahr
                    //int KalenderWoche = jetzt.get(Calendar.WEEK_OF_YEAR);    //Aktuelle Kalenderwoche
                    //int WochentagZahl = jetzt.get(Calendar.DAY_OF_WEEK);     //Tageszahl in der Woche (Sun = 1...)
                    
                    //int HalbTag =     jetzt.get(Calendar.AM_PM);            //0= vor 12 ; 1 = nach 12
                    int Jahrestag =     jetzt.get(Calendar.DAY_OF_YEAR);    //Aktueller Tag im Jahr
                    //int March =         jetzt.get(Calendar.MARCH);
                
                    final long birth = System.currentTimeMillis()/1000;
                    final int Se = Sekunde;
                    
                    
    void Zeit() {
        
                    
                     U = Sekunde;
                    
                     Uhrzeit = Stunde + ":" + Minute + ":" + Sekunde;
                     Datum = Tag + "." + Monat + "." + Jahr;
                    
     }
    

    void lifeTime() {
         DatumUhrzeit DT = new DatumUhrzeit();
        
        
        
        long lifeTimeSec = System.currentTimeMillis()/1000 - birth;
            //if (lifeTimeSec >= 60) {lifeTimeSec = lifeTimeSec - lifeMin * 60;}
            
            System.out.println("LifeTimeSec: " + lifeTimeSec);
        
            
        
         //--------------------------------------------------------------------------------------------
         int J = DT.Jahr;
         int SJ = 0;
         if(J==2024||J==2028||J==2032||J==2036||J==2040||J==2044||J==2048||J==2052||
            J==2056||J==2060||J==2064||J==2068||J==2072||J==2076||J==2080||J==2084||    // SCHALTJAHRE
            J==2088||J==2092||J==2096||J==2100||J==2104||J==2108||J==2112||J==2116) {
             SJ = 1;
         }
         //--------------------------------------------------------------------------------------------
        
         LocalDateTime startYear = LocalDateTime.of(Jahr, Monat, Tag, Stunde, Minute, Sekunde);
         LocalDateTime endYear = LocalDateTime.now();
         long year = ChronoUnit.YEARS.between(startYear, endYear);
         //System.out.println("Jahr: " + year);
        
         LocalDateTime startMonth = LocalDateTime.of(DT.Jahr,  Monat, Tag, Stunde, Minute, Sekunde);
         LocalDateTime endMonth = LocalDateTime.now();
         long month = ChronoUnit.MONTHS.between(startMonth, endMonth);
         if(month <0) {month = month+12;}
         //System.out.println("Monat: " + month);
        
         LocalDateTime startDay = LocalDateTime.of(DT.Jahr, DT.Monat, Tag, Stunde, Minute, Sekunde);
         LocalDateTime endDay = LocalDateTime.now();
         long day = ChronoUnit.DAYS.between(startDay, endDay);
         if(day <0) {
             int M = DT.Monat;
             if(M == 1||M==3||M==5||M==7||M==8||M==10||M==12) {day=day+31;}
             if(M == 4||M==6||M==9||M==11) {day=day+30;}
             if(M == 2 && SJ== 1){day=day+29;}
             if(M == 2 && SJ!= 1){day=day+28;}
         }
         //System.out.println("Tag: " + day);
        
         LocalDateTime startHour = LocalDateTime.of(DT.Jahr, DT.Monat, DT.Tag, Stunde, Minute, Sekunde);
         LocalDateTime endHour = LocalDateTime.now();
         long hour = ChronoUnit.HOURS.between(startHour, endHour);
         if(hour <0) {hour = hour+24;}
         //System.out.println("Stunde: " + hour);
        
         LocalDateTime startMinute = LocalDateTime.of(DT.Jahr, DT.Monat, DT.Tag, DT.Stunde, Minute, Sekunde);
         LocalDateTime endMinute = LocalDateTime.now();
         long minute = ChronoUnit.MINUTES.between(startMinute, endMinute);
         if(minute <0) {minute = minute+60;}
         //System.out.println("Minute: " + minute);
        
        
         //----------------------------------------------------------------------------------------------------
        
         LocalDateTime startSecond = LocalDateTime.of(DT.Jahr, DT.Monat, DT.Tag, DT.Stunde, DT.Minute, Se);
         LocalDateTime endSecond = LocalDateTime.now();
         long second = ChronoUnit.SECONDS.between(startSecond, endSecond);
         if(second <0) {second = second +60;}
         System.out.println("Sekunde: " + second);
         //-----------------------------------------------------------------------------------------------------
        
         RunAge = year + "J " + month + "M " + day + "T " + hour + "h " + minute + "min " + second + "sec";
         //System.out.println(RunAge);
              
        
    }
                    
                                    
                    
}

 

[Oneixee5]

Ich will dich jetzt nicht entmutigen, aber schmeiß das alles weg. Für die Anforderung brauch man höchsten 10 Zeilen Code. Bitte informiere dich zuerst, z.B.: in der API-Doku oder in Tutorials, wie man so etwas angeht
@see https://www.baeldung.com/java-date-difference

 

[EricB2]

Nun Danke erstmal für den Denkanstoß von vorn anzufangen und tatsächlich habe ich eine um einiges einfachere Methode gefunden was zumindest das DatumZeitFormat und die Berechnung der Zeitspanne in Jahre.Monat,Tag angeht. Das Problem mit der Zeit besteht jedoch immernoch kurzum: Wie berechne ich z.B. die vergangene Zeit von gestern 18:22Uhr zu heite 13:42Uhr in Stunden,Minuten,Sekunden
OHNE Negativwerte zu erhalten wie z.B. bei der "Duration"-Methode.

         LocalDateTime Jetzt = LocalDateTime.now();            //jetztiges Datum UND Uhrzeit
         DateTimeFormatter DateForm = DateTimeFormatter.ofPattern("EEEE, dd.MM.YYYY");
         DateTimeFormatter TimeForm = DateTimeFormatter.ofPattern("HH:mm:ss");
        
         System.out.println(DateForm.format(Jetzt));        //Fertiges Datum
         System.out.println(TimeForm.format(Jetzt));        //Fertige Uhrzeit
        
        
         LocalTime Jetzt2 = LocalTime.now();
         LocalTime Start2 = LocalTime.of(17, 11, 34);
         Duration Dauer = Duration.between(Start2, Jetzt2);
        
        
         LocalDate heute = LocalDate.now();                    //Heutiges Datum
         Period vielZeit = Period.of(9, 10, 01);            //Zeitangabe in (Jahre, Monate, Tage)
         LocalDate später = heute.plus(vielZeit);            //Datum in der Zukunft
        
         LocalDate Start = LocalDate.of(2009, 10, 01);        //StartDatum
         Period Alter = Start .until(heute);                //errechnet die Zeitspanne zwischen "Start" und "heute"
        
         int Jahre = Alter.getYears();                        //gibt die Zeit in Jahren aus       
         int Monate = Alter.getMonths();                    //gibt die Zeit in Monaten aus (zw. 0 u. 11)
         int Tage = Alter.getDays();                        //gibt die Zeit in Tagen aus (zw. 0 u. 30)
        
        
         System.out.println(Jahre);
         System.out.println(Monate);
         System.out.println(Tage);
         System.out.println(später);
         System.out.println(Dauer);

 

[httpdigest]

Hast du mal versucht, danach zu googlen?
Ich hab gerade 2 Sekunden investiert mit googlen von "Java difference between two dates in years months days":
- https://stackoverflow.com/questions...en-two-dates-in-years-months-and-days-in-java

 

[Oneixee5]

Das sieht schon besser aus.
Zur Beachtung: Variablen schreibt man immer klein.
Ich erhalte keine negativen Werte:

public class Play {
  
    //private static LocalDateTime start = LocalDateTime.now();
    
    // test value from https://www.java-forum.org/thema/alter-laufzeit-berechnen.197194/#post-1305047
    private static LocalDateTime start = LocalDateTime.of(2022, 4, 23, 18, 22);

    public static void main(String[] args) throws Exception {
      
        // timekeeping
        Runnable task = new Runnable() {
          
            @Override
            public void run() {
                LocalDateTime now = LocalDateTime.now();
//                // add test values
//                now = now.plusDays(10);
//                now = now.plusMonths(1);
//                now = now.plusYears(2);
              
                // test value from https://www.java-forum.org/thema/alter-laufzeit-berechnen.197194/#post-1305047
                now = LocalDateTime.of(2022, 4, 24, 13, 42);
                System.out.println(divToHumanReadableFormat(now));
            }
        };
      
        // execute the task every second
        ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();
        executorService.scheduleWithFixedDelay(task, 1L, 1L, TimeUnit.SECONDS);
      
        // standby, simulate other work for more then one minute
        Thread.sleep(67000);
      
        // bye bye
        executorService.shutdownNow();
    }

    private static String divToHumanReadableFormat(LocalDateTime now) {
        Duration duration = Duration.between(start, now);
        Period period = Period.between(start.toLocalDate(), now.toLocalDate());
      
        long yyyy = period.getYears();
        long mm = period.getMonths();
        long dd = period.getDays();
        long hh = duration.toHoursPart();
        long mi = duration.toMinutesPart();
        long ss = duration.toSecondsPart();
      
        return String.format("%02d.%02d.%02d %02d:%02d:%02d", yyyy, mm, dd, hh, mi, ss);
    }

}

Die fest eingefügten Testwerte müssen natürlich entfernt werden.

 

[White_Fox]

Wenn ich jetzt das Programm bei z.B. aktueller Sekunde 40 starte bekomme ich logischerweise bei Beginn einer neuen Minute Negativwerte. Um das zu ändern habe ich bei Negativwerten einfach 60 addiert.

Sorry, aber das ist nicht logisch, sondern bedeutet daß du da schon Mist gebaut hast.
Logisch wäre ein Ergebnis von 0.

 

[hpechti]

Hallo,

const Jetzt2 = Date.now();
const Start2 = new Date('02 Feb 1996 03:04:05 GMT');

var Dauer = Jetzt2.valueOf() - Start2.valueOf()
var date = new Date(Dauer * 1000);

date.toUTCString()

Ist nicht getestet, nur teoretisch!

meintest du sowas?

 

[hpechti]

var start = Date.now();
console.log(new Date(start).toUTCString());
console.log('Start des Timer...');

setTimeout(() => {
  const milliS = Date.now() - start;
  console.log(`vergangene Sekunden = ${Math.floor(milliS / 1000)}`);
  console.log(new Date(start+milliS).toUTCString());
  // expected output: seconds elapsed = 2
}, 2000);

Jetzt is besser!

 

[Oneixee5]

var start = Date.now();
console.log(new Date(start).toUTCString());
console.log('Start des Timer...');

setTimeout(() => {
  const milliS = Date.now() - start;
  console.log(`vergangene Sekunden = ${Math.floor(milliS / 1000)}`);
  console.log(new Date(start+milliS).toUTCString());
  // expected output: seconds elapsed = 2
}, 2000);

Jetzt is besser!

Stand da etwas von JavaScript?

 

[hpechti]

Oh Sorry, wollte ja eigentlich nur ein Gedankenanstoß geben, um die Lösung selber zu finden!

 

[EricB2]

So es ist geschafft. Dank eurer zahlreicher Anregungen hab ich mir jetzt etwas zusammengeschustert was dem entspricht wie ich es mir vorstelle.
Vielleicht hilft es jemandem der mal ein ähnliches Problem hat.

import java.time.Duration;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.Period;
import java.time.format.DateTimeFormatter;
//import java.util.Calendar;



class DatumUhrzeit {

    String datum;
    String uhrzeit;
    String laufZeitKurz;
    String laufZeitLang;
    long lifeTimeSec;
    
            
            
                    //Calendar jetzt = Calendar.getInstance(); //Instanziert die Objekte aus der javainternen Klasse Calendar
                    //int KalenderWoche = jetzt.get(Calendar.WEEK_OF_YEAR);    //Aktuelle Kalenderwoche
                    //int WochentagZahl = jetzt.get(Calendar.DAY_OF_WEEK);     //Tageszahl in der Woche (Sun = 1...)
                    //int HalbTag =     jetzt.get(Calendar.AM_PM);            //0= vor 12 ; 1 = nach 12
                    //int Jahrestag =     jetzt.get(Calendar.DAY_OF_YEAR);    //Aktueller Tag im Jahr
                    
                    
                    final long birth = System.currentTimeMillis()/1000;
                    LocalDateTime birthDateTime = LocalDateTime.now();
                    LocalTime birthTime = LocalTime.now();
                    LocalDate birthDate = LocalDate.now();
                    
    
    void lifeTime() {
        
         //---------------------------------------------------------------------------
         // DATUM UND UHRZEIT
         LocalDateTime liveDateTime = LocalDateTime.now();            //jetztiges Datum UND Uhrzeit
         DateTimeFormatter dateForm = DateTimeFormatter.ofPattern("EEEE, dd.MM.YYYY");
         DateTimeFormatter timeForm = DateTimeFormatter.ofPattern("HH:mm:ss");
         System.out.println(dateForm.format(liveDateTime));        //Fertiges Datum
         System.out.println(timeForm.format(liveDateTime));        //Fertige Uhrzeit
         datum = dateForm.format(liveDateTime);
         uhrzeit = timeForm.format(liveDateTime);
         //-------------------------------------------------------------------------
        
         //Alter in Stunden, Minuten, Sekunden
         LocalTime liveTime = LocalTime.now();
         //LocalTime Start2 = LocalTime.of(17, 11, 34);
         Duration dauer = Duration.between(birthTime, liveTime);
         long Stunden = dauer.toHoursPart();
         long Minuten = dauer.toMinutesPart();
         long Sekunden = dauer.toSecondsPart();
         laufZeitKurz = String.format("%02d:%02d:%02d", Stunden, Minuten, Sekunden);
         System.out.println(laufZeitKurz);
         //--------------------------------------------------------------------------
        
         //Alter in Jahren, Monaten, Tagen
         LocalDate liveDate = LocalDate.now();                        //Heutiges Datum
         //LocalDate Start = LocalDate.of(2009, 10, 01);            //StartDatum
         Period alter = birthDate .until(liveDate);                    //errechnet die Zeitspanne zwischen "Start" und "heute"
         int Jahre = alter.getYears();                                //gibt die Zeit in Jahren aus       
         int Monate = alter.getMonths();                            //gibt die Zeit in Monaten aus (zw. 0 u. 11)
         int Tage = alter.getDays();                                //gibt die Zeit in Tagen aus (zw. 0 u. 30)
         laufZeitLang = String.format("%04d:%02d:%02d", Jahre, Monate, Tage);
         System.out.println(laufZeitLang);
         //--------------------------------------------------------------------------
        
         Period irgendwannIn = Period.of(9, 10, 01);                //Zeitangabe (z.B. in die Zukunft) in (Jahre, Monate, Tage)
         LocalDate zukunft = liveDate.plus(irgendwannIn);            //Datum in der Zukunft
         System.out.println("Die Zukunft: " + zukunft);
        
         // LaufZeit in Sekunden
         lifeTimeSec = System.currentTimeMillis()/1000 - birth;
         System.out.println("LifeTimeSec: " + lifeTimeSec);
         System.out.println("");
        
        
    }

}

 

[White_Fox]

So es ist geschafft.

Immer wieder schön, wenn Leute auch die Lösung zu ihrem Problem präsentieren.