Java 8: Berechnen des Unterschieds zwischen zwei LocalDateTime

Ich versuche zur Berechnung der Differenz zwischen zwei LocalDateTime.

Die Ausgabe muss dem format y years m months d days h hours m minutes s seconds. Hier ist, was ich geschrieben habe:

import java.time.Duration;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.Period;
import java.time.ZoneId;

public class Main {

    static final int MINUTES_PER_HOUR = 60;
    static final int SECONDS_PER_MINUTE = 60;
    static final int SECONDS_PER_HOUR = SECONDS_PER_MINUTE * MINUTES_PER_HOUR;

    public static void main(String[] args) {
        LocalDateTime toDateTime = LocalDateTime.of(2014, 9, 9, 19, 46, 45);
        LocalDateTime fromDateTime = LocalDateTime.of(1984, 12, 16, 7, 45, 55);

        Period period = getPeriod(fromDateTime, toDateTime);
        long time[] = getTime(fromDateTime, toDateTime);

        System.out.println(period.getYears() + " years " + 
                period.getMonths() + " months " + 
                period.getDays() + " days " +
                time[0] + " hours " +
                time[1] + " minutes " +
                time[2] + " seconds.");


    }

    private static Period getPeriod(LocalDateTime dob, LocalDateTime now) {
        return Period.between(dob.toLocalDate(), now.toLocalDate());
    }

    private static long[] getTime(LocalDateTime dob, LocalDateTime now) {
        LocalDateTime today = LocalDateTime.of(now.getYear(),
                now.getMonthValue(), now.getDayOfMonth(), dob.getHour(), dob.getMinute(), dob.getSecond());
        Duration duration = Duration.between(today, now);

        long seconds = duration.getSeconds();

        long hours = seconds / SECONDS_PER_HOUR;
        long minutes = ((seconds % SECONDS_PER_HOUR) / SECONDS_PER_MINUTE);
        long secs = (seconds % SECONDS_PER_MINUTE);

        return new long[]{hours, minutes, secs};
    }
}

Den Ausgang, bin ich immer 29 years 8 months 24 days 12 hours 0 minutes 50 seconds. Ich habe mein Ergebnis von dieser website (mit Werten 12/16/1984 07:45:55 und 09/09/2014 19:46:45). Der folgende screenshot zeigt die Ausgabe:

Ich bin mir ziemlich sicher, dass die Felder nach dem Monat Wert ist kommen falsch von meinem code. Jeder Vorschlag wäre sehr hilfreich.

Update

Habe ich getestet, mein Ergebnis von einer anderen website und das Ergebnis bekam ich, anders. Hier ist es: Berechnen Sie die Dauer zwischen zwei Datumsangaben (Ergebnis: 29 Jahre, 8 Monaten, 24 Tagen, 12 Stunden, 0 Minuten und 50 Sekunden).

Update

Da hab ich zwei verschiedene Ergebnisse mit zwei verschiedenen Seiten, ich Frage mich, ob der Algorithmus meiner Berechnung legitim ist oder nicht. Wenn ich folgende zwei LocalDateTime Objekte:

LocalDateTime toDateTime = LocalDateTime.of(2014, 9, 10, 6, 40, 45);
LocalDateTime fromDateTime = LocalDateTime.of(1984, 12, 16, 7, 45, 55);

Dann die Ausgabe kommen: 29 years 8 months 25 days -1 hours -5 minutes -10 seconds.

Aus diesem link es sollte 29 years 8 months 24 days 22 hours, 54 minutes and 50 seconds. So muss der Algorithmus zu handhaben, die negative zahlen zu.

Hinweis: die Frage ist nicht, über die Website gab mir, was ich wissen müssen, den richtigen Algorithmus und müssen das Recht haben, die Ergebnisse.

