Datums in Java vergelijken

1. Inleiding

In deze tutorial zullen we ons concentreren op het vergelijken van datums met behulp van de Java 8 Date / Time API. We gaan in op verschillende methoden om te controleren of twee datums gelijk zijn en hoe we datums kunnen vergelijken.

2. Datums vergelijken

De basismanier om een ​​datum in Java uit te drukken is LocalDate. Laten we er twee bekijken LocalDate objectinstanties, die 10 augustus 2019 en 1 juli 2019 vertegenwoordigen:

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

We gaan er twee vergelijken LocalDate objecten door gebruik te maken van de isAfter (), isBefore (), en isEqual () methoden, net zoals is gelijk aan () en vergelijk met().

Wij gebruiken de isAfter () methode om te controleren of de datuminstantie na de andere opgegeven datum ligt. Daarom zal de volgende JUnit-bewering slagen:

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

Analoog de methode isBefore () controleert of de datuminstantie vóór de andere gespecificeerde datum valt:

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

De methode is gelijk() controleert of een datum hetzelfde punt op de lokale tijdlijn vertegenwoordigt als de andere gespecificeerde datum:

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

2.1. Datums vergelijken met de Vergelijkbaar Koppel

De is gelijk aan () methode geeft hetzelfde resultaat als is gelijk(), maar alleen als het doorgegeven argument van hetzelfde type is (in dit geval LocalDate):

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

De is gelijk() methode kan in plaats daarvan worden gebruikt om te vergelijken met objecten van een ander type, zoals JapaneseDate, ThaiBuddhistDate, enz.

We kunnen twee datuminstanties vergelijken met behulp van de vergelijk met() methode, zoals gedefinieerd door de Vergelijkbaar koppel:

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

3. Datuminstanties met de tijdcomponent vergelijken

In dit gedeelte wordt uitgelegd hoe u twee kunt vergelijken LocalDateTime gevallen. LocalDateTime instanties bevatten zowel de datum als de tijdcomponent.

gelijk aan LocalDate, we vergelijken er twee LocalDateTime instanties met de methoden isAfter (), isBefore () en is gelijk(). Bovendien, is gelijk aan () en vergelijk met() kan op dezelfde manier worden gebruikt als beschreven voor LocalDate.

Evenzo kunnen we dezelfde methoden gebruiken om twee te vergelijken ZonedDateTime gevallen. Laten we 8:00 lokale tijd in New York en 14:00 lokale tijd in Berlijn op dezelfde dag vergelijken:

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), is (false)); assertThat (timeInNewYork.isBefore (timeInBerlin), is (false)); assertThat (timeInNewYork.isEqual (timeInBerlin), is (true));

Hoewel beide ZonedDateTime instanties vertegenwoordigen hetzelfde moment in de tijd, ze vertegenwoordigen geen gelijke Java-objecten. Ze hebben verschillende LocalDateTime en ZoneId velden intern:

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

4. Aanvullende vergelijkingen

Laten we een eenvoudige utility-klasse maken voor iets complexere vergelijkingen.

Ten eerste zullen we controleren of er gevallen zijn van LocalDateTime en LocalDate zijn op dezelfde dag:

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

Ten tweede zullen we controleren of er twee gevallen zijn van LocalDateTime zijn op dezelfde dag:

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

De truncatedTo (TemporalUnit) methode kapt een datum af op het opgegeven niveau, wat in ons voorbeeld een dag is.

Ten derde kunnen we een vergelijking uitvoeren op het niveau van een uur:

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

Ten slotte kunnen we op een vergelijkbare manier controleren of er twee zijn ZonedDateTime gevallen gebeuren binnen hetzelfde uur:

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

We kunnen die twee zien ZonedDateTime objecten vinden feitelijk plaats binnen hetzelfde uur, zelfs als hun lokale tijden verschillen (respectievelijk 8:30 en 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), is (true));

5. Vergelijking in de oude Java Date API

Vóór Java 8 moesten we java.util.Date en java.util.Calendar klassen voor het manipuleren van datum- / tijdinformatie. Het ontwerp van de oude Java Date API heeft veel tekortkomingen, zoals complex en niet thread-safe. De java.util.Date instantie vertegenwoordigt een "moment in de tijd" en niet een echte datum.

Een van de oplossingen was om de Joda Time-bibliotheek te gebruiken. Sinds de release van Java 8 wordt aanbevolen om te migreren naar de Java 8 Date / Time API.

gelijk aan LocalDate en LocalDateTime, beide java.util.Date en java.util.Calendar objecten hebben na(), voordat(), vergelijk met() en is gelijk aan () methoden voor het vergelijken van twee datuminstanties. De datums worden vergeleken als de tijdstippen, op het niveau van een milliseconde:

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

Voor complexere vergelijkingen kunnen we gebruiken DateUtils uit de Apache Commons Lang-bibliotheek. Deze klasse bevat veel handige methoden om mee om te gaan Datum en Kalender voorwerpen:

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

Om datumobjecten die afkomstig zijn van de verschillende API's te vergelijken, moeten we eerst een goede conversie uitvoeren en pas daarna de vergelijking toepassen. We kunnen meer details vinden in onze tutorial Date to LocalDate of LocalDateTime and Back.

6. Conclusie

In dit artikel hebben we verschillende manieren onderzocht om datuminstanties in Java te vergelijken.

De Java 8 Date / Time-klassen hebben uitgebreide API's voor het vergelijken van datums, met of zonder tijd- en tijdzones. We hebben ook gezien hoe u datums kunt vergelijken op basis van de granulariteit van een dag, uur, minuut, enz.

Alle codefragmenten die in het artikel worden genoemd, inclusief aanvullende voorbeelden, zijn beschikbaar op GitHub.