Java 6 alternatives for LocalDate and DateTimeFormatter

Question

In a Java 8 project, I can parse the date this way:

LocalDate.parse(
    newDateString, 
    DateTimeFormatter.ofPattern(expectedDateFormat) 
)
.format(
    DateTimeFormatter.ofPattern(expectedDBDateFormat)
);

My problem is that I have a Java 6 project, and LocalDate and DateTimeFormatter are not defined for Java 6.

How can I parse the date in my Java 6 project?

Answer 1

There are 3 main choices:

• Use ThreeTen-Backport (Recommended)
  Advantage: Mostly same API as Java 8 Time API (JSR-310). Migration to Java 8 is very easy.
  Disadvantage: Package names are different, and it is not a full implementation of JSR-310.

  import org.threeten.bp.LocalDate;
  import org.threeten.bp.format.DateTimeFormatter;
  
  LocalDate.parse(input, DateTimeFormatter.ofPattern(inputFormat))
           .format(DateTimeFormatter.ofPattern(outputFormat));
  

• Use Joda-Time
  Advantage: Will work with any Java version.
  Disadvantage: Deprecated, in favor of Java 8 Time API (JSR-310).

  import org.joda.time.LocalDate;
  import org.joda.time.format.DateTimeFormat;
  
  LocalDate.parse(input, DateTimeFormat.forPattern(inputFormat))
           .toString(DateTimeFormat.forPattern(outputFormat));
  

• Use Java 6 Date and SimpleDateFormat
  Advantage: Will work for all future Java versions. No 3rd-party library.
  Disadvantage: The API is flawed, which is why Java 8 Time API (JSR-310) was created.

  import java.text.SimpleDateFormat;
  
  new SimpleDateFormat(outputFormat).format(
      new SimpleDateFormat(inputFormat).parse(input));
  

For comparison, your Java 8 code is:

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;

LocalDate.parse(input, DateTimeFormatter.ofPattern(inputFormat))
         .format(DateTimeFormatter.ofPattern(outputFormat));

Answer 2

The java.time-API has a backport operating for Java 6 or 7. So I think this is the simplest approach with as few changes as possible.

Other answers have also advocated Joda-Time, but the main disadvantage is a change of format pattern syntax so more than just changing import statements or the replacement of constructors versus factory methods is necessary.

Finally (for completeness), there is also my lib Time4J (v3.x for Java 6) which contains an alternative parse/format-engine based on the class ChronoFormatter (and the equivalent PlainDate instead of LocalDate).

Answer 3

I would like to use Joda time, you can just make some changes in your code, your code should like like this :

LocalDate.parse(
     newDateString, DateTimeFormat.forPattern(expectedDateFormat)
).toString(DateTimeFormat.forPattern(expectedDBDateFormat));

---

The imports

The imports should be :

import org.joda.time.LocalDate;
import org.joda.time.format.DateTimeFormat;

Instead of :

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;

---

Method names

If you note there are a small changes :

In Java 8 Time                            In Joda Time 
ofPattern(String pattern)           =>    forPattern(String pattern)   
format(DateTimeFormatter format)    =>    toString(DateTimeFormat format)

Answer 4

In vanilla Java 6 you can use the Date type and SimpleDateFormat class to parse string/format string represented dates.

SimpleDateFormat parser = new SimpleDateFormat(expectedDateFormat);
Date date = parser.parse(input);
SimpleDateFormat formatter = new SimpleDateFormat(expectedDBDateFormat);
String formattedDate = formatter.format(date);

As mentioned in other answers, both classes have their issues hence they have been superseeded by the Date/Time API since Java 8. Prefer one of those options or bettery yet avoid storing string formatted dates in the database.