Lesson 14 - Date and Time in Java - Parsing and comparing
In the previous lesson, Date and Time in Java - Modifying and intervals, we learned to convert between LocalDateTime, LocalDate, and LocalTime, modify the inner value, and introduced time intervals. In today's Java course tutorial, we're going to finish up with the topic of date and time. We'll get inner values, parse using custom formats, and compare.
Retrieving the value
We read values using the get*() methods on the instance:
LocalDate halloween = LocalDate.of(2016, Month.OCTOBER, 31); System.out.println("Year: " + halloween.getYear() + ", month: " + halloween.getMonthValue() + ", day: " + halloween.getDayOfMonth());
Console application Year: 2016, month: 10, day: 31
Notice the use of the getMonthValue() to retrieve the month number. We had to use it, in this case, because getMonth() returns the value of the enumerated Month type.
Note: If you ever encounter the older Calendar class, beware that months were zero-based back then (January was 0, not 1 like it is now in LocalDate/LocalDateTime).
Parsing date and time
As you may already know, date and time often comes as a String, e.g. from the user through the console, a file or the database. We then create a LocalDateTime from the string value using the parse() method right on the data type as we're used to in Java.
The default parse() method expects dates to be in the "yyyy-mm-dd" format, date and times in the "yyyy-mm-ddThh:mm:ss" format and times in the "hh:mm:ss" format. All of the numbers have to have leading zeros if they’re less than 10. The "T" in the example below isn't a typo. It’s more of a separator for date and time:
LocalDateTime dateTime = LocalDateTime.parse("2016-12-08T10:20:30"); LocalDate date = LocalDate.parse("2016-12-08"); LocalTime time = LocalTime.parse("10:20:30"); System.out.println(dateTime.format(DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM))); System.out.println(date.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM))); System.out.println(time.format(DateTimeFormatter.ofLocalizedTime(FormatStyle.MEDIUM)));
Console application Dec 8, 2016 10:20:30 AM Dec 8, 2016 10:20:30 AM
Even more so, we'll need to parse an American date and time or date and time in some other format. The default "T" separator for date and time, here, isn't very user-friendly
LocalDateTime dateTime = LocalDateTime.parse("12/08/2016 10:20:30", DateTimeFormatter.ofPattern("M/d/y HH:mm:ss")); LocalDate date = LocalDate.parse("12/8/2016", DateTimeFormatter.ofPattern("M/d/y")); LocalTime time = LocalTime.parse("10:20:30", DateTimeFormatter.ofPattern("H:m:ss")); System.out.println(dateTime.format(DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM))); System.out.println(date.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM))); System.out.println(time.format(DateTimeFormatter.ofLocalizedTime(FormatStyle.MEDIUM)));
Console application Dec 8, 2016 10:20:30 AM Dec 8, 2016 10:20:30 AM
Since Java doesn't support operator overloading, we’ll compare the dates using methods. They all start with is*(), let's go through them:
- isAfter(date) - Returns whether the instance is after the date/date and time passed through the parameter (whether the value is greater).
- isBefore(date) - Returns whether the instance is before the date/date and time passed through the parameter (whether the value is lesser).
- isEqual(date) - Returns whether the instance is set to the same date and/or time as the instance passed in the parameter (whether the value is equal).
Easy enough, right? While on the topic of is*() methods, let's go over the rest of them:
- isLeapYear() - Returns whether the instance is set to a leap year or not.
- isSupported(ChronoUnit) - Returns whether the instance supports a given chrono unit (e.g. LocalDate won't support ChronoUnit.HOURS since it doesn't carry any time information).
Here’s an example of their use:
LocalDate halloween = LocalDate.of(2016, 10, 31); LocalDate christmas = LocalDate.of(2016, 12, 25); System.out.println("after: " + halloween.isAfter(christmas)); System.out.println("before: " + halloween.isBefore(christmas)); System.out.println("equals: " + christmas.isEqual(halloween)); System.out.println("equals: " + halloween.isEqual(halloween)); System.out.println("leap: " + halloween.isLeapYear()); System.out.println("leap: " + halloween.withYear(2017).isLeapYear()); System.out.println("supports hours: " + halloween.isSupported(ChronoUnit.HOURS)); System.out.println("supports years: " + halloween.isSupported(ChronoUnit.YEARS));
Console application after: false before: true equals: false equals: true leap: true leap: false supports hours: false supports years: true
Aside from LocalDateTime, LocalDate, and LocalTime, you may also encounter several other classes which you'll use rather than the aforementioned ones in applications whose main focus is date and time manipulation. Don’t worry, you'll get by with LocalDateTime in most applications. However, you should be aware of the existence of the following classes.
Instant represents a date and time that is not related to the calendar or to daylight saving. It's stored as a number of nanoseconds since 1/1/1970, which gives it a certain point in the UTC (universal time) timeline. The following code will always print the same date and time no matter where you’re located:
Instant instantNow = Instant.now(); System.out.println(instantNow);
Instant is only aware of universal time, so it'll differ from a particular area’s local time.
OffsetDateTime and ZonedDateTime
Now you know that Instant is used for universal time and LocalDateTime is used for a particular area’s local time. We wouldn't be able to get a point in a timeline from LocalDateTime since it doesn't carry any area information.
Wouldn’t it be great if there was a class where date and time would be local and also carry area information (timezone)? This way, we would be able to convert between various time zones. Well, that's exactly what the ZonedDateTime class is there for.
You may also encounter the OffsetDateTime class in Java, which is an intermediate Instant with the timezone offset. However, it comes without full timezone support.
In Java, time zones are represented by the ZoneId class. Here’s an example of its use (creating an instance based on a time zone):
ZonedDateTime localDateTime = ZonedDateTime.now(ZoneId.of("America/New_York")); System.out.println(localDateTime);
Console application 2016-12-09T04:30:41.597-05:00[America/New_York]
You may now be thinking, that's a lot of classes. I suggest that you treat it rather as information to which you may return to when you need it. There are more classes in Java than in many other programming languages. The best way to become a solid Java programmer is to be patient and develop some endurance to the fact. On the other hand, this is why we’re better paid than others We'll get to some more practical programming in the next lesson so as to take a break from the theoretical aspects of it all.
To top it all off, we’ll get acquainted with some more LocalDateTime methods.
- ofEpochSecond() - A static method allowing us to create a LocalDateTime instance from a Linux timestamp which was used to store dates in the past. In returns the number of seconds since 1/1/1970 (the beginning of the Linux epoch), which is a huge number, and we have to specify the nanoseconds as well (mostly 0) as well as a timezome (most often ZoneOffset.UTC). The method is also available on LocalDate as ofEpochDay() where it receives the number of days rather than seconds.
- toEpochSecond() and toEpochDay() - These methods do the exact opposite of the ones mentioned above. They convert the instance to the number of seconds/days since 1970.
That is all for date and time in Java 8. We'll code a practical application in the next lesson, an electronic diary.
No one has commented yet - be the first!