Konvertieren einer ISO 8601-kompatiblen Zeichenfolge in java.util.Date

Okay, diese Frage ist bereits beantwortet, aber ich lasse meine Antwort trotzdem. Es könnte jemand helfen.

Ich habe auf der Suche für ein - Lösung für Android - (API 7).

• Joda war in Frage, es ist riesig, und Sie leidet unter der langsamen Initialisierung. Es schien auch eine große overkill für diesen bestimmten Zweck.
• Antworten, die javax.xml funktionieren nicht auf Android-API 7.

Endete der Umsetzung dieser einfachen Klasse. Es umfasst nur die häufigste form der ISO-8601-strings, aber das sollte genug sein, in einigen Fällen (wenn du bist ganz sicher, dass die Eingabe in diese - format).

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

/**
 * Helper class for handling a most common subset of ISO 8601 strings
 * (in the following format: "2008-03-01T13:00:00+01:00"). It supports
 * parsing the "Z" timezone, but many other less-used features are
 * missing.
 */
public final class ISO8601 {
    /** Transform Calendar to ISO 8601 string. */
    public static String fromCalendar(final Calendar calendar) {
        Date date = calendar.getTime();
        String formatted = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ")
            .format(date);
        return formatted.substring(0, 22) + ":" + formatted.substring(22);
    }

    /** Get current date and time formatted as ISO 8601 string. */
    public static String now() {
        return fromCalendar(GregorianCalendar.getInstance());
    }

    /** Transform ISO 8601 string to Calendar. */
    public static Calendar toCalendar(final String iso8601string)
            throws ParseException {
        Calendar calendar = GregorianCalendar.getInstance();
        String s = iso8601string.replace("Z", "+00:00");
        try {
            s = s.substring(0, 22) + s.substring(23);  //to get rid of the ":"
        } catch (IndexOutOfBoundsException e) {
            throw new ParseException("Invalid length", 0);
        }
        Date date = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ").parse(s);
        calendar.setTime(date);
        return calendar;
    }
}

Leistung Hinweis: instanziieren ich neue " = SimpleDateFormat jedes mal, als Mittel zum vermeiden ein bug in Android 2.1. Wenn man so erstaunt wie ich war, sehen dieses Rätsel. Für andere Java-engines, kann der cache-Instanz in einem privaten, statischen Feld (mit ThreadLocal -, thread-safe).

InformationsquelleAutor der Antwort wrygiel

java.Zeit

Den java.Zeit-API (built in Java 8 und höher), macht das ein wenig einfacher.

Wenn Sie wissen, der Eingang ist in UTCwie die Z (Zulu) am Ende, die Instant Klasse analysieren kann.

java.util.Date date = Date.from( Instant.parse( "2014-12-12T10:39:40Z" ));

Wenn Ihr input kann ein anderes offset von UTC Werte eher als UTC gekennzeichnet durch die Z (Zulu) am Ende, verwenden Sie die OffsetDateTime Klasse zu analysieren.

OffsetDateTime odt = OffsetDateTime.parse( "2010-01-01T12:00:00+01:00" );

Extrahieren Sie dann eine Instantund die Umstellung auf eine java.util.Date durch den Aufruf .

Instant instant = odt.toInstant();  //Instant is always in UTC.
java.util.Date date = java.util.Date.from( instant );

InformationsquelleAutor der Antwort Adam

tl;dr

OffsetDateTime.parse ( "2010-01-01T12:00:00+01:00" )

Mit java.Zeit

Den neuen java.Zeit - Paket in Java 8 und später wurde inspiriert von Joda-Time.

Den OffsetDateTime Klasse repräsentiert einen moment auf der Zeitachse mit einem offset von UTC aber nicht die Zeit-zone.

OffsetDateTime odt = OffsetDateTime.parse ( "2010-01-01T12:00:00+01:00" );

Aufrufen toString erzeugt einen string im ISO 8601-standard-format:

2010-01-01T12:00+01:00

Zu sehen, den gleichen Wert durch die Linse von UTC, extrahieren Sie eine Instant oder passen Sie den offset von +01:00 zu 00:00.

Instant instant = odt.toInstant();  

...oder...

OffsetDateTime odtUtc = odt.withOffsetSameInstant( ZoneOffset.UTC );

Passen in einen Zeit-zone, falls gewünscht. Ein Zeitzone ist eine Geschichte der offset von UTC Werte für eine region, mit einem Satz von Regeln für den Umgang mit Anomalien, wie Sommerzeit (DST). So wenden Sie ein Zeit-zone statt einer bloßen offset, Wann immer möglich.

ZonedDateTime zonedDateTimeMontréal = odt.atZoneSameInstant( ZoneId.of( "America/Montreal" ) );

