DateTimeFormatter and SimpleDateFormat produce different results using same input string

Question

We currently in the process of replacing SimpleDateFormat with DateTimeFormatter. During this I came across a weird behavior. There is a difference in milliseconds which I can't explain to myself. Here is the code:

val timeString = "2021-09-17T13:37:00.09Z"
val newFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSSXXX").withZone(ZoneId.of("UTC"))
val oldFormatter = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSXXX", Locale.US)

val zonedDateTime = newFormatter.parse(timeString)
val newFormatterDate = Date.from(zonedDateTime.toInstant())
val oldFormatterDate = oldFormatter.parse(timeString)

Assert.assertEquals(newFormatterDate, oldFormatterDate) // false
// newFormatterDate.time is 1631885820090 and 
// oldFormatterDate.time is 1631885820009

I found a lot of posts here stating that we shouldn't use SimpleDateFormat anymore.

But can someone explain to me how this could happen? Do we have a bug in our code or misunderstood something?

Edit: The solution provided by @Ole V.V.'s link (How to parse date-time with two or three milliseconds digits in java?) may solve the bug I encounter but it does not answer the question/explain why these two formatters produce different results.

Note your data has two digits for fractional seconds and the patterns have three. What does `09` exactly mean when interpreted as three digits of fractional seconds? Also have a look at https://stackoverflow.com/questions/48291776/how-to-parse-date-time-with-two-or-three-milliseconds-digits-in-java — laalto, Oct 04 '21 at 14:38
@Iaalto Thanks. Solved. If you want to answer instead of comment I will mark it as the correct one — Aaron, Oct 04 '21 at 15:00
Does this answer your question? [How to parse date-time with two or three milliseconds digits in java?](https://stackoverflow.com/questions/48291776/how-to-parse-date-time-with-two-or-three-milliseconds-digits-in-java) — Ole V.V., Oct 05 '21 at 11:38
So in short your old code had a bug, and the new code hasn’t got that bug. — Ole V.V., Oct 05 '21 at 12:08
I find it interesting that your `DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSSXXX").withZone(ZoneId.of("UTC"))` can parse your time string of `2021-09-17T13:37:00.09Z`. It’s probably a bug. `SSS` ought to insist on three decimals, but also accepts 2 decimals. If I provide 1 or 4 decimals, I get an exception (tested on Java 11). — Ole V.V., Oct 05 '21 at 23:32
Another related question: [SimpleDateFormat showing incorrect milliseconds with "S" format, but not with "SSS"](https://stackoverflow.com/questions/67535630/simpledateformat-showing-incorrect-milliseconds-with-s-format-but-not-with-s) — Ole V.V., Oct 05 '21 at 23:37

score 3 · Accepted Answer · answered Oct 05 '21 at 11:21

The modern, DateTimeFormatter considers the digits after seconds as the fraction of a second whereas the legacy, SimpleDateFormat considers the digits after the seconds as the number of milliseconds.

Let's see how DateTimeFormatter processes it:

0.09 seconds = 0.09 * 1000 ms = 90 ms

On the other hand, SimpleDateFormat processes it as 09 milliseconds = 9 milliseconds.

By the way, while using the modern Date-Time API, you do not need to use a DateTimeFormatter explicitly to parse your Date-Time string because it is already in ISO 8601 format. 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.

Demo:

import java.time.Instant;

public class Main {
    public static void main(String[] args) {
        System.out.println(Instant.parse("2021-09-17T13:37:00.09Z").toEpochMilli());
    }
}

Output:

1631885820090

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

^{* 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. Note that Android 8.0 Oreo already provides support for java.time.}

score 1 · Answer 2 · answered Oct 05 '21 at 08:14

Your input data has two digits for fractional seconds. Your input patterns have three. The implementations interpret differently what 09 fractional seconds mean when three digits are expected.

If possible, fix either your input data or your input pattern to agree on the number of fractional digits. If you need to accept both two or three digits of fractional seconds, have a look at How to parse date-time with two or three milliseconds digits in java?

DateTimeFormatter and SimpleDateFormat produce different results using same input string

2 Answers2