Compare two date strings in different time zones with SimpleDateFormat in Java

Question

I have two dates from different time zones:

String s1 = "2021-08-07T03:00:01-07:00";
String s2 = "2021-08-07T15:30:00+05:30";

I want to compare both dates. I am parsing dates like below:

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss-hh:mm");
Date d = null;
try {
    d = sdf.parse(s1);
} catch (ParseException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}
System.out.println(d);

How do I add time zone to the date with the zone offset provided in the string?

Answer 1

tl;dr

OffsetDateTime
.parse( "2021-08-07T03:00:01-07:00" )
.isBefore(
    OffsetDateTime.parse( "2021-08-07T15:30:00+05:30" )
)

See this code run live at IdeOne.com.

false

Details

As commented, your formatting pattern fails to match your data. You are not using correct codes for the offset-from-UTC at the end. That is not a time-of-day with the plus and minus signs.

Never use those terrible obsolete date-time classes. They were years ago supplanted by the modern java.time classes.

Your ISO 8601 standard inputs can be parsed by default using the OffsetDateTime classes. No need to define a formatting pattern.

String s1="2021-08-07T03:00:01-07:00";
String s2="2021-08-07T15:30:00+05:30";
OffsetDateTime odt1 = OffsetDateTime.parse( s1 ) ;
OffsetDateTime odt2 = OffsetDateTime.parse( s2 ) ;
boolean odt1IsEarlier = odt1.isBefore( odt2 ) ;

See this code run live at IdeOne.com.

You may choose to adjust both objects to UTC, having an offset of zero hours-minutes-seconds. Merely extract an Instant.

Instant i1 = odt1.toInstant() ;
Instant i2 = odt2.toInstant() ;

Answer 2

As others have pointed out, avoid using legacy date-time classes (Date & SimpleDateFormat) that were supplanted by the java.time classes.

If you still wish to use Date & SimpleDateFormat, read on.

Try -

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public static void main(String[] args) {
    String inputDateString1 = "2021-08-07T03:00:01-07:00";
    String inputDateString2 = "2021-08-07T15:30:00+05:30";
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssXXX");
    Date d1 = null, d2 = null;
    try {
        d1 = sdf.parse(inputDateString1);
        d2 = sdf.parse(inputDateString2);
        System.out.println("Date 1 = " + d1);
        System.out.println("Date 2 = " + d2);
        System.out.println("Date 1 - Date 2 in milliseconds = " + (d1.getTime() - d2.getTime()));
    } catch (ParseException e) {
        e.printStackTrace();
    }
}

The output of the above code snippet is :-

Date 1 = Sat Aug 07 15:30:01 IST 2021
Date 2 = Sat Aug 07 15:30:00 IST 2021
Date 1 - Date 2 in milliseconds = 1000

Answer 3

The answer by Basil Bourque is correct and the recommended solution. You can use this answer as a supplement to his answer.

java.time

The java.util Date-Time API and their formatting API, SimpleDateFormat are outdated and error-prone. It is recommended to stop using them completely and switch to the modern Date-Time API^*.

Solution using java.time, the modern Date-Time API:

The modern Date-Time API is based on ISO 8601 and does not require using a DateTimeFormatter object explicitly as long as the Date-Time string conforms to the ISO 8601 standards. Both of your Date-Time strings conform to the ISO 8601 format for Date-Time with timezone offset and therefore it makes perfect sense to parse them directly using OffsetDateTime. However, Java SE 12 onwards, you can parse them directly to even Instant.

Demo:

import java.time.Instant;

public class Main {
    public static void main(String[] args) {
        String s1 = "2021-08-07T03:00:01-07:00";
        String s2 = "2021-08-07T15:30:00+05:30";

        Instant instant1 = Instant.parse(s1);
        Instant instant2 = Instant.parse(s2);

        System.out.println(s1 + " represents " + instant1);
        System.out.println(s1 + " represents " + instant2);

        if (instant1.isBefore(instant2)) {
            System.out.println(s1 + " is before " + s2);
        } else if (instant1.isAfter(instant2)) {
            System.out.println(s1 + " is after " + s2);
        } else {
            System.out.println("The strings represent the same instants.");
        }
    }
}

Output:

2021-08-07T03:00:01-07:00 represents 2021-08-07T10:00:01Z
2021-08-07T03:00:01-07:00 represents 2021-08-07T10:00:00Z
2021-08-07T03:00:01-07:00 is after 2021-08-07T15:30:00+05:30

ONLINE DEMO

An Instant represents an instantaneous point on the timeline, normally represented in UTC time. The Z in the output is the timezone designator for a zero-timezone offset. It stands for Zulu and specifies the Etc/UTC timezone (which has the timezone offset of +00:00 hours).

Learn more about the modern Date-Time API from Trail: Date Time.

---

^{* For any reason, if you have to stick to Java 6 or Java 7, you can use ThreeTen-Backport which backports most of the java.time functionality to Java 6 & 7. If you are working for an Android project and your Android API level is still not compliant with Java-8, check Java 8+ APIs available through desugaring and How to use ThreeTenABP in Android Project.}