Nur eine Vermutung, aber könnte Period.between() gelten einige der Rundung?
Ich sah den code noch einmal ein und es scheint, dass die Webseite falsch ist (Versuchen Sie die Berechnung selbst). Wenn du weglassen, das Datum, d.h. Unterschiede in der Jahr, Monat und Tag, erhalten Sie die Startzeit 7:45:55 und das Ende der Zeit 19:46:45 (oder 7:46:45 Uhr). Also der Unterschied zwischen denen zwei mal 12 Stunden, 0 Minuten und 50 Sekunden und nie 23 Stunden, 34 Minuten und 12 Sekunden. Also deine Berechnung actualle scheint richtig zu sein, zumindest auf den Teil der Zeit.
Interessantes Phänomen auf dieser website: hinzufügen von 10 Jahren ab Datum und die Differenz in Stunden änderungen von 23 auf 8 - sicher ein Zeichen für Fehler.
Hinzugefügt vor 1 Jahr, 4 und 10 - keine Veränderung in Stunden
hast du den zweiten link in meinem update?
Beachten Sie, dass seit LocalDateTime hat kein Zeit-zone, könnte es nicht sein, eine eindeutige Antwort. Auch wenn Sie davon ausgehen, die start-und end-Zeit-Zonen sind die gleichen, in bestimmten Zonen Termine wie 2014-09-09 werden in der Sommerzeit oder Sommerzeit, in anderen nicht. Dies mag throw-off Dinge, indem Sie eine Stunde. Also das berechnen der Differenz der zweite ist sinnlos, es sei denn, dies ist gelöst.
"ich habe getestet, mein Ergebnis von einer anderen website und das Ergebnis bekam ich, anders" > So, dass die mit Ihrem Java-code. Scheint, wie diese Frage ist nun überflüssig - die andere website ist gebrochen.
bitte siehe update, die Frage ist nicht redundant.
dann muss ich verwenden ZonedDateTime; richtig?
wenn man sich den code für das Datum abrufen Zeit werden Sie feststellen, dass der Teil entfernt wird und somit nur das Datum betrachtet. Das ist, warum Sie bekommen 24 Tage statt 23.
ZonedDateTime wird Ihnen helfen zu vermeiden das bestimmte problem, das ich erwähnte.
Was java.time.Duration.between(Temporal a, Temporal b) ? Laut javadoc: Erhält eine Dauer der Vertretung die Dauer zwischen zwei zeitlichen Objekten. Dieser berechnet die Dauer zwischen zwei zeitlichen Objekten. Wenn die Objekte verschiedener Typen enthalten, dann wird die Dauer berechnet, basierend auf dem Typ des ersten Objekts. Zum Beispiel, wenn das erste argument ein LocalTime dann das zweite argument ist in einer LocalTime.
Verstehen Sie, dass die Verwendung LocalDateTime Erträge unrealistischen Ergebnisse, wie die Klasse absichtlich fehlt jede Vorstellung von Zeit zone oder offset-von-UTC? Für realistische Werte, weisen eine Zeitzone über ZoneId zu verwenden ZonedDateTime.

InformationsquelleAutor Tapas Bose | 2014-09-09

136

Leider scheint es nicht eine Periode, in der Klasse, die sich über die Zeit als gut, so müssen Sie möglicherweise führen Sie die Berechnungen auf Ihrem eigenen.

