Understanding SimpleDateFormat Quirks in Java: A Guide to Parsing Dates Correctly

Explore the bizarre behavior of `SimpleDateFormat` in Java as we break down its parsing issues and provide comprehensive solutions for handling dates effectively.
---

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: SimpleDateFormat succeeds or throws depending on year number

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding SimpleDateFormat Quirks in Java: A Guide to Parsing Dates Correctly

Working with legacy code can often feel like navigating a labyrinth. Especially when you encounter peculiar inconsistencies, as illustrated by the issues related to Java's SimpleDateFormat. In recent years, developers have expressed frustration over the way this class handles date parsing with specific formats, particularly when it comes to years. In this guide, we will unravel a specific puzzle: why does SimpleDateFormat sometimes succeed in parsing dates, while at other times it fails? Let's delve into the details.

The Problem

Consider the following Java snippet that attempts to parse dates using the format string ddMMyy:

[[See Video to Reveal this Text or Code Snippet]]

When this code is executed, the output reveals unexpected behavior:

It prints a valid date for 09012023 but returns an absurd year (70403584).

Conversely, it throws an Unparseable date exception for 09012022.

This stark contrast raises the question: why does SimpleDateFormat behave this way, and how can we tackle it efficiently?

Exploring the Cause of the Issue

To understand the source of this problem, we need to break down what happens during parsing:

Last Segment Parsing: The yy portion of the date format captures the last two digits as the year. In the input 09012023000000000, the system extracts 2023000000000, leading to an overflow when converting from Long to Integer. This overflow yields an unreasonably high year 70403584 due to the manner Java handles insufficient overflow checks.

Different Output for Invalid Year: On the other hand, when processing 09012022000000000, the parsing runs into a Long value of 2022000000000. This results in an even larger negative overflow when cast to int, causing a ParseException as it leads to a year of -929596416, which is deemed invalid.

Internal Calendar Mechanics: The reasoning behind why some year values are accepted while others throw exceptions is tied to the limits enforced on the GregorianCalendar. Java allows certain out-of-range values but not others based on internal configurations, skewing the results significantly when working in non-lenient mode.

The Ultimate Conclusion

The findings reveal a critical aspect concerning SimpleDateFormat usage: non-lenient mode does not function reliably. Here's a summary of the key points:

Overflow scenarios are rarely checked, allowing bizarre year values that may or may not work.

Important: Relying on SimpleDateFormat for date management can lead to inconsistent behavior, especially with year values.

Moving Forward: A Secure Solution

Switch to DateTimeFormatter: Instead of using SimpleDateFormat, opt for DateTimeFormatter to handle date parsing reliably:

[[See Video to Reveal this Text or Code Snippet]]

Avoid timezone related complexities.

Eliminate confusion around epoch time formats and offsets.

Be Aware of Local Anomalies: When working with localized settings, be mindful of potential issues that could arise—especially regarding dates prior to a certain year, which can shift unexpectedly.