Convert Long to Date in Java

1. Overview

When working with dates in Java, we often see date/time values expressed as long values that denote the number of days, seconds, or milliseconds since the epoch, January 1, 1970, 00:00:00 GMT.

In this short tutorial, we’ll explore different ways of converting a long value to a date in Java. First, we’ll explain how to do this using core JDK classes. Then, we’ll showcase how to achieve the same objective using the third-party Joda-Time library.

2. Using the Java 8+ Date-Time API

Java 8 is often praised for the new Date-Time API feature it brought to the Java landscape. This API was introduced mainly to cover the drawbacks of the old date API. So, let’s take a close look at what this API provides to answer our central question.

2.1. Using the Instant Class

The easiest solution would be using the Instant class introduced in the new Java 8 date-time API. This class describes a single instantaneous point on the timeline.

So, let’s see it in practice:

@Test
void givenLongValue_whenUsingInstantClass_thenConvert() {
    Instant expectedDate = Instant.parse("2020-09-08T12:16:40Z");
    long seconds = 1599567400L;
    Instant date = Instant.ofEpochSecond(seconds);
    assertEquals(expectedDate, date);
}

As shown above, we used the ofEpochSecond() method to create an object of the Instant class. Please bear in mind that we can use the ofEpochMilli() method as well to create an Instant instance using milliseconds.

2.2. Using the LocalDate Class

LocalDate is another option to consider when converting a long value to a date. This class models a classic date, such as 2023-10-17, without the time detail.

Typically, we can use the LocalDate#ofEpochDay method to achieve our objective:

@Test
void givenLongValue_whenUsingLocalDateClass_thenConvert() {
    LocalDate expectedDate = LocalDate.of(2023, 10, 17);
    long epochDay = 19647L;
    LocalDate date = LocalDate.ofEpochDay(epochDay);
    assertEquals(expectedDate, date);
}

The ofEpochDay() method creates an instance of the LocalDate class from the given epoch day.

3. Using the Legacy Date API

Before Java 8, we would usually use the Date or Calendar classes from the java.util package to achieve our objective. So, let’s see how to use these two classes to convert a long value to a date.

3.1. Using the Date Class

The Date class denotes a specific instant in time with millisecond precision. As the name indicates, it comes with a host of methods that we can use to manipulate dates. It offers the easiest way to convert a long value to a date as it provides an overloaded constructor that accepts a parameter of long type.

So, let’s see it in action:

@Test
void givenLongValue_whenUsingDateClass_thenConvert() {
    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
    Date expectedDate = dateFormat.parse("2023-10-15 22:00:00");
    long milliseconds = 1689458400000L;
    Date date = new Date(milliseconds);
    assertEquals(expectedDate, date);
}

Please note that the Date class is outdated and belongs to the old API. So, it’s not the best way to go when working with dates.

3.2. Using the Calendar Class

Another solution would be to use the Calendar class from the old date API. This class provides the setTimeInMillis(long value) method that we can use to set the time to the given long value.

Now, let’s exemplify the use of this method using another test case:

@Test
void givenLongValue_whenUsingCalendarClass_thenConvert() {
    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
    Date expectedDate = dateFormat.parse("2023-07-15 22:00:00");
    long milliseconds = 1689458400000L;
    Calendar calendar = Calendar.getInstance();
    calendar.setTimeZone(TimeZone.getTimeZone("UTC"));
    calendar.setTimeInMillis(milliseconds);
    assertEquals(expectedDate, calendar.getTime());
}

Similarly, the specified long value denotes the number of milliseconds passed since the epoch.

4. Using Joda-Time

Lastly, we can use the Joda-Time library to tackle our challenge. First, let’s add its dependency to the pom.xml file:

<dependency>
    <groupId>joda-time</groupId>
    <artifactId>joda-time</artifactId>
    <version>2.12.5</version>
</dependency>

Similarly, Joda-Time provides its version of the LocalDate class. So, let’s see how we can use it to convert a long value to a LocalDate object:

@Test
void givenLongValue_whenUsingJodaTimeLocalDateClass_thenConvert() {
    org.joda.time.LocalDate expectedDate = new org.joda.time.LocalDate(2023, 7, 15);
    long milliseconds = 1689458400000L;
    org.joda.time.LocalDate date = new org.joda.time.LocalDate(milliseconds, DateTimeZone.UTC);
    assertEquals(expectedDate, date);
}

As illustrated, LocalDate offers a direct way to construct a date from a long value.

5. Conclusion

In this short article, we explained in detail how to convert a long value to a date in Java.

First, we’ve seen how to do the conversion using built-in JDK classes. Then, we illustrated how to accomplish the same goal using the Joda-Time library.

As always, the code used in this article can be found over on GitHub.