How to set time zone of a java.util.Date?


Translate

I have parsed a java.util.Date from a String but it is setting the local time zone as the time zone of the date object.

The time zone is not specified in the String from which Date is parsed. I want to set a specific time zone of the date object.

How can I do that?


All Answers
  • Translate

    Use DateFormat. For example,

    SimpleDateFormat isoFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
    isoFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
    Date date = isoFormat.parse("2010-05-23T09:01:02");
    

  • Translate

    Be aware that java.util.Date objects do not contain any timezone information by themselves - you cannot set the timezone on a Date object. The only thing that a Date object contains is a number of milliseconds since the "epoch" - 1 January 1970, 00:00:00 UTC.

    As ZZ Coder shows, you set the timezone on the DateFormat object, to tell it in which timezone you want to display the date and time.


  • Translate

    tl;dr

    …parsed … from a String … time zone is not specified … I want to set a specific time zone

    LocalDateTime.parse( "2018-01-23T01:23:45.123456789" )  // Parse string, lacking an offset-from-UTC and lacking a time zone, as a `LocalDateTime`.
        .atZone( ZoneId.of( "Africa/Tunis" ) )              // Assign the time zone for which you are certain this date-time was intended. Instantiates a `ZonedDateTime` object.
    

    No Time Zone in j.u.Date

    As the other correct answers stated, a java.util.Date has no time zone. It represents UTC/GMT (no time zone offset). Very confusing because its toString method applies the JVM's default time zone when generating a String representation.

    Avoid j.u.Date

    For this and many other reasons, you should avoid using the built-in java.util.Date & .Calendar & java.text.SimpleDateFormat. They are notoriously troublesome.

    Instead use the java.time package bundled with Java 8.

    java.time

    The java.time classes can represent a moment on the timeline in three ways:

    • UTC (Instant)
    • With an offset (OffsetDateTime with ZoneOffset)
    • With a time zone (ZonedDateTime with ZoneId)

    Instant

    In java.time, the basic building block is Instant, a moment on the time line in UTC. Use Instant objects for much of your business logic.

    Instant instant = Instant.now();
    

    OffsetDateTime

    Apply an offset-from-UTC to adjust into some locality’s wall-clock time.

    Apply a ZoneOffset to get an OffsetDateTime.

    ZoneOffset zoneOffset = ZoneOffset.of( "-04:00" );
    OffsetDateTime odt = OffsetDateTime.ofInstant( instant , zoneOffset );
    

    ZonedDateTime

    Better is to apply a time zone, an offset plus the rules for handling anomalies such as Daylight Saving Time (DST).

    Apply a ZoneId to an Instant to get a ZonedDateTime. Always specify a proper time zone name. Never use 3-4 abbreviations such as EST or IST that are neither unique nor standardized.

    ZoneId zoneId = ZoneId.of( "America/Montreal" );
    ZonedDateTime zdt = ZonedDateTime.ofInstant( instant , zoneId );
    

    LocalDateTime

    If the input string lacked any indicator of offset or zone, parse as a LocalDateTime.

    If you are certain of the intended time zone, assign a ZoneId to produce a ZonedDateTime. See code example above in tl;dr section at top.

    Formatted Strings

    Call the toString method on any of these three classes to generate a String representing the date-time value in standard ISO 8601 format. The ZonedDateTime class extends standard format by appending the name of the time zone in brackets.

    String outputInstant = instant.toString(); // Ex: 2011-12-03T10:15:30Z
    String outputOdt = odt.toString(); // Ex: 2007-12-03T10:15:30+01:00
    String outputZdt = zdt.toString(); // Ex: 2007-12-03T10:15:30+01:00[Europe/Paris]
    

    For other formats use the DateTimeFormatter class. Generally best to let that class generate localized formats using the user’s expected human language and cultural norms. Or you can specify a particular format.


    About java.time

    The java.time framework is built into Java 8 and later. These classes supplant the troublesome old legacy date-time classes such as java.util.Date, Calendar, & SimpleDateFormat.

    The Joda-Time project, now in maintenance mode, advises migration to the java.time classes.

    To learn more, see the Oracle Tutorial. And search Stack Overflow for many examples and explanations. Specification is JSR 310.

    You may exchange java.time objects directly with your database. Use a JDBC driver compliant with JDBC 4.2 or later. No need for strings, no need for java.sql.* classes.

    Where to obtain the java.time classes?

    The ThreeTen-Extra project extends java.time with additional classes. This project is a proving ground for possible future additions to java.time. You may find some useful classes here such as Interval, YearWeek, YearQuarter, and more.


    Joda-Time

    While Joda-Time is still actively maintained, its makers have told us to migrate to java.time as soon as is convenient. I leave this section intact as a reference, but I suggest using the java.time section above instead.

    In Joda-Time, a date-time object (DateTime) truly does know its assigned time zone. That means an offset from UTC and the rules and history of that time zone’s Daylight Saving Time (DST) and other such anomalies.

    String input = "2014-01-02T03:04:05";
    DateTimeZone timeZone = DateTimeZone.forID( "Asia/Kolkata" );
    DateTime dateTimeIndia = new DateTime( input, timeZone );
    DateTime dateTimeUtcGmt = dateTimeIndia.withZone( DateTimeZone.UTC );
    

    Call the toString method to generate a String in ISO 8601 format.

    String output = dateTimeIndia.toString();
    

    Joda-Time also offers rich capabilities for generating all kinds of other String formats.

    If required, you can convert from Joda-Time DateTime to a java.util.Date.

    Java.util.Date date = dateTimeIndia.toDate();
    

    Search StackOverflow for "joda date" to find many more examples, some quite detailed.


    Actually there is a time zone embedded in a java.util.Date, used for some internal functions (see comments on this Answer). But this internal time zone is not exposed as a property, and cannot be set. This internal time zone is not the one used by the toString method in generating a string representation of the date-time value; instead the JVM’s current default time zone is applied on-the-fly. So, as shorthand, we often say “j.u.Date has no time zone”. Confusing? Yes. Yet another reason to avoid these tired old classes.


  • Translate

    You could also set the timezone at the JVM level

    Date date1 = new Date();
    System.out.println(date1);
    
    TimeZone.setDefault(TimeZone.getTimeZone("UTC"));
    // or pass in a command line arg: -Duser.timezone="UTC"
    
    Date date2 = new Date();
    System.out.println(date2);
    

    output:

    Thu Sep 05 10:11:12 EDT 2013
    Thu Sep 05 14:11:12 UTC 2013
    

  • Translate

    If you must work with only standard JDK classes you can use this:

    /**
     * Converts the given <code>date</code> from the <code>fromTimeZone</code> to the
     * <code>toTimeZone</code>.  Since java.util.Date has does not really store time zome
     * information, this actually converts the date to the date that it would be in the
     * other time zone.
     * @param date
     * @param fromTimeZone
     * @param toTimeZone
     * @return
     */
    public static Date convertTimeZone(Date date, TimeZone fromTimeZone, TimeZone toTimeZone)
    {
        long fromTimeZoneOffset = getTimeZoneUTCAndDSTOffset(date, fromTimeZone);
        long toTimeZoneOffset = getTimeZoneUTCAndDSTOffset(date, toTimeZone);
    
        return new Date(date.getTime() + (toTimeZoneOffset - fromTimeZoneOffset));
    }
    
    /**
     * Calculates the offset of the <code>timeZone</code> from UTC, factoring in any
     * additional offset due to the time zone being in daylight savings time as of
     * the given <code>date</code>.
     * @param date
     * @param timeZone
     * @return
     */
    private static long getTimeZoneUTCAndDSTOffset(Date date, TimeZone timeZone)
    {
        long timeZoneDSTOffset = 0;
        if(timeZone.inDaylightTime(date))
        {
            timeZoneDSTOffset = timeZone.getDSTSavings();
        }
    
        return timeZone.getRawOffset() + timeZoneDSTOffset;
    }
    

    Credit goes to this post.


  • Translate

    java.util.Calendar is the usual way to handle time zones using just JDK classes. Apache Commons has some further alternatives/utilities that may be helpful. Edit Spong's note reminded me that I've heard really good things about Joda-Time (though I haven't used it myself).


  • Translate

    If anyone ever needs this, if you need to convert an XMLGregorianCalendar timezone to your current timezone from UTC, then all you need to do is set the timezone to 0, then call toGregorianCalendar() - it will stay the same timezone, but the Date knows how to convert it to yours, so you can get the data from there.

    XMLGregorianCalendar xmlStartTime = DatatypeFactory.newInstance()
        .newXMLGregorianCalendar(
            ((GregorianCalendar)GregorianCalendar.getInstance());
    xmlStartTime.setTimezone(0);
    GregorianCalendar startCalendar = xmlStartTime.toGregorianCalendar();
    Date startDate = startCalendar.getTime();
    XMLGregorianCalendar xmlStartTime = DatatypeFactory.newInstance()
        .newXMLGregorianCalendar(startCalendar);
    xmlStartTime.setHour(startDate.getHours());
    xmlStartTime.setDay(startDate.getDate());
    xmlStartTime.setMinute(startDate.getMinutes());
    xmlStartTime.setMonth(startDate.getMonth()+1);
    xmlStartTime.setTimezone(-startDate.getTimezoneOffset());
    xmlStartTime.setSecond(startDate.getSeconds());
    xmlStartTime.setYear(startDate.getYear() + 1900);
    System.out.println(xmlStartTime.toString());
    

    Result:

    2015-08-26T12:02:27.183Z
    2015-08-26T14:02:27.183+02:00
    

  • Translate

    Convert the Date to String and do it with SimpleDateFormat.

        SimpleDateFormat readFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
        readFormat.setTimeZone(TimeZone.getTimeZone("GMT" + timezoneOffset));
        String dateStr = readFormat.format(date);
        SimpleDateFormat writeFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
        Date date = writeFormat.parse(dateStr);
    

  • Translate

    This code was helpful in an app I'm working on:

        Instant date = null;
        Date sdf = null;
        String formatTemplate = "EEE MMM dd yyyy HH:mm:ss";
        try {
            SimpleDateFormat isoFormat = new SimpleDateFormat("EEE MMM dd yyyy HH:mm:ss");
            isoFormat.setTimeZone(TimeZone.getTimeZone(ZoneId.of("US/Pacific")));
            sdf = isoFormat.parse(timeAtWhichToMakeAvailable);
            date = sdf.toInstant();
    
        } catch (Exception e) {
            System.out.println("did not parse: " + timeAtWhichToMakeAvailable);
        }
    
        LOGGER.info("timeAtWhichToMakeAvailable: " + timeAtWhichToMakeAvailable);
        LOGGER.info("sdf: " + sdf);
        LOGGER.info("parsed to: " + date);