Über java.Zeit

Den java.Zeit framework ist in Java 8 und höher. Diese Klassen verdrängen die lästige alte Vermächtnis Datum-Zeit-Klassen wie java.util.DateCalendar& " = SimpleDateFormat.

Den Joda-Time Projekt, jetzt in Wartungsmodusrät der migration auf die java.Zeit Klassen.

Um mehr zu erfahren, siehe die Oracle Tutorial. Und die Suche Stack Overflow für viele Beispiele und Erklärungen. Spezifikation JSR 310.

Können Sie exchange java.Zeit Objekte direkt mit Ihrer Datenbank. Verwenden Sie eine JDBC-Treiber kompatibel mit JDBC 4.2 oder später. Keine Notwendigkeit für Streicher, keine Notwendigkeit für java.sql.* Klassen.

Wo erhalten Sie die java.Zeit-Klassen?

• Java SE 8Java SE 9Java SE 10und später
  • Eingebaut.
  • Teil der standard-Java-API mit einer gebündelten Umsetzung.
  • Java 9 fügt einige kleine features und behebt.
• Java SE 6 und Java SE 7
  • Viel von java.Funktionalität ist zurück-portiert auf Java 6 & 7 in ThreeTen-Backport.
• Android
  • Späteren Versionen von Android bundle Implementierungen von java.Zeit-Klassen.
  • Für frühere Android (<26), die ThreeTenABP Projekt passt ThreeTen-Backport (oben erwähnt). Sehen die How to use ThreeTenABP....

Den ThreeTen-Extra Projekt erweitert die java.mal mit zusätzlicher Klassen. Dieses Projekt ist ein Testgelände für mögliche künftige Erweiterungen zu java.Zeit. Sie finden möglicherweise einige nützliche Klassen, die hier wie IntervalYearWeekYearQuarterund mehr.

InformationsquelleAutor der Antwort Basil Bourque

Den DatatypeConverter Lösung funktioniert nicht in allen VMs. Folgendes funktioniert bei mir:

javax.xml.datatype.DatatypeFactory.newInstance().newXMLGregorianCalendar("2011-01-01Z").toGregorianCalendar().getTime()

Habe ich herausgefunden, dass joda nicht funktioniert out of the box (speziell für das Beispiel gab ich oben mit der Zeitzone, die auf ein Datum, das gültig sein sollte)

InformationsquelleAutor der Antwort James Scriven

Andere sehr einfache Art und Weise zu analysieren, nach ISO8601 Zeitstempel ist die Nutzung org.apache.commons.lang.time.DateUtils:

import static org.junit.Assert.assertEquals;

import java.text.ParseException;
import java.util.Date;
import org.apache.commons.lang.time.DateUtils;
import org.junit.Test;

public class ISO8601TimestampFormatTest {
  @Test
  public void parse() throws ParseException {
    Date date = DateUtils.parseDate("2010-01-01T12:00:00+01:00", new String[]{ "yyyy-MM-dd'T'HH:mm:ssZZ" });
    assertEquals("Fri Jan 01 12:00:00 CET 2010", date.toString());
  }
}

InformationsquelleAutor der Antwort tmandry

Stand ich vor der gleichen problem und löste es, indem Sie den folgenden code .

 public static Calendar getCalendarFromISO(String datestring) {
    Calendar calendar = Calendar.getInstance(TimeZone.getDefault(), Locale.getDefault()) ;
    SimpleDateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", Locale.getDefault());
    try {
        Date date = dateformat.parse(datestring);
        date.setHours(date.getHours() - 1);
        calendar.setTime(date);

        String test = dateformat.format(calendar.getTime());
        Log.e("TEST_TIME", test);

    } catch (ParseException e) {
        e.printStackTrace();
    }

    return calendar;
}

Früher war ich mit
SimpleDateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ", Locale.getDefault());

Aber später fand ich, dass die wichtigste Ursache der Ausnahme war die yyyy-MM-dd'T'HH:mm:ss.SSSZ ,

So habe ich

SimpleDateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", Locale.getDefault());

Es funktionierte gut für mich .

InformationsquelleAutor der Antwort Abhay Kumar

Apache Jackrabbit verwendet den ISO-8601-format zum beibehalten von Daten, und es ist eine Hilfsklasse zum Parsen Ihnen:

org.apache.jackrabbit.util.Nach ISO8601

Kommt mit jackrabbit-jcr-commons.

InformationsquelleAutor der Antwort Alexander Klimetschek

Den workaround für Java 7+ ist mit " = SimpleDateFormat:

DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSX", Locale.US);

Dieser code Parsen kann nach ISO8601-format wie:

• 2017-05-17T06:01:43.785Z
• 2017-05-13T02:58:21.391+01:00

