Java 8 timezone conversion

Question

I know there are similar questions like this, but I wasn't quite able to find the example similar to mine. I learned about LocalDateTime and ZonedDateTime but I don't know how to tell my ZonedDateTime what's assumed timezone of parsed date.

I'm migrating from Java 7 to Java 8. In my code, I have a method like this:

public String changeTZ(String tzFrom, String tzTo, String dateToChange) {
    ZoneId zoneFrom = ZoneId.of(tzFrom);
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern(dateFormat.toPattern());
    LocalDateTime localtDateAndTime = LocalDateTime.parse(dateToChange, formatter);
    ZonedDateTime dateAndTimeINeed = ZonedDateTime.of(localtDateAndTime, zoneFrom );

    ZonedDateTime rezDate = dateAndTimeINeed.withZoneSameInstant(ZoneId.of(tzTo));

    return formatter.format(rezDate);
}

Example usage is:

String rez = changeTZ("CEST", "UTC", "2017-08-10 14:23:58");

As you can see it receives datetime in form of string, timezone date is in tzFrom variable and TZ I need (toTo variable).

Code which does that in Java 7 is absurd and complex so I won't enlist it here. Can you please tell me how to achieve the same in Java 8 without changing method interface (arguments and return type)? What about DST? Is it handled automatically in Java 8?

Note that method also supports timezones in form of "CEST", "CET", "UTC" as well as standard ones like "Europe/London".

Answer 1

This solution uses the IANA timezones names mentioned by Hugo in the comments to get the ZoneId (more details here). Will throw an exception if you use it with CEST.

public static String changeTZ(String tzFrom, String tzTo, String dateToChange){
    DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss").withZone(ZoneId.of(tzFrom));
    ZonedDateTime zdt = ZonedDateTime.parse(dateToChange, dtf);
    DateTimeFormatter dtf2 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss").withZone(ZoneId.of(tzTo));  
    return zdt.format(dtf2);
}

Use like:

String rez = changeTZ("US/Alaska", "Europe/Berlin", "2017-08-10 14:23:58");

Answer 2

Java 8 uses IANA timezones names (always in the format Region/City, like America/Sao_Paulo or Europe/Berlin). Avoid using the short abbreviations (like CEST or PST) because they are ambiguous and not standard.

Actually, those names don't work with ZoneId mainly because of this ambiguity (CST, for example, can be "Central Standard Time", "Cuba Standard Time" or "China Standard Time"). Actually, some of them might work due to retro-compatibility reasons, but it's not guaranteed to work with all of them.

I'm assuming that CEST is the Central European Summer Time. There are lots of different countries (and timezones) that are currently in CEST, so the API can't decide which timezone to choose if you just pass "CEST" to it.

That's because a timezone contains all the different offsets a region had during its history. There may be lots of countries using CEST today, but their history differs in the past (some might had DST in different years, or used a different offset and then changed, etc), and that's why they have one timezone for each.

To use such short names (like CEST), though, you can define some defaults for each one (which will be an arbitrary choice) and put these choices in a map:

// map of custom zone names
Map<String, String> map = new HashMap<>();
// setting my arbitrary choices for each name
map.put("CEST", "Europe/Berlin"); // Berlin during DST period
map.put("CET", "Europe/Berlin"); // Berlin during non-DST period
// ... and so on

Then you can use this map to create the ZoneId:

// use the custom map to create the ZoneId
ZoneId zoneFrom = ZoneId.of(tzFrom, map);
...
// use the custom map to create the ZoneId
ZonedDateTime rezDate = dateAndTimeINeed.withZoneSameInstant(ZoneId.of(tzTo, map));

I've chosen Europe/Berlin, but of course you can change it to whatever timezone you need. You can get a list of available timezones (and choose the one that fits best your system) by calling ZoneId.getAvailableZoneIds().

---

Using the map above:

System.out.println(changeTZ("CEST", "UTC", "2017-08-10 14:23:58"));

This code outputs:

2017-08-10 12:23:58

Note that 14:23 in CEST (which I chose to be Europe/Berlin) is 12:23 in UTC, which is correct because in August Berlin is in DST (offset is +02:00).

ZoneId and ZonedDateTime classes handle DST effects automatically. You can check this by choosing a date in January (when DST is not in effect in Berlin):

// January is not DST, so use CET
System.out.println(changeTZ("CET", "UTC", "2017-01-10 14:23:58"));

The output is:

2017-01-10 13:23:58

In January Berlin is not in DST, so the offset is +01:00, then 14:23 in Berlin becomes 13:23 in UTC.

---

Of course the ideal is to always use the full names (like Europe/Berlin), but the custom map is an alternative if you don't have control over the inputs.

Java 8 also has a built-in predefined map, but as any other predefined stuff, the choices are arbitrary and not necessarily the ones you need.

Answer 3

Here is a class that does the job.

public class TimeZoneConverter {

    private static String datePattern = "yyyy-MM-dd HH:mm:ss";

    public static void main(String[] args) throws ParseException {
        String sourceDate = "2017-02-27 16:00:00";
        String resultDate = convertTimeZone("EET", "UTC", sourceDate);

        System.out.println("EET: "+ sourceDate);
        System.out.println("UTC: "+ resultDate);
    }

    public static String convertTimeZone(String timeZoneFrom, String timeZoneTo, String date) throws ParseException {
        long timestamp = stringToTimestamp(date, timeZoneFrom);
        String result = timestampToString(timestamp, timeZoneTo);
        return result;
    }

    public static long stringToTimestamp(String time, String timeZone) throws ParseException {
        DateFormat format = getDateFormat(timeZone);
        return format.parse(time).getTime();
    }

    public static String timestampToString(long timestamp, String timeZone) {
        DateFormat format = getDateFormat(timeZone);
        return format.format(new Date(timestamp));
    }

    private static DateFormat getDateFormat(String timeZone) {
        DateFormat format = new SimpleDateFormat(datePattern);
        format.setTimeZone(TimeZone.getTimeZone(timeZone));
        return format;
    }

}