Forunately das Datum und die Zeit, die Klassen haben eine Menge von utility-Methoden, die Vereinfachung, die zu einem gewissen Grad. Hier ist ein Weg, um die Differenz zu ermitteln, wenngleich Sie nicht unbedingt der Schnellste:
```
LocalDateTime fromDateTime = LocalDateTime.of(1984, 12, 16, 7, 45, 55);
LocalDateTime toDateTime = LocalDateTime.of(2014, 9, 10, 6, 40, 45);

LocalDateTime tempDateTime = LocalDateTime.from( fromDateTime );

long years = tempDateTime.until( toDateTime, ChronoUnit.YEARS);
tempDateTime = tempDateTime.plusYears( years );

long months = tempDateTime.until( toDateTime, ChronoUnit.MONTHS);
tempDateTime = tempDateTime.plusMonths( months );

long days = tempDateTime.until( toDateTime, ChronoUnit.DAYS);
tempDateTime = tempDateTime.plusDays( days );


long hours = tempDateTime.until( toDateTime, ChronoUnit.HOURS);
tempDateTime = tempDateTime.plusHours( hours );

long minutes = tempDateTime.until( toDateTime, ChronoUnit.MINUTES);
tempDateTime = tempDateTime.plusMinutes( minutes );

long seconds = tempDateTime.until( toDateTime, ChronoUnit.SECONDS);

System.out.println( years + " years " + 
        months + " months " + 
        days + " days " +
        hours + " hours " +
        minutes + " minutes " +
        seconds + " seconds.");

//prints: 29 years 8 months 24 days 22 hours 54 minutes 50 seconds.
```
Die grundlegende Idee ist folgende: erstellen Sie einen temporären Startdatum und in den vollen Jahren zu Ende. Stellen Sie dann das Datum ein, indem Sie die Anzahl der Jahre, so dass das start-Datum ist weniger als ein Jahr nach dem Ende. Wiederholen Sie, dass für jede Zeiteinheit, in absteigender Reihenfolge.

Endlich mal ein disclaimer: ich habe keine unterschiedlichen Zeitzonen zu berücksichtigen (beide Daten sollten in der gleichen Zeitzone) und ich auch nicht testen/überprüfen, wie die Sommerzeit ein -, oder andere änderungen in einem Kalender (wie die Zeitzone ändert sich in Samoa) Einfluss auf diese Berechnung. So nutzen Sie mit Sorgfalt.
- Sie haben die gleiche grundlegende Idee, daher mein upvote, aber versuchen Sie bitte, die gleichen input-sonst wird die andere Folge ist verwirrend.
- es wird den gleichen Eingang, genau genommen aus dem update, wo der OP hat Probleme mit negativen Uhrzeiten. 😉
- Ah ich sehe. Sah nur die erste Eingabe an den start des OPs posting.
- das ist schlecht von JSR310 weil JodaTime hat es: Punkt p = new Punkt(date1, date2, PeriodType.yearMonthDayTime()); int Jahre = p.getYears(); int mon = p.getMonths(); int Tag = p.getDays(); int hrs = p.getHours(); int min = p.getMinutes(); int Sek = p.getSeconds(); int mil = p.getMillis();
- Guter Algorithmus, aber die falsche Art (siehe Thomas disclaimer). Bevor Sie Ihre Berechnung, sollten Sie konvertieren Sie Ihre LocalDateTime Variablen ZonedDateTime mit Standard-Zeitzone zum Beispiel (oder eine beliebige Zeitzone, die Sie brauchen) : ZonedDateTime fromZonedDateTime = fromDateTime.atZone(amp; zoneid.systemDefault());
- Niemand sollte es unbeholfen in der Gegenwart von ChronoUnit, die Teil der java.time, als vorgestellt von satnam.
- du hast Recht, wenn man in der Lage auf Java 8 (die war nicht weit verbreitet, wenn ich geschrieben die Antwort) - und auch heute nicht jeder ist in der Lage auf Java 8.
- Dein Beispiel mit Java 8 als gut und die Frage ist tagged as java-8. In der Tat, Ihr Beispiel ist auch mit ChronoUnit 🙂 aber tut den job "von hand".
- oh ja, du hast Recht. Total verpasst haben 😉 - Außerdem, Sie würden noch abziehen, die größere Einheiten aus dem Intervall, da zum Beispiel long minutes = ChronoUnit.MINUTES.between(fromDate, toDate); zurückkehren würde, eine Zahl, die größer als 59 werden für jedes Intervall von mindestens 1 Stunde - und das ist nicht das, was der OP will. Nehmen Sie in account, Sie würden nicht in der Lage, nur 6 Aufrufe ChronoUnit#between() und durchgeführt werden.
InformationsquelleAutor Thomas
414

