How to Convert Between java.sql.Timestamp and ZonedDateTime in Java

1. Overview

Handling timеstamps in Java is a common task that allows us to manipulatе and display datе and timе information morе еffеctivеly еspеcially when we’re dealing with databasеs or global applications. Two fundamental classes for handling timestamps and timezones are java.sql.Timestamp and ZonedDateTime.

In this tutorial, we’ll look at various approaches to converting between java.sql.Timestamp and ZonedDateTime.

2. Converting java.sql.Timestamp to ZonedDateTime

First, we’ll look into multiple approaches to converting java.sql.Timestamp to ZonedDateTime.

2.1. Using the Instant Class

The easiest way to think of the Instant class is as a single moment in the UTC zone. If we think of time as a line, Instant represents a single point on the line.

Under the hood, the Instant class is just counting the number of seconds and nanoseconds relative to the standard Unix epoch time of January 1, 1970, at 00:00:00. This point in time is denoted by 0 seconds and 0 nanoseconds, and everything else is just an offset from it.

Storing the number of seconds and nanoseconds relative to this specific time point allows the class to store negative and positive offsets. In other words, the Instant class can represent times before and after the epoch time.

Let’s look at how we can work with the Instant class to convert a timestamp to ZonedDateTime:

ZonedDateTime convertToZonedDateTimeUsingInstant(Timestamp timestamp) {
    Instant instant = timestamp.toInstant();
    return instant.atZone(ZoneId.systemDefault());
}

In the above method, we convert the provided timestamp to an Instant by using the toInstant() method of the Timestamp class, which represents a moment on the timeline in UTC. Then, we use the atZone() method on the Instant object to associate it with a specific timezone. We use the system’s default timezone, obtained via ZoneId.systemDefault(). 

Let’s test this method by using the system’s default timezone (the global timezone):

@Test
void givenTimestamp_whenUsingInstant_thenConvertToZonedDateTime() {
    Timestamp timestamp = Timestamp.valueOf("2024-04-17 12:30:00");
    ZonedDateTime actualResult = TimestampAndZonedDateTimeConversion.convertToZonedDateTimeUsingInstant(timestamp);
    ZonedDateTime expectedResult = ZonedDateTime.of(2024, 4, 17, 12, 30, 0, 0, ZoneId.systemDefault());
    Assertions.assertEquals(expectedResult.toLocalDate(), actualResult.toLocalDate());
    Assertions.assertEquals(expectedResult.toLocalTime(), actualResult.toLocalTime());
}

2.2. Using the Calendar Class

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

ZonedDateTime convertToZonedDateTimeUsingCalendar(Timestamp timestamp) {
    Calendar calendar = Calendar.getInstance();
    calendar.setTimeInMillis(timestamp.getTime());
    return calendar.toInstant().atZone(ZoneId.systemDefault());
}

In the above method, we initialized the Calendar instance using the Calendar.getInstance() method. The time of the Calendar instance is set to the same as the Timestamp object. After that, we used the toInstant() method on the Calendar object to obtain an Instant. Then, we again used the atZone() method on the Instant object to associate it with a specific timezone. We used the system’s default timezone, obtained via ZoneId.systemDefault(). 

Let’s see the following test code:

@Test
void givenTimestamp_whenUsingCalendar_thenConvertToZonedDateTime() {
    Timestamp timestamp = Timestamp.valueOf("2024-04-17 12:30:00");
    ZonedDateTime actualResult = TimestampAndZonedDateTimeConversion.convertToZonedDateTimeUsingCalendar(timestamp);
    ZonedDateTime expectedResult = ZonedDateTime.of(2024, 4, 17, 12, 30, 0, 0, ZoneId.systemDefault());
    Assertions.assertEquals(expectedResult.toLocalDate(), actualResult.toLocalDate());
    Assertions.assertEquals(expectedResult.toLocalTime(), actualResult.toLocalTime());
}

2.3. Using LocalDateTime Class

The java.timе packagе was introduced in Java 8 and offers a modern date and time API. LоcalDatеTimе is one of the classes in this packagе, which can store and manipulate data and time of different timezones. Let’s take a look at this approach:

ZonedDateTime convertToZonedDateTimeUsingLocalDateTime(Timestamp timestamp) {
    LocalDateTime localDateTime = timestamp.toLocalDateTime();
    return localDateTime.atZone(ZoneId.systemDefault());
}

The toLocalDateTime() method of the Timestamp class converts the Timestamp to a LocalDateTime, which represents a date and time without timezone information.

Let’s test this approach:

@Test
void givenTimestamp_whenUsingLocalDateTime_thenConvertToZonedDateTime() {
    Timestamp timestamp = Timestamp.valueOf("2024-04-17 12:30:00");
    ZonedDateTime actualResult = TimestampAndZonedDateTimeConversion.convertToZonedDateTimeUsingLocalDateTime(timestamp);
    ZonedDateTime expectedResult = ZonedDateTime.of(2024, 4, 17, 12, 30, 0, 0, ZoneId.systemDefault());
    Assertions.assertEquals(expectedResult.toLocalDate(), actualResult.toLocalDate());
    Assertions.assertEquals(expectedResult.toLocalTime(), actualResult.toLocalTime());
}

2.4. Using Joda-Time Class

Joda-Time is a very popular Java library for manipulating dates and times. It offers a much more intuitive and flexible API than the standard DateTime class.