Aber auf Java6, SimpleDateFormat nicht verstehen X Charakter und wirft

IllegalArgumentException: Unknown pattern character 'X'

Wir müssen zu normalisieren Datum nach ISO8601 format lesbar in Java 6 mit SimpleDateFormat.

public static Date iso8601Format(String formattedDate) throws ParseException {
    try {
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSX", Locale.US);
        return df.parse(formattedDate);
    } catch (IllegalArgumentException ex) {
        //error happen in Java 6: Unknown pattern character 'X'
        if (formattedDate.endsWith("Z")) formattedDate = formattedDate.replace("Z", "+0000");
        else formattedDate = formattedDate.replaceAll("([+-]\\d\\d):(\\d\\d)\\s*$", "$1$2");
        DateFormat df1 = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ", Locale.US);
        return df1.parse(formattedDate);
    }
}

Oben genannte Methode zu ersetzen [Z mit +0000] oder [+01:00 mit +0100] wenn Fehler in Java 6 (Sie können ermitteln, Java-version und ersetzen Sie try/catch mit if-Anweisung).

InformationsquelleAutor der Antwort Khang .NT

Java hat ein Dutzend verschiedene Möglichkeiten, um ein Datum zu analysieren-Zeit, der guten Antworten hier zeigen. Aber etwas erstaunlich, keine Java-Zeit-Klassen komplett implementieren ISO 8601!

Mit Java 8, die ich empfehlen würde:

ZonedDateTime zp = ZonedDateTime.parse(string);
Date date = Date.from(zp.toInstant());

Behandelt Beispiele, die beide in UTC und mit einem Versatz, wie "2017-09-13T10:36:40Z" oder "2017-09-13T10:36:40+01:00". Es wird für die meisten Anwendungsfälle.

Aber es wird nicht mit Beispielen wie "2017-09-13T10:36:40+01", die ist eine gültige ISO-8601-Datum-Zeit.

Es wird auch nicht behandeln, nur Datum, z.B. "2017-09-13".

Wenn Sie behandeln müssen, ich würde vorschlagen, mit einem regex ersten schnuppern der syntax.

Gibt es eine schöne Liste der ISO-8601-Beispiele hier mit vielen Sonderfällen: https://www.myintervals.com/blog/2009/05/20/iso-8601-date-validation-that-doesnt-suck/ ich bin mir nicht bewusst jede Java-Klasse, konnte mit Ihnen allen gerecht zu werden.

InformationsquelleAutor der Antwort Daniel Winterstein

Hatte ich ein ähnliches Bedürfnis: ich musste in der Lage sein, zu analysieren, jedes Datum nach ISO8601-konform, ohne zu wissen, das genaue format im Voraus, und ich wollte eine leichte Lösung, die funktionieren auch auf Android.

Als ich gegoogelt meine Bedürfnisse stolperte ich über diese Frage, und bemerkt, dass AFAIU, keine Antwort ganz zu meinen Anforderungen passen. So entwickelte ich jISO8601 und schob es auf maven central.

Nur in Sie pom.xml:

<dependency>
  <groupId>fr.turri</groupId>
  <artifactId>jISO8601</artifactId>
  <version>0.2</version>
</dependency>

und dann sind Sie gut zu gehen:

import fr.turri.jiso8601.*;
...
Calendar cal = Iso8601Deserializer.toCalendar("1985-03-04");
Date date = Iso8601Deserializer.toDate("1985-03-04T12:34:56Z");

Hofft, es hilft.

InformationsquelleAutor der Antwort gturri

Machen Sie es wie diese:

public static void main(String[] args) throws ParseException {

    String dateStr = "2016-10-19T14:15:36+08:00";
    Date date = javax.xml.bind.DatatypeConverter.parseDateTime(dateStr).getTime();

    System.out.println(date);

}

Hier ist die Ausgabe:

Mi Okt 19 15:15:36 CST 2016

InformationsquelleAutor der Antwort David Yin

Diese schien zu funktionieren am besten für mich:

public static Date fromISO8601_( String string ) {

    try {
            return new SimpleDateFormat ( "yyyy-MM-dd'T'HH:mm:ssXXX").parse ( string );
    } catch ( ParseException e ) {
        return Exceptions.handle (Date.class, "Not a valid ISO8601", e);
    }


}

Ich brauchte, um zu konvertieren/fro JavaScript-date-strings in Java. Ich fand den oben genannten Werken mit der Empfehlung. Es wurden einige Beispiele für die Verwendung von " = SimpleDateFormat, die in der Nähe waren, aber Sie schien es nicht zu sein, die Teilmenge als empfohlen von:

http://www.w3.org/TR/NOTE-datetime