Ich fand die beste Weg, dies zu tun ist mit ChronoUnit.
```
long minutes = ChronoUnit.MINUTES.between(fromDate, toDate);
long hours = ChronoUnit.HOURS.between(fromDate, toDate);
```
Zusätzliche Dokumentation ist hier: https://docs.oracle.com/javase/tutorial/datetime/iso/period.html
- Ich sehe keine wirkliche Verbesserung. Im Vergleich mit akzeptierten Thomas' Antwort, die Sie ersetzen Sie einfach tempDateTime.until( toDateTime, ChronoUnit.YEARS) mit ChronoUnit.YEARS.between(fromDate, toDate). Aber das wichtige zusätzliche Zeilen wie tempDateTime.plusYears( years ) etc. völlig fehlt in deiner Antwort, damit es nicht zur OP. Der vollständige Algorithmus ist wichtig!
- Ich mag dieses besser, da es kürzer und mehr Lesen Sie lesbar. Dies ist der beste Weg, um die Differenz zwischen zwei Datumsangaben.
- Nein, Sie vollkommen übersehen, dass der kritische Punkt. Der OP will nicht, dass eine Dauer von nur ein Gerät, sondern mehrere units, und daher diese Antwort ist keine wirkliche Antwort an alle. Die OP ' s Anliegen ist einfach nicht angesprochen. Bitte seien Sie so freundlich, noch einmal zu Lesen die Frage. (Viel upvoters zu haben scheinen, falsch verstanden, die Frage).
- Ich denke, dass Sie eigentlich diejenige ist, fehlt der kritische Punkt. Der OP bekam Ihre Antwort vor über einem Jahr. Die 36 tausend Menschen, die betrachten diese Frage nicht kümmern, die OP-spezifische Frage. Sie wurden hier von google und meine Antwort gibt Ihnen das, was Sie suchten-eine saubere und einfache Lösung für das erhalten der Differenz zwischen zwei Datumsangaben.
- "nicht die Sorge um die OP-spezifische Frage" ist eine ehrliche Aussage und bestätigt meine Beobachtung, dass viele Menschen einfach falsch verstehen, die Frage in einer verkürzten Art und Weise. Der Aspekt über ChronoUnit.between(...) ist nichts neues, sondern finden mehrmals hier auf die SO Beispiel-link mit einer Antwort von dem Haupt-Autor von JSR-310
- Ich brauchte Sekunden, die Differenz zwischen zwei Datums-mal und begann mit der Umsetzung meiner eigenen Lösung. Kurz, es scheint zu Komplex und ich fand auf google. satnam Antwort kann nicht Antworten OP in Frage, aber für sicher, dass hat mir sehr geholfen und ich Wette, viele viele andere wie mich.
- Damit beantwortet der Titel der Frage "Berechnen Differenz zwischen zwei LocalDateTime'. Die eigentliche Frage hat wenig mit dem Titel zu tun, damit die Verwirrung und die vielen upvotes.
- In meinem Fall möchte ich prüfen, ob das Datum ist von gestern und es schlägt fehl, wenn der Unterschied zwischen 24-Stunden-obwohl die Tage sind unterschiedlich. Also ich musste mein custom-checker. Ich teilte die checker hier, wenn jemand verwenden möchte oder kann mir helfen, zu optimieren, gist.github.com/hendrawd/9f9b77557b16579c84759c5c699b5343
- Können Sie darlegen, warum? Wie kann ich es verbessern?
- isYesterday() kann geschrieben werden als eine einzige Zeile code. zurück LocalDate.jetzt().minusDays(1).equals(Eingabe.toLocalDate()); Vergleich der formatierten strings ist nicht der beste Weg, es zu tun.
- Dies sollte akzeptiert werden Antwort.
InformationsquelleAutor satnam

Hier ein einzelnes Beispiel für die Verwendung Dauer und TimeUnit um 'hh:mm:ss' - format.

Duration dur = Duration.between(localDateTimeIni, localDateTimeEnd);
long millis = dur.toMillis();

String.format("%02d:%02d:%02d", 
        TimeUnit.MILLISECONDS.toHours(millis),
        TimeUnit.MILLISECONDS.toMinutes(millis) - 
        TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(millis)),
        TimeUnit.MILLISECONDS.toSeconds(millis) - 
        TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis)));

