Sammenligning av datoer i Java

1. Introduksjon

I denne opplæringen vil vi fokusere på hvordan du kan sammenligne datoer ved hjelp av Java 8 Date / Time API. Vi vil dykke inn i forskjellige metoder for å sjekke om to datoer er like og hvordan man sammenligner datoer.

2. Sammenligning av datoer

Den grunnleggende måten å uttrykke en dato på Java er LocalDate. La oss vurdere to LocalDate objektforekomster, som representerer 10. august 2019 og 1. juli 2019:

LocalDate firstDate = LocalDate.of (2019, 8, 10); LocalDate secondDate = LocalDate.of (2019, 7, 1);

Vi skal sammenligne to LocalDate objekter ved å bruke isAfter (), isBefore (), og isEqual () metoder, i tillegg til er lik() og sammenligne med().

Vi bruker isAfter () metode for å sjekke om datoinstansen er etter den andre spesifiserte datoen. Derfor vil neste JUnit-påstand bestå:

assertThat (firstDate.isAfter (secondDate), er (true));

Analogt, metoden isBefore () sjekker om datoinstansen er før den andre spesifiserte datoen:

assertThat (firstDate.isBefore (secondDate), er (false));

Metoden er lik() sjekker om en dato representerer samme punkt på den lokale tidslinjen som den andre spesifiserte datoen:

assertThat (firstDate.isEqual (firstDate), er (true)); assertThat (firstDate.isEqual (secondDate), er (false));

2.1. Sammenligning av datoer ved bruk av Sammenlignelig Grensesnitt

De er lik() metoden vil gi samme resultat som er lik(), men bare hvis argumentet som er sendt er av samme type (i dette tilfellet, LocalDate):

assertThat (firstDate.equals (secondDate), er (false));

De er lik() metoden kan brukes i stedet for å sammenligne med objekter av en annen type, for eksempel JapaneseDate, ThaiBuddhistDate, etc.

Vi kan sammenligne to datoinstanser ved å bruke sammenligne med() metode, som definert av Sammenlignelig grensesnitt:

assertThat (firstDate.compareTo (secondDate), er (1)); assertThat (secondDate.compareTo (firstDate), er (-1));

3. Sammenligning av datoinstanser som inneholder tidskomponenten

Denne delen vil forklare hvordan du kan sammenligne to LocalDateTime tilfeller. LocalDateTime forekomster inneholder både dato og tidskomponent.

På samme måte som LocalDate, vi sammenligner to LocalDateTime tilfeller med metodene isAfter (), isBefore () og er lik(). I tillegg er lik() og sammenligne med() kan brukes på en lignende måte som beskrevet for LocalDate.

På samme måte kan vi bruke de samme metodene for å sammenligne to ZonedDateTime tilfeller. La oss sammenligne 8:00 lokal tid i New York og 14:00 lokal tid i Berlin, samme dag:

ZonedDateTime timeInNewYork = ZonedDateTime.of (2019, 8, 10, 8, 0, 0, 0, ZoneId.of ("America / New_York")); ZonedDateTime timeInBerlin = ZonedDateTime.of (2019, 8, 10, 14, 0, 0, 0, ZoneId.of ("Europe / Berlin")); assertThat (timeInNewYork.isAfter (timeInBerlin), er (false)); assertThat (timeInNewYork.isBefore (timeInBerlin), er (false)); assertThat (timeInNewYork.isEqual (timeInBerlin), er (true));

Selv om begge deler ZonedDateTime tilfeller representerer samme øyeblikk i tid, representerer de ikke like Java-objekter. De har forskjellige LocalDateTime og ZoneId felt internt:

assertThat (timeInNewYork.equals (timeInBerlin), er (false)); assertThat (timeInNewYork.compareTo (timeInBerlin), er (-1));

4. Ytterligere sammenligninger

La oss lage en enkel nytteklasse for litt mer komplekse sammenligninger.

For det første vil vi sjekke om forekomster av LocalDateTime og LocalDate er på samme dag:

offentlig statisk boolsk isSameDay (LocalDateTime tidsstempel, LocalDate localDateToCompare) {return timestamp.toLocalDate (). isEqual (localDateToCompare); }

For det andre vil vi sjekke om to forekomster av LocalDateTime er på samme dag:

offentlig statisk boolsk isSameDay (LocalDateTime tidsstempel, LocalDateTime tidsstempelToCompare) {return timestamp.truncatedTo (DAYS) .isEqual (timestampToCompare.truncatedTo (DAYS)); }

De truncatedTo (TemporalUnit) metoden avkorter en dato på det gitte nivået, som i vårt eksempel er en dag.

For det tredje kan vi implementere en sammenligning på en times nivå:

offentlig statisk boolsk isSameHour (LocalDateTime tidsstempel, LocalDateTime tidsstempelToCompare) {retur tidsstempel.trunkeretTo (HOURS) .isEqual (tidsstempelToKompar.trunkeretTo (HOURS)); }

Til slutt, på en lignende måte, kan vi sjekke om to ZonedDateTime forekomster skjer innen samme time:

offentlig statisk boolsk isSameHour (ZonedDateTime zonedTimestamp, ZonedDateTime zonedTimestampToCompare) {return zonedTimestamp.truncatedTo (HOURS) .isEqual (zonedTimestampToCompare.truncatedTo (HOURS)); }

Vi kan se at to ZonedDateTime gjenstander skjer faktisk innen samme time, selv om deres lokale tid er forskjellig (henholdsvis 8:30 og 14:00):

ZonedDateTime zonedTimestamp = ZonedDateTime.of (2019, 8, 10, 8, 30, 0, 0, ZoneId.of ("America / New_York")); ZonedDateTime zonedTimestampToCompare = ZonedDateTime.of (2019, 8, 10, 14, 0, 0, 0, ZoneId.of ("Europe / Berlin")); assertThat (DateTimeComparisonUtils. isSameHour (zonedTimestamp, zonedTimestampToCompare), er (true));

5. Sammenligning i Old Java Date API

Før Java 8 måtte vi bruke java.util.Date og java.util.Kalender klasser for å manipulere informasjon om dato / tid. Utformingen av den gamle Java Date API har mange feil, for eksempel å være kompleks og ikke trådsikker. De java.util.Date forekomst representerer et "øyeblikkelig tidspunkt" og ikke en reell dato.

En av løsningene var å bruke Joda Time-biblioteket. Siden utgivelsen av Java 8 anbefales det å migrere til Java 8 Date / Time API.

På samme måte som LocalDate og LocalDateTime, både java.util.Date og java.util.Kalender gjenstander har etter(), før(), sammenligne med() og er lik() metoder for å sammenligne to datoinstanser. Datoene sammenlignes som øyeblikkene på et millisekund nivå:

Date firstDate = toDate (LocalDateTime.of (2019, 8, 10, 0, 00, 00)); Dato secondDate = toDate (LocalDateTime.of (2019, 8, 15, 0, 00, 00)); assertThat (firstDate.after (secondDate), er (false)); assertThat (firstDate.before (secondDate), er (sann)); assertThat (firstDate.compareTo (secondDate), er (-1)); assertThat (firstDate.equals (secondDate), er (false));

For mer komplekse sammenligninger kan vi bruke DateUtils fra biblioteket Apache Commons Lang. Denne klassen inneholder mange nyttige metoder for å håndtere Dato og Kalender gjenstander:

public static boolean isSameDay (Date date, Date dateToCompare) {return DateUtils.isSameDay (date, dateToCompare); } public static boolean isSameHour (Date date, Date dateToCompare) {return DateUtils.truncatedEquals (date, dateToCompare, Calendar.HOUR); }

For å sammenligne datoobjekter som stammer fra de forskjellige API-ene, bør vi først gjøre en skikkelig konvertering og først deretter bruke sammenligningen. Vi finner flere detaljer i vår Konverter dato til LocalDate eller LocalDateTime og Back-veiledning.

6. Konklusjon

I denne artikkelen har vi utforsket forskjellige måter å sammenligne datoforekomster i Java.

Java 8 Date / Time-klasser har rike APIer for å sammenligne datoer, med eller uten tid og tidssoner. Vi har også sett hvordan man kan sammenligne datoer på granulariteten til en dag, time, minutt osv.

Alle kodebitene som er nevnt i artikkelen, inkludert flere eksempler, er tilgjengelige på GitHub.


$config[zx-auto] not found$config[zx-overlay] not found