38

I am working in a project that reads files and processes data. There I got to work with dates for example:

  1. 2012-01-10 23:13:26
  2. January 13, 2012

I found the package Joda, kinda interesting package but don't know if it is the easiest around.

I was able to parse the first example to a DateTime object (Joda) reg-ex and String manipulation. (Ex: by replacing the space by '-' and passing it to constructor.

new DateTime("2012-01-10 23:13:26".replace(' ', '-'))

I guess it worked, but the problem is with the second format. How can I use such an input to extract a an object, preferably a Joda object. I sure can write a function to change the format to what Joda supports, but was wondering if there would be some other way (even some native Java library) to do it.

If there are any thing better than Joda out there, please let me know it as well.

Thank you.

Jonik
  • 80,077
  • 70
  • 264
  • 372
Ziyan Junaideen
  • 3,270
  • 7
  • 46
  • 71

6 Answers6

44

Using Joda-Time, take a look at DateTimeFormat; it allows parsing both kind of date strings that you mention (and almost any other arbitrary formats). If your needs are even more complex, try DateTimeFormatterBuilder.

To parse #1:

DateTimeFormatter f = DateTimeFormat.forPattern("yyyy-MM-dd HH:mm:ss");
DateTime dateTime = f.parseDateTime("2012-01-10 23:13:26");

Edit: actually LocalDateTime is a more appropriate type for a datetime without a time zone:

LocalDateTime dateTime = f.parseLocalDateTime("2012-01-10 23:13:26");

And for #2:

DateTimeFormatter f = DateTimeFormat.forPattern("MMMM dd, yyyy");
LocalDate localDate = f.parseLocalDate("January 13, 2012");

And yes, Joda-Time is definitely the way to go, as far as Java date & time handling is concerned. :)

As mostly everyone will agree, Joda is an exceptionally user-friendly library. For example, I had never done this kind of parsing with Joda before, but it took me just a few minutes to figure it out from the API and write it.

Update (2015)

If you're on Java 8, in most cases you should simply use java.time instead of Joda-Time. It contains pretty much all the good stuff—or their equivalents—from Joda. For those already familiar with Joda APIs, Stephen Colebourne's Joda-Time to java.time migration guide comes in handy.

Here are java.time versions of above examples.

To parse #1:

DateTimeFormatter f = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
LocalDateTime dateTime = LocalDateTime.from(f.parse("2012-01-10 23:13:26"));