Ist es eigentlich möglich, es zu tun mögen dieses: String.format("%02d:%02d:%02d",dur.toHoursPart(), dur.toMinutesPart(), dur.toSecondsPart());. Der Teil Methoden geben Ihnen die richtigen zahlen zu bauen, die einen string. Ich denke, dass es' mehr lesbar.
Anmerkung zu meinem vorherigen Kommentar: die Teil-Methoden sind nur verfügbar, von JDK 9 und up.

InformationsquelleAutor Junior Batista

18

Es sollte einfacher sein!
```
Duration.between(startLocalDateTime, endLocalDateTime).toMillis();
```
- Ich glaube, das ist eigentlich die semantisch korrekte Lösung ab Java 8. Und vor dieser version, JodaTime macht das gleiche.
InformationsquelleAutor Zon

Und die version von @Thomas in Groovy mit die gewünschten Einheiten in einer Liste statt hardcoding die Werte. Diese Umsetzung (die leicht portiert auf Java - ich habe die Deklaration der Funktion explicit) macht Thomas Ansatz mehr wiederverwendbar.

def fromDateTime = LocalDateTime.of(1968, 6, 14, 0, 13, 0)
def toDateTime = LocalDateTime.now()
def listOfUnits = [
    ChronoUnit.YEARS, ChronoUnit.MONTHS, ChronoUnit.DAYS,
    ChronoUnit.HOURS, ChronoUnit.MINUTES, ChronoUnit.SECONDS,
    ChronoUnit.MILLIS]

println calcDurationInTextualForm(listOfUnits, fromDateTime, toDateTime)    

String calcDurationInTextualForm(List<ChronoUnit> listOfUnits, LocalDateTime ts, LocalDateTime to)
{
    def result = []

    listOfUnits.each { chronoUnit ->
        long amount = ts.until(to, chronoUnit)
        ts = ts.plus(amount, chronoUnit)

        if (amount) {
            result << "$amount ${chronoUnit.toString()}"
        }
    }

    result.join(', ')
}

Zum Zeitpunkt des Schreibens dieses Artikels,ist der code oben gibt 47 Years, 8 Months, 9 Days, 22 Hours, 52 Minutes, 7 Seconds, 140 Millis. Und für @Gennadi Kolomoets Eingang, gibt der code 23 Hours.

Wenn Sie eine Liste der Einheiten, es muss sortiert werden, indem die Größe der Einheiten (größte zuerst):

def listOfUnits = [ChronoUnit.WEEKS, ChronoUnit.DAYS, ChronoUnit.HOURS]
//returns 2495 Weeks, 3 Days, 8 Hours

InformationsquelleAutor ChrLipp

Hier ist eine sehr einfache Antwort auf Ihre Frage. Es funktioniert.

import java.time.*;
import java.util.*;
import java.time.format.DateTimeFormatter;
public class MyClass {
    public static void main(String args[]) {
       DateTimeFormatter T = DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm");
       Scanner h = new Scanner(System.in);

       System.out.print("Enter date of birth[dd/mm/yyyy hh:mm]: ");
       String b = h.nextLine();

       LocalDateTime bd = LocalDateTime.parse(b,T);
       LocalDateTime cd = LocalDateTime.now();

       int hr = cd.getHour() - bd.getHour();
       int mn = cd.getMinute() - bd.getMinute();

       Period time = Period.between(bd.toLocalDate(),cd.toLocalDate());

       System.out.print("Age is: "+time.getYears()+ " years,"+time.getMonths()+ " months, " +time.getDays()+ " days, "+hr+ " hours, " +mn+ " minutes old");
    }
}

InformationsquelleAutor SavedBeau

Gibt es einige problem für Tapas Bose-code und Thomas-code. Wenn die Zeitdifferenz negativ ist, wird der array bekommt die negativen Werte. Zum Beispiel, wenn

LocalDateTime toDateTime = LocalDateTime.of(2014, 9, 10, 6, 46, 45);
LocalDateTime fromDateTime = LocalDateTime.of(2014, 9, 9, 7, 46, 45);

gibt es 0 Jahre 0 Monate 1 Tage, -1 Stunden, 0 Minuten, 0 Sekunden.

Denke ich die richtige Ausgabe ist: 0 Jahre 0 Monate 0 Tage 23 Stunden 0 Minuten 0 Sekunden.

Ich schlage vor, trennen Sie die LocalDateTime-Instanzen auf LocalDate und LocalTime-Instanzen. Nachdem wir das Java-8 Zeit und Dauer-Instanzen. Die Dauer Instanz wird getrennt auf die Anzahl der Tage und während-den-Tag-Zeit-Wert (< 24h) mit anschließender Korrektur der Zeit-Wert. Wenn die zweite LocalTime-Wert ist vor der firstLocalTime Wert, ist es notwendig, reduzieren Sie die Zeit für einen Tag.

Hier ist mein Weg zur Berechnung der LocalDateTime Unterschied:

private void getChronoUnitForSecondAfterFirst(LocalDateTime firstLocalDateTime, LocalDateTime secondLocalDateTime, long[] chronoUnits) {
    /*Separate LocaldateTime on LocalDate and LocalTime*/
    LocalDate firstLocalDate = firstLocalDateTime.toLocalDate();
    LocalTime firstLocalTime = firstLocalDateTime.toLocalTime();

    LocalDate secondLocalDate = secondLocalDateTime.toLocalDate();
    LocalTime secondLocalTime = secondLocalDateTime.toLocalTime();

    /*Calculate the time difference*/
    Duration duration = Duration.between(firstLocalDateTime, secondLocalDateTime);
    long durationDays = duration.toDays();
    Duration throughoutTheDayDuration = duration.minusDays(durationDays);
    Logger.getLogger(PeriodDuration.class.getName()).log(Level.INFO,
            "Duration is: " + duration + " this is " + durationDays
            + " days and " + throughoutTheDayDuration + " time.");

    Period period = Period.between(firstLocalDate, secondLocalDate);

    /*Correct the date difference*/
    if (secondLocalTime.isBefore(firstLocalTime)) {
        period = period.minusDays(1);
        Logger.getLogger(PeriodDuration.class.getName()).log(Level.INFO,
                "minus 1 day");
    }

    Logger.getLogger(PeriodDuration.class.getName()).log(Level.INFO,
            "Period between " + firstLocalDateTime + " and "
            + secondLocalDateTime + " is: " + period + " and duration is: "
            + throughoutTheDayDuration
            + "\n-----------------------------------------------------------------");

    /*Calculate chrono unit values and  write it in array*/
    chronoUnits[0] = period.getYears();
    chronoUnits[1] = period.getMonths();
    chronoUnits[2] = period.getDays();
    chronoUnits[3] = throughoutTheDayDuration.toHours();
    chronoUnits[4] = throughoutTheDayDuration.toMinutes() % 60;
    chronoUnits[5] = throughoutTheDayDuration.getSeconds() % 60;
}

Dem obigen Verfahren können verwendet werden, um die Differenz zu ermitteln, alle lokalen Datum und Zeit Werte, zum Beispiel:

public long[] getChronoUnits(String firstLocalDateTimeString, String secondLocalDateTimeString) {
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

    LocalDateTime firstLocalDateTime = LocalDateTime.parse(firstLocalDateTimeString, formatter);
    LocalDateTime secondLocalDateTime = LocalDateTime.parse(secondLocalDateTimeString, formatter);

    long[] chronoUnits = new long[6];
    if (secondLocalDateTime.isAfter(firstLocalDateTime)) {
        getChronoUnitForSecondAfterFirst(firstLocalDateTime, secondLocalDateTime, chronoUnits);
    } else {
        getChronoUnitForSecondAfterFirst(secondLocalDateTime, firstLocalDateTime, chronoUnits);
    }
    return chronoUnits;
}

Ist es zweckmäßig, schreiben Sie einen unit-test für die oben genannten-Methode (beide sind PeriodDuration Schüler). Hier ist der code:

@RunWith(Parameterized.class)
public class PeriodDurationTest {

private final String firstLocalDateTimeString;
private final String secondLocalDateTimeString;
private final long[] chronoUnits;

public PeriodDurationTest(String firstLocalDateTimeString, String secondLocalDateTimeString, long[] chronoUnits) {
    this.firstLocalDateTimeString = firstLocalDateTimeString;
    this.secondLocalDateTimeString = secondLocalDateTimeString;
    this.chronoUnits = chronoUnits;
}

@Parameters
public static Collection<Object[]> periodValues() {
    long[] chronoUnits0 = {0, 0, 0, 0, 0, 0};
    long[] chronoUnits1 = {0, 0, 0, 1, 0, 0};
    long[] chronoUnits2 = {0, 0, 0, 23, 0, 0};
    long[] chronoUnits3 = {0, 0, 0, 1, 0, 0};
    long[] chronoUnits4 = {0, 0, 0, 23, 0, 0};
    long[] chronoUnits5 = {0, 0, 1, 23, 0, 0};
    long[] chronoUnits6 = {29, 8, 24, 12, 0, 50};
    long[] chronoUnits7 = {29, 8, 24, 12, 0, 50};
    return Arrays.asList(new Object[][]{
        {"2015-09-09 21:46:44", "2015-09-09 21:46:44", chronoUnits0},
        {"2015-09-09 21:46:44", "2015-09-09 22:46:44", chronoUnits1},
        {"2015-09-09 21:46:44", "2015-09-10 20:46:44", chronoUnits2},
        {"2015-09-09 21:46:44", "2015-09-09 20:46:44", chronoUnits3},
        {"2015-09-10 20:46:44", "2015-09-09 21:46:44", chronoUnits4},
        {"2015-09-11 20:46:44", "2015-09-09 21:46:44", chronoUnits5},
        {"1984-12-16 07:45:55", "2014-09-09 19:46:45", chronoUnits6},
        {"2014-09-09 19:46:45", "1984-12-16 07:45:55", chronoUnits6}
    });
}

@Test
public void testGetChronoUnits() {
    PeriodDuration instance = new PeriodDuration();
    long[] expResult = this.chronoUnits;
    long[] result = instance.getChronoUnits(this.firstLocalDateTimeString, this.secondLocalDateTimeString);
    assertArrayEquals(expResult, result);
}

}

Alle tests erfolgreich sind, ob oder nicht der Wert des ersten LocalDateTime ist vor und für jede LocalTime Werte.

Kann ich nicht reproduzieren Ihre Aussage, dass Thomas-code mit Ihrem Eingang oben erzeugt gemischte Zeichen. Meine Ausgabe ist: "0 Jahre, 0 Monate, 0 Tage, 23 Stunden 0 Minuten 0 Sekunden.". Und die ich getestet habe, nur jetzt.
Danke für den Kommentar. Ich habe gründlich getestet, die Thomas-code, in der Tat, es arbeitet richtig! Die Magie geschieht durch LocalDateTime, bis die Methode der Korrektur chrono-Einheiten. Negative Werte in der Thomas-code angezeigt, wenn der erste DateTime ist später als die zweite. Dies kann aber einfach korrigiert werden, zum Beispiel, wie ich in den obigen code. Nochmals vielen Dank.
Naja, Thomas-code und meine Bibliothek Time4J unter Verwendung des gleichen Algorithmus für die Berechnung von Laufzeiten produzieren kann negative Vorzeichen, aber nur für die gesamte Dauer. Das ist der entscheidende Punkt! Das Zeichen bezieht sich auf die gesamte Dauer und damit beschreibt, wenn der start später als Ende und ist nie bezogen auf einzelne Dauer-Komponenten. Gemischte Zeichen sind hier nicht möglich und würde verhindern, dass eine solche interpretation beginnen, relativ zum Ende (Gegenbeispiel sind die Joda-Time-Periode oder der java.time.Period wo die Benutzer erzwingen/erzeugen solche gemischten Zeichen, aufgrund von verschiedenen internen design).

InformationsquelleAutor Gennady Kolomoets

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.