Convert YYYY-MM-DDThh:mm:ssTZD format date string to local time

In this blog post, we will explore how to convert a date string in the format “YYYY-MM-DDThh:mm:ssTZD” to the local time zone using Java. This topic often arises in Spring Boot applications, where developers need to handle ISO 8601 datetime strings without using the JODA library. We will provide you with a simple and concise solution using the modern Java date and time API.

Understanding the Problem

When working with ISO 8601 datetime strings, such as “2019-11-13T00:11:08+05:00”, the challenge is to convert it to the local datetime without relying on outdated classes like SimpleDateFormat and Date. These legacy classes can be error-prone and are no longer recommended for handling date and time operations.

Solution Approach

To solve this problem, we will utilize the java.time package, which provides robust support for date and time manipulation. Specifically, we will use the OffsetDateTime and LocalDateTime classes along with the DateTimeFormatterBuilder to parse and format the date string accurately.

Here’s the code snippet that demonstrates the solution:

code










String receivedDateTime = "2019-11-13T00:11:08+05:00";

DateTimeFormatter formatter = new DateTimeFormatterBuilder()
        .append(DateTimeFormatter.ISO_LOCAL_DATE_TIME)
        .optionalStart().appendOffset("+HH:MM", "+00:00").optionalEnd()
        .optionalStart().appendOffset("+HHMM", "0000").optionalEnd()
        .toFormatter();

OffsetDateTime parsedDateTime = OffsetDateTime.parse(receivedDateTime, formatter);
LocalDateTime localDateTime = parsedDateTime.atZoneSameInstant(ZoneId.systemDefault()).toLocalDateTime();

System.out.println(localDateTime);

Explanation of the Solution

Let’s break down the solution step by step:

1. We start by defining the date string receivedDateTime, which represents the ISO 8601 datetime format.
2. Next, we create a DateTimeFormatter using the DateTimeFormatterBuilder. The builder allows us to specify optional patterns to handle different offset formats in the date string.
3. The formatter is constructed with ISO_LOCAL_DATE_TIME, which matches the basic ISO date and time format (e.g., “2019-11-13T00:11:08”).
4. We then specify two optional offset patterns using optionalStart() and optionalEnd(). These patterns accommodate different offset representations, such as “+HH:MM” (e.g., “+05:00”) and “+HHMM” (e.g., “+0500”).
5. After creating the formatter, we use OffsetDateTime.parse() to parse the date string using the formatter. This returns an OffsetDateTime object representing the original datetime with the specified offset.
6. Finally, we convert the OffsetDateTime to the local datetime by calling atZoneSameInstant() with ZoneId.systemDefault(). This ensures that the datetime is adjusted to the local time zone. We then extract the LocalDateTime using toLocalDateTime().
7. The resulting LocalDateTime can be further processed or displayed as needed. In the provided code, we print the local datetime using System.out.println().

Understanding the ISO 8601 Format

The ISO 8601 format is an international standard for representing date and time information. It provides a consistent and unambiguous way of expressing datetime values, including offsets to account for different time zones.

The format consists of the following components:

• YYYY: Four-digit year
• MM: Two-digit month
• DD: Two-digit day
• T: Separator indicating the start of the time component
• hh: Two-digit hour
• mm: Two-digit minute
• ss: Two-digit second
• TZD: Time zone designator in the form of +/-hh:mm or +/-hhmm

Using the DateTimeFormatterBuilder

To handle the different offset formats in the date string, we utilize the DateTimeFormatterBuilder class provided by the java.time package. This class allows us to construct a custom DateTimeFormatter with optional patterns.

In our solution, we use the DateTimeFormatterBuilder to create a formatter that can handle two possible offset representations: “+HH:MM” and “+HHMM”. By making these patterns optional, the formatter can handle date strings with or without offsets.

Parsing the Date String

Once we have our formatter, we use the OffsetDateTime.parse() method to parse the date string. This method takes the date string and the formatter as arguments and returns an OffsetDateTime object representing the original datetime with the specified offset.

The OffsetDateTime class is capable of handling datetime values with time zone offsets, making it suitable for our conversion process. It provides methods for manipulating and extracting the datetime components as needed.

Converting to Local DateTime

To obtain the local datetime from the parsed OffsetDateTime, we utilize the atZoneSameInstant() method. This method takes a ZoneId representing the desired time zone and returns a ZonedDateTime object adjusted to that time zone.

In our solution, we use ZoneId.systemDefault() to obtain the system’s default time zone. You can modify this to any specific time zone according to your requirements. By calling toLocalDateTime() on the resulting ZonedDateTime, we extract the LocalDateTime representing the datetime adjusted to the local time zone.

Conclusion

By following the steps outlined in this blog post, you can easily convert a date string in the format “YYYY-MM-DDThh:mm:ssTZD” to the local datetime using Java’s modern date and time API. The solution avoids using outdated classes like SimpleDateFormat and Date, providing a more reliable and efficient approach to handling datetime conversions.

Remember to embrace the power of the java.time package and leverage its various classes and methods for all your date and time operations.