Convert Date to LocalDate or LocalDateTime and Back

1. Overview

Starting with Java 8, we have a new Date API: java.time.

However, sometimes we still need to perform conversions between the new and old APIs and work with date representations from both.

2. Converting java.util.Date to java.time.LocalDate

In this section, let’s look at ways to convert a java.util.Date object to the new java.time.LocalDate type.

2.1. Using toInstant() and toLocalDate()

Let’s start with converting the old date representation to the new one.

Here, we can take advantage of a new toInstant() method, which was added to java.util.Date in Java 8.

When we’re converting an Instant object, it’s required to use a ZoneId because Instant objects are time-zone agnostic — just points on the timeline.

The atZone(ZoneId zone) API from Instant returns a ZonedDateTime, so we just need to extract LocalDate from it using the toLocalDate() method.

First, we’re using the default system ZoneId:

public LocalDate convertToLocalDateViaInstant(Date dateToConvert) {
    return dateToConvert.toInstant()
      .atZone(ZoneId.systemDefault())
      .toLocalDate();
}

Note that for dates before Oct 10, 1582, it’s necessary to set up Calendar as a Gregorian calendar and call method setGregorianChange():

GregorianCalendar calendar = new GregorianCalendar();
calendar.setGregorianChange(new Date(Long.MIN_VALUE));
Date dateToConvert = calendar.getTime();

2.2. Using ofEpochMilli() and toLocalDate()

A similar solution but with a different way of creating an Instant object — using the ofEpochMilli() method:

public LocalDate convertToLocalDateViaMilisecond(Date dateToConvert) {
    return Instant.ofEpochMilli(dateToConvert.getTime())
      .atZone(ZoneId.systemDefault())
      .toLocalDate();
}

This behaves the same as the previous implementation.

2.3. Using ofInstant()

In Java 9, there are new methods available that simplify conversion between java.util.Date and java.time.LocalDate.

Let’s look at an example:

public LocalDate convertToLocalDate(Date dateToConvert) {
    return LocalDate.ofInstant(
      dateToConvert.toInstant(), ZoneId.systemDefault());
}

LocalDate.ofInstant(Instant instant, ZoneId zone) provides a handy shortcut for the conversion.

3. Converting java.util.Date to java.time.LocalDateTime

Now let’s look at the ways to convert java.util.Date to LocalDateTime instance

3.1. Using toInstant() and toLocalDateTime()

To get a LocalDateTime instance, we can similarly use an intermediary ZonedDateTime and then use the toLocalDateTime() API.

Just like before, we can use two possible solutions to get an Instant object from java.util.Date:

public LocalDateTime convertToLocalDateTimeViaInstant(Date dateToConvert) {
    return dateToConvert.toInstant()
      .atZone(ZoneId.systemDefault())
      .toLocalDateTime();
}

3.2. Using ofEpochMilli() and toLocalDateTime()

Instead of toInstant(), we can also use ofEpochMilli():

public LocalDateTime convertToLocalDateTimeViaMilisecond(Date dateToConvert) {
    return Instant.ofEpochMilli(dateToConvert.getTime())
      .atZone(ZoneId.systemDefault())
      .toLocalDateTime();
}

This returns the LocalDateTime value from the Date instance.

3.3. Using ofInstant()

Since Java 9, we can use the method ofInstant() to easily convert java.util.Date to LocalDateTime:

public LocalDateTime convertToLocalDateTime(Date dateToConvert) {
    return LocalDateTime.ofInstant(
      dateToConvert.toInstant(), ZoneId.systemDefault());
}

4. Convert java.time to java.util.Date

Now that we have a good understanding of how to convert from the old data representation to the new one, let’s have a look at converting in the other direction.

4.1. Convert java.time.LocalDate to java.util.Date

We’ll discuss two possible ways of converting LocalDate to Date.

In the first, we use a new valueOf(LocalDate date) method provided in java.sql.Date object, which takes LocalDate as a parameter:

public Date convertToDateViaSqlDate(LocalDate dateToConvert) {
    return java.sql.Date.valueOf(dateToConvert);
}

As we can see, it is effortless and intuitive. It uses local time zone for conversion (all is done under the hood, so no need to worry).

In another Java 8 example, we use an Instant object that we pass to the from(Instant instant) method of java.util.Date object:

public Date convertToDateViaInstant(LocalDate dateToConvert) {
    return java.util.Date.from(dateToConvert.atStartOfDay()
      .atZone(ZoneId.systemDefault())
      .toInstant());
}

Notice we make use of an Instant object here and that we also need to care about time zones when doing this conversion.

Next, let’s use a very similar solution to convert a LocalDateTime to a Date object.

4.2. Convert java.time.LocalDateTime to java.util.Date

The easiest way of getting a java.util.Date from LocalDateTime is to use an extension to the java.sql.Timestamp — available with Java 8:

public Date convertToDateViaSqlTimestamp(LocalDateTime dateToConvert) {
    return java.sql.Timestamp.valueOf(dateToConvert);
}

But of course, an alternative solution is using an Instant object, which we obtain from ZonedDateTime:

Date convertToDateViaInstant(LocalDateTime dateToConvert) {
    return java.util.Date
      .from(dateToConvert.atZone(ZoneId.systemDefault())
      .toInstant());
}

5. Convert java.sql.Date to java.time.LocalDate

Now let’s also have a quick look at the old java.sql.Date class and how that can be converted to a LocalDate as well.

Starting with Java 8, we can find an additional toLocalDate() method on java.sql.Date, which also gives us an easy way of converting it to java.time.LocalDate.

In this case, we don’t need to worry about the time zone:

public LocalDate convertToLocalDateViaSqlDate(Date dateToConvert) {
    return new java.sql.Date(dateToConvert.getTime()).toLocalDate();
}

And starting with Java 8, we can also use java.sql.Timestamp to obtain a LocalDateTime:

public static LocalDateTime convertToLocalDateTimeViaSqlTimestamp(Date dateToConvert) {
    return new java.sql.Timestamp(
      dateToConvert.getTime()).toLocalDateTime();
}

6. Conclusion

In this article, we covered possible ways of converting old java.util.Date into new java.time.LocalDate and java.time.LocalDateTime, as well as the other way around. We utilized methods such as toInstant(), ofEpochMilli(), and ofInstant(). Additionally, we also explored ways to convert java.sql.Date and java.sql.Timestamp into LocalDate and LocalDateTime respectively.