To include the functionality of the Joda-Time library, we need to add the following dependency from Maven Central:

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

Let’s see how we can use the Joda-Time class to achieve this conversion:

ZonedDateTime convertToZonedDateTimeUsingJodaTime(Timestamp timestamp) {
    DateTime dateTime = new DateTime(timestamp.getTime());
    return dateTime.toGregorianCalendar().toZonedDateTime();
}

In this approach, we first retrieve the number of milliseconds since the epoch (1970-01-01T00:00:00Z). Then, we create a new DateTime object from the obtained milliseconds value using the default timezone.

Next, we transform the DateTime object into a GregorianCalendar and subsequently convert the GregorianCalendar into a ZonedDateTime using the Joda-Time library’s method.

Now, let’s run our test:

@Test
void givenTimestamp_whenUsingJodaTime_thenConvertToZonedDateTime() {
    Timestamp timestamp = Timestamp.valueOf("2024-04-17 12:30:00");
    ZonedDateTime actualResult = TimestampAndZonedDateTimeConversion.convertToZonedDateTimeUsingJodaTime(timestamp);
    ZonedDateTime expectedResult = ZonedDateTime.of(2024, 4, 17, 12, 30, 0, 0, ZoneId.systemDefault());
    Assertions.assertEquals(expectedResult.toLocalDate(), actualResult.toLocalDate());
    Assertions.assertEquals(expectedResult.toLocalTime(), actualResult.toLocalTime());
}

3. Converting ZonedDateTime to java.sql.Timestamp

Now, we’ll look into multiple approaches to converting ZonedDateTime to java.sql.Timestamp:

3.1. Using the Instant Class

Let’s look at how we can use the Instant class to convert ZonedDateTime to java.sql.Timestamp:

Timestamp convertToTimeStampUsingInstant(ZonedDateTime zonedDateTime) {
    Instant instant = zonedDateTime.toInstant();
    return Timestamp.from(instant);
}

In the above method, we first convert the provided ZonedDateTime object into an Instant using the toInstant() method. Then, we used the from() method of the Timestamp class to create a Timestamp object by passing the obtained Instant as an argument.

Now, let’s test this approach:

@Test
void givenZonedDateTime_whenUsingInstant_thenConvertToTimestamp() {
    ZonedDateTime zonedDateTime = ZonedDateTime.of(2024, 4, 17, 12, 30, 0, 0, ZoneId.systemDefault());
    Timestamp actualResult = TimestampAndZonedDateTimeConversion.convertToTimeStampUsingInstant(zonedDateTime);
    Timestamp expectedResult = Timestamp.valueOf("2024-04-17 12:30:00");
    Assertions.assertEquals(expectedResult, actualResult);
}

3.2. Using LocalDateTime Class

Let’s use the LocalDateTime class to convert the ZonedDateTime to java.sql.Timestamp:

Timestamp convertToTimeStampUsingLocalDateTime(ZonedDateTime zonedDateTime) {
    LocalDateTime localDateTime = zonedDateTime.toLocalDateTime();
    return Timestamp.valueOf(localDateTime);
}

In the above method, we convert the provided ZonedDateTime object into a LocalDateTime object using the toLocalDateTime() method. LocalDateTime represents a date and time without a timezone. Then, we created and returned a Timestamp object using the valueOf() method of the Timestamp class by passing the LocalDateTime object as an argument.

Now, let’s run our test:

@Test
void givenZonedDateTime_whenUsingLocalDateTime_thenConvertToTimestamp() {
    ZonedDateTime zonedDateTime = ZonedDateTime.of(2024, 4, 17, 12, 30, 0, 0, ZoneId.systemDefault());
    Timestamp actualResult = TimestampAndZonedDateTimeConversion.convertToTimeStampUsingLocalDateTime(zonedDateTime);
    Timestamp expectedResult = Timestamp.valueOf("2024-04-17 12:30:00");
    Assertions.assertEquals(expectedResult, actualResult);
}

3.3. Using Joda-Time Class

Let’s see how we can use the Joda-Time class to achieve this conversion:

Timestamp convertToTimestampUsingJodaTime(ZonedDateTime zonedDateTime) {
    DateTime dateTime = new DateTime(zonedDateTime.toInstant().toEpochMilli());
    return new Timestamp(dateTime.getMillis());
}

In this approach, we first retrieve the number of milliseconds since the epoch (1970-01-01T00:00:00Z) by converting the ZonedDateTime object to an Instant. Then, we create a new DateTime object from the obtained milliseconds value using the default timezone.

Similarly, we create a Timestamp object representing the same point in time as the DateTime object. Let’s now test this approach:

@Test
void givenZonedDateTime_whenUsingJodaDateTime_thenConvertToTimestamp() {
    ZonedDateTime zonedDateTime = ZonedDateTime.of(2024, 4, 17, 12, 30, 0, 0, ZoneId.systemDefault());
    Timestamp actualResult = TimestampAndZonedDateTimeConversion.convertToTimestampUsingJodaTime(zonedDateTime);
    Timestamp expectedResult = Timestamp.valueOf("2024-04-17 12:30:00");
    Assertions.assertEquals(expectedResult, actualResult);
}

4. Conclusion

In this quick tutorial, we learned how to convert ZonedDateTime and java.sql.Timestamp classes in Java.

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