unterstützt von PLIST-und JavaScript-Strings und solche, die ist, was ich brauchte.

Scheint dies die häufigste form der nach ISO8601 string gibt, und eine gute Auswahl.

Die Beispiele, die Sie geben, sind:

1994-11-05T08:15:30-05:00 corresponds 
November 5, 1994, 8:15:30 am, US Eastern Standard Time.

 1994-11-05T13:15:30Z corresponds to the same instant.

Ich habe auch eine schnelle version:

final static int SHORT_ISO_8601_TIME_LENGTH =  "1994-11-05T08:15:30Z".length ();
                                            //01234567890123456789012
final static int LONG_ISO_8601_TIME_LENGTH = "1994-11-05T08:15:30-05:00".length ();


public static Date fromISO8601( String string ) {
    if (isISO8601 ( string )) {
        char [] charArray = Reflection.toCharArray ( string );//uses unsafe or string.toCharArray if unsafe is not available
        int year = CharScanner.parseIntFromTo ( charArray, 0, 4 );
        int month = CharScanner.parseIntFromTo ( charArray, 5, 7 );
        int day = CharScanner.parseIntFromTo ( charArray, 8, 10 );
        int hour = CharScanner.parseIntFromTo ( charArray, 11, 13 );

        int minute = CharScanner.parseIntFromTo ( charArray, 14, 16 );

        int second = CharScanner.parseIntFromTo ( charArray, 17, 19 );

        TimeZone tz ;

         if (charArray[19] == 'Z') {

             tz = TimeZone.getTimeZone ( "GMT" );
         } else {

             StringBuilder builder = new StringBuilder ( 9 );
             builder.append ( "GMT" );
             builder.append( charArray, 19, LONG_ISO_8601_TIME_LENGTH - 19);
             String tzStr = builder.toString ();
             tz = TimeZone.getTimeZone ( tzStr ) ;

         }
         return toDate ( tz, year, month, day, hour, minute, second );

    }   else {
        return null;
    }

}

...

public static int parseIntFromTo ( char[] digitChars, int offset, int to ) {
    int num = digitChars[ offset ] - '0';
    if ( ++offset < to ) {
        num = ( num * 10 ) + ( digitChars[ offset ] - '0' );
        if ( ++offset < to ) {
            num = ( num * 10 ) + ( digitChars[ offset ] - '0' );
            if ( ++offset < to ) {
                num = ( num * 10 ) + ( digitChars[ offset ] - '0' );
                if ( ++offset < to ) {
                    num = ( num * 10 ) + ( digitChars[ offset ] - '0' );
                    if ( ++offset < to ) {
                        num = ( num * 10 ) + ( digitChars[ offset ] - '0' );
                        if ( ++offset < to ) {
                            num = ( num * 10 ) + ( digitChars[ offset ] - '0' );
                            if ( ++offset < to ) {
                                num = ( num * 10 ) + ( digitChars[ offset ] - '0' );
                                if ( ++offset < to ) {
                                    num = ( num * 10 ) + ( digitChars[ offset ] - '0' );
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    return num;
}


public static boolean isISO8601( String string ) {
      boolean valid = true;

      if (string.length () == SHORT_ISO_8601_TIME_LENGTH) {
          valid &=  (string.charAt ( 19 )  == 'Z');

      } else if (string.length () == LONG_ISO_8601_TIME_LENGTH) {
          valid &=  (string.charAt ( 19 )  == '-' || string.charAt ( 19 )  == '+');
          valid &=  (string.charAt ( 22 )  == ':');

      } else {
          return false;
      }

    // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4
    //"1 9 9 4 - 1 1 - 0 5 T 0 8 : 1 5 : 3 0 - 0 5 : 0 0

    valid &=  (string.charAt ( 4 )  == '-') &&
                (string.charAt ( 7 )  == '-') &&
                (string.charAt ( 10 ) == 'T') &&
                (string.charAt ( 13 ) == ':') &&
                (string.charAt ( 16 ) == ':');

    return valid;
}

Habe ich nicht gemessen, aber ich denke, es wird ziemlich schnell. Es scheint zu funktionieren. 🙂

@Test
public void testIsoShortDate() {
    String test =  "1994-11-05T08:15:30Z";

    Date date = Dates.fromISO8601 ( test );
    Date date2 = Dates.fromISO8601_ ( test );

    assertEquals(date2.toString (), date.toString ());

    puts (date);
}

@Test
public void testIsoLongDate() {
    String test =  "1994-11-05T08:11:22-05:00";

    Date date = Dates.fromISO8601 ( test );
    Date date2 = Dates.fromISO8601_ ( test );

    assertEquals(date2.toString (), date.toString ());

    puts (date);
}

InformationsquelleAutor der Antwort RickHigh