You cannot parse this into ZonedDateTime or OffsetDateTime (which are counterparts of Joda's DateTime, used in my original answer), but that kinda makes sense because there's no time zone information in the parsed string.

To parse #2:

DateTimeFormatter f = DateTimeFormatter.ofPattern("MMMM dd, yyyy");
LocalDate localDate = LocalDate.from(f.parse("January 13, 2012"));

Here LocalDate is the most appropriate type to parse into (just like with Joda-Time).

Jonik
  • 80,077
  • 70
  • 264
  • 372
  • 3
    For users with non-english Locale but parsing US dates, `format = format.withLocale(Locale.US); ` otherwise the parsing of `January` will fail. //Joda-newbie – Kennet Jan 14 '12 at 09:46
  • **great**, thanks for the quick information. Could have taken me days or even weeks to figure things out. Thanks for the help every one! – Ziyan Junaideen Jan 14 '12 at 10:06
  • 2
    Correct answer, but lacking two things. [a] **the Locale** as explained in first comment. [b] **A time zone.** If omitted, the JVM's current default time zone will be assigned to the DateTime object. Better to explicitly state the time zone intended by the source of that data. Call `withZone` on the formatter object, passing the result of `DateTimeZone.UTC` or `DateTimeZone.forID( "Europe/Helsinki" )`. – Basil Bourque Sep 23 '14 at 18:51
  • The Java 8 version of the solution can be slightly improved by using the overloaded `#parse` method which takes a TemporalQuery object as the second parameter: `LocalDateTime dateTime = f.parse("2012-01-10 23:13:26", LocalDateTime::from)`. – alb-i986 Oct 18 '21 at 12:35
26

SimpleDateFormat will parse dates into Java Date objects:

http://docs.oracle.com/javase/1.4.2/docs/api/java/text/SimpleDateFormat.html

SimpleDateFormat format1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss"); // first example
SimpleDateFormat format2 = new SimpleDateFormat("MMMMM dd,yyyy"); // second example

Date d1 = format1.parse( dateStr1 );
Date d2 = format2.parse( dateStr2 );
chubbsondubs
  • 37,646
  • 24
  • 106
  • 138
  • I believe YYYY needs to be lowercase – the.Doc May 06 '16 at 14:27
  • If you're parsing 24-hour time you should use `HH` instead of `hh`. [Documentation](https://docs.oracle.com/javase/7/docs/api/java/text/SimpleDateFormat.html) – rmtheis May 09 '18 at 18:15
7

I would imagine Joda has something of a Formatter to do this for you. I found this with a quick google search: http://johannburkard.de/blog/programming/java/date-time-parsing-formatting-joda-time.html

DateTimeFormatter parser1 =
    DateTimeFormat.forPattern("dd/MMM/yyyy:HH:mm:ss Z");

DateTimeFormatter parser2 =
    DateTimeFormat.forPattern("yyyy-MM-dd HH:mm");

DateTime time = parser1.parseDateTime("<data>");

The syntax that is used to evaluate the patterns can be found in X-Zero's link.

nicholas.hauschild
  • 42,483
  • 9
  • 127
  • 120
5

JodaTime is largely considered the de-facto standard for date-time processing in Java - they're working to get it added to the next version of the Java library (well, effectively).

For getting JodaTime dates from strings, you're going to want to look into the DateTimeFormat class.

Clockwork-Muse
  • 12,806
  • 6
  • 31
  • 45
2

tl;dr

LocalDateTime ldt = LocalDateTime.parse( "2012-01-10 23:13:26".replace( " " , "T" ) );

…and…

LocalDate localDate = LocalDate.parse ( "January 13, 2012" , DateTimeFormatter.ofLocalizedDate ( FormatStyle.LONG ).withLocale ( Locale.US ) );

Details

The Answer by Jonik is basically correct but misses some important issues.

java.time

If there are any thing better than Joda out there, please let me know it as well.

Yes, there is something better, the java.time framework. The Joda-Time team advises migration to java.time as its successor.

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

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

Much of the java.time functionality is back-ported to Java 6 & 7 in ThreeTen-Backport and further adapted to Android in ThreeTenABP.

Date-time

Your first input is a date plus a time-of-day. It lacks any offset-from-UTC or time zone info, so we parse it as a LocalDateTime object. The “Local…” means any locality, no specific locality. So it is not an actual moment on the timeline but rather just a rough idea about a moment.

To parse the input string 2012-01-10 23:13:26 we can replace the SPACE in the middle with a T to conform with the canonical style for the ISO 8601 standard format of date-time values.

The java.time classes use ISO 8601 formats by default when parsing and generating textual representations of date-time values. So no need to define a parsing pattern.

String input = "2012-01-10 23:13:26".replace( " " , "T" );
LocalDateTime ldt = LocalDateTime.parse( input );

If you know the the intended time zone from the context of this value, apply it to define an actual moment on the timeline.

ZoneId zoneId = ZoneId.of( "America/Montreal" );
ZonedDateTime zdt = ldt.atZone( zoneId );

Dump to console.

System.out.println ( "input: " + input + " | zdt: " + zdt );

input: 2012-01-10T23:13:26 | zdt: 2012-01-10T23:13:26-05:00[America/Montreal]

Date-only

The second of you inputs is a date-only value without time-of-day and without time zone. For that we need the LocalDate class.

I recognize the format of that input as complying with the language (English) and cultural norms of the United States. So no need to specify explicitly a formatting pattern. We can simply ask for a formatter that knows that US format by specifying a Locale. We specify FormatStyle.LONG as appropriate for the length of this format.

String input = "January 13, 2012";
DateTimeFormatter formatter = DateTimeFormatter.ofLocalizedDate ( FormatStyle.LONG ).withLocale ( Locale.US );
LocalDate localDate = LocalDate.parse ( input , formatter );

Dump to console.

System.out.println ( "input: " + input + " | localDate: " + localDate );

input: January 13, 2012 | localDate: 2012-01-13

Community
  • 1
  • 1
Basil Bourque
  • 303,325
  • 100
  • 852
  • 1,154
2

Easiest would be setting up SimpleDateFormat properly as per the format you would expect and use its parse method to give you a Date object

rakche
  • 21
  • 1