Dátumok összehasonlítása Java-ban

1. Bemutatkozás

Ebben az oktatóanyagban arra összpontosítunk, hogy miként lehet összehasonlítani a dátumokat a Java 8 Date / Time API segítségével. Különböző módszereket vizsgálunk meg annak ellenőrzésére, hogy két dátum egyenlő-e, és hogyan lehet összehasonlítani a dátumokat.

2. Dátumok összehasonlítása

A dátum Java-ban történő kifejezésének alapvető módja az LocalDate. Tekintsünk kettőt LocalDate objektum példányok, amelyek 2019. augusztus 10-ét és július 1-jét képviselik:

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

Összehasonlítunk kettőt LocalDate objektumokat a isAfter (), isBefore (), és isEqual () metódusok, továbbá egyenlő () és összehasonlítani().

Használjuk a isAfter () módszer annak ellenőrzésére, hogy a dátumpéldány a másik megadott dátum után van-e. Ezért a következő JUnit-állítás elmúlik:

assertThat (firstDate.isAfter (secondDate), (igaz));

Hasonlóképpen a módszer isBefore () ellenőrzi, hogy a dátumpéldány a másik megadott dátum előtt van-e:

assertThat (firstDate.isBefore (secondDate), (hamis));

A módszer, a metódus egyenlő() ellenőrzi, hogy egy dátum ugyanazt a pontot képviseli-e a helyi idővonalon, mint a másik megadott dátum:

assertThat (firstDate.isEqual (firstDate), (igaz)); assertThat (firstDate.isEqual (secondDate), is (hamis));

2.1. Dátumok összehasonlítása a Hasonló Felület

A egyenlő () módszer ugyanazt az eredményt adja, mint egyenlő(), de csak akkor, ha az átadott argumentum azonos típusú (ebben az esetben LocalDate):

assertThat (firstDate.equals (secondDate), is (hamis));

A egyenlő() metódus használható más típusú objektumokkal való összehasonlításhoz, mint pl JapaneseDate, ThaiBuddhistDatestb.

Két dátumpéldányt összehasonlíthatunk a összehasonlítani() módszer, a Hasonló felület:

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

3. Az Időkomponenset tartalmazó dátumpéldányok összehasonlítása

Ez a szakasz elmagyarázza, hogyan lehet kettőt összehasonlítani LocalDateTime példányok. LocalDateTime a példányok tartalmazzák a dátumot és az idő összetevőt.

Hasonlóan LocalDate, kettőt hasonlítunk össze LocalDateTime példák a módszerekkel isAfter (), isBefore () és egyenlő(). Ezenkívül egyenlő () és összehasonlítani() leírásához hasonló módon használható LocalDate.

Ugyanígy ugyanazokat a módszereket alkalmazhatjuk kettő összehasonlítására is ZonedDateTime példányok. Hasonlítsuk össze New York-i helyi idő szerint 8:00 és Berlinben 14:00 helyi idő szerint ugyanazon a napon:

ZonedDateTime timeInNewYork = ZonedDateTime.of (2019, 8, 10, 8, 0, 0, 0, ZoneId.of ("Amerika / New_York")); ZonedDateTime timeInBerlin = ZonedDateTime.of (2019, 8, 10, 14, 0, 0, 0, ZoneId.of ("Európa / Berlin")); assertThat (timeInNewYork.isAfter (timeInBerlin), van (hamis)); assertThat (timeInNewYork.isBefore (timeInBerlin), is (hamis)); assertThat (timeInNewYork.isEqual (timeInBerlin), is (igaz));

Bár mindkettő ZonedDateTime a példányok ugyanazt az időpontot képviselik, nem azonos Java objektumokat képviselnek. Különbözőek LocalDateTime és ZoneId belső mezők:

assertThat (timeInNewYork.equals (timeInBerlin), is (hamis)); assertThat (timeInNewYork.compareTo (timeInBerlin), (-1));

4. További összehasonlítások

Hozzunk létre egy egyszerű segédosztályt a kissé összetettebb összehasonlításokhoz.

Először ellenőrizzük, hogy vannak-e LocalDateTime és LocalDate ugyanazon a napon vannak:

public static boolean isSameDay (LocalDateTime timestamp, LocalDate localDateToCompare) {return timestamp.toLocalDate (). isEqual (localDateToCompare); }

Másodszor ellenőrizzük, hogy van-e két példánya LocalDateTime ugyanazon a napon vannak:

public static boolean isSameDay (LocalDateTime timestamp, LocalDateTime timestampToCompare) {return timestamp.truncatedTo (DAYS) .isEqual (timestampToCompare.truncatedTo (DAYS)); }

A truncatedTo (TemporalUnit) metódus csonkol egy dátumot az adott szinten, amely példánkban egy nap.

Harmadszor, összehasonlítást valósíthatunk meg egy óra szinten:

public static boolean isSameHour (LocalDateTime timestamp, LocalDateTime timestampToCompare) {return timestamp.truncatedTo (HOURS) .isEqual (timestampToCompare.truncatedTo (HOURS)); }

Végül hasonló módon ellenőrizhetjük, hogy kettő van-e ZonedDateTime esetek ugyanabban az órán belül történnek:

public static boolean isSameHour (ZonedDateTime zonedTimestamp, ZonedDateTime zonedTimestampToCompare) {return zonedTimestamp.truncatedTo (HOURS) .isEqual (zonedTimestampToCompare.truncatedTo (HOURS)); }

Láthatjuk azt a kettőt ZonedDateTime az objektumok valójában ugyanazon órán belül történnek, még akkor is, ha a helyi idő eltér egymástól (8:30 és 14:00):

ZonedDateTime zonedTimestamp = ZonedDateTime.of (2019, 8, 10, 8, 30, 0, 0, ZoneId.of ("Amerika / New_York")); ZonedDateTime zonedTimestampToCompare = ZonedDateTime.of (2019, 8, 10, 14, 0, 0, 0, ZoneId.of ("Európa / Berlin")); assertThat (DateTimeComparisonUtils. isSameHour (zonedTimestamp, zonedTimestampToCompare), (true));

5. Összehasonlítás a régi Java Date API-ban

A Java 8 előtt használnunk kellett java.util.Dátum és java.util.Naptár osztályok a dátum / idő információ kezelésére. A régi Java Date API kialakításának számos hibája van, például összetett és nem szálbiztos. A java.util.Dátum a példány „pillanat az időben”, nem pedig valós dátumot jelent.

Az egyik megoldás a Joda Time könyvtár használata volt. A Java 8 megjelenése óta javasoljuk a migrációt a Java 8 Date / Time API-ra.

Hasonlóan LocalDate és LocalDateTime, mindkét java.util.Dátum és java.util.Naptár tárgyak rendelkeznek utána(), előtt(), összehasonlítani() és egyenlő () módszerek két dátumpéldány összehasonlítására. A dátumokat összehasonlítjuk az idő pillanataival, ezredmásodperc szinten:

Date firstDate = toDate (LocalDateTime.of (2019, 8, 10, 0, 00, 00)); Date secondDate = toDate (LocalDateTime.of (2019, 8, 15, 0, 00, 00)); assertThat (firstDate.after (secondDate), (hamis)); assertThat (firstDate.before (secondDate), (igaz)); assertThat (firstDate.compareTo (secondDate), (-1)); assertThat (firstDate.equals (secondDate), is (hamis));

Összetettebb összehasonlításokhoz használhatjuk DateUtils az Apache Commons Lang könyvtárból. Ez az osztály sok praktikus módszert tartalmaz a kezeléshez Dátum és Naptár tárgyak:

nyilvános statikus logikai isSameDay (dátum dátum, dátum dátumToCompare) {return DateUtils.isSameDay (dátum, dátumToCompare); } public static boolean isSameHour (Date date, Date dateToCompare) {return DateUtils.truncatedEquals (date, dateToCompare, Calendar.HOUR); }

A különböző API-kból származó dátumobjektumok összehasonlításához először megfelelő konverziót kell végrehajtanunk, és csak azután alkalmazzuk az összehasonlítást. További részletek a Dátum konvertálása LocalDate vagy LocalDateTime és Back oktatóanyagunkban találhatók.

6. Következtetés

Ebben a cikkben különböző módszereket tártunk fel a Java dátumpéldányainak összehasonlítására.

A Java 8 dátum / idő osztályok gazdag API-kat tartalmaznak a dátumok összehasonlítására, idővel és időzónával vagy anélkül. Láttuk azt is, hogyan lehet összehasonlítani a dátumokat egy nap, óra, perc stb.

A cikkben említett összes kódrészlet, beleértve a további példákat is, elérhető a GitHub oldalon.