Ich denke, was viele Leute tun wollen, ist JSON-Datumszeichenfolgen zu analysieren. Wenn Sie zu dieser Seite gelangen, besteht eine gute Chance, dass Sie ein JavaScript-JSON-Datum in ein Java-Datum konvertieren möchten.
So zeigen Sie, wie eine JSON-Datumszeichenfolge aussieht:
var d=new Date();
var s = JSON.stringify(d);
document.write(s);
document.write("<br />"+d);
"2013-12-14T01:55:33.412Z"
Fri Dec 13 2013 17:55:33 GMT-0800 (PST)
Die JSON-Datumszeichenfolge lautet 2013-12-14T01: 55: 33.412Z.
Daten werden nicht von der JSON-Spezifikation abgedeckt, aber das oben genannte ist ein sehr spezifisches ISO 8601-Format, während ISO_8601 viel viel größer ist und dies nur eine Teilmenge ist, wenn auch eine sehr wichtige.
Siehe http://www.json.org
Siehe http://en.wikipedia.org/wiki/ISO_8601
Siehe http://www.w3.org/TR/NOTE-datetime
Zufällig habe ich einen JSON-Parser und einen PLIST-Parser geschrieben, die beide ISO-8601 verwenden, aber nicht dieselben Bits.
/*
var d=new Date();
var s = JSON.stringify(d);
document.write(s);
document.write("<br />"+d);
"2013-12-14T01:55:33.412Z"
Fri Dec 13 2013 17:55:33 GMT-0800 (PST)
*/
@Test
public void jsonJavaScriptDate() {
String test = "2013-12-14T01:55:33.412Z";
Date date = Dates.fromJsonDate ( test );
Date date2 = Dates.fromJsonDate_ ( test );
assertEquals(date2.toString (), "" + date);
puts (date);
}
Ich habe zwei Möglichkeiten geschrieben, dies für mein Projekt zu tun. Ein Standard, einer schnell.
Auch hier ist die JSON-Datumszeichenfolge eine sehr spezifische Implementierung von ISO 8601 ....
(Ich habe die andere in der anderen Antwort gepostet, die für PLIST-Daten funktionieren sollte, die ein anderes ISO 8601-Format haben.)
Das JSON-Datum lautet wie folgt:
public static Date fromJsonDate_( String string ) {
try {
return new SimpleDateFormat ( "yyyy-MM-dd'T'HH:mm:ss.SSSXXX").parse ( string );
} catch ( ParseException e ) {
return Exceptions.handle (Date.class, "Not a valid JSON date", e);
}
}
PLIST-Dateien (ASCII non GNUNext) verwenden ebenfalls ISO 8601, jedoch keine Millisekunden. Daher sind nicht alle ISO-8601-Daten gleich. (Zumindest habe ich noch keinen gefunden, der Milis verwendet, und der Parser, den ich gesehen habe, überspringt die Zeitzone insgesamt OMG).
Nun zur schnellen Version (Sie finden sie in Boon).
public static Date fromJsonDate( String string ) {
return fromJsonDate ( Reflection.toCharArray ( string ), 0, string.length () );
}
Beachten Sie, dass Reflection.toCharArray unsicher verwendet, wenn verfügbar, aber standardmäßig string.toCharArray, wenn nicht.
(Sie können es aus dem Beispiel entfernen, indem Sie Reflection.toCharArray (Zeichenfolge) durch Zeichenfolge.toCharArray () ersetzen.)
public static Date fromJsonDate( char[] charArray, int from, int to ) {
if (isJsonDate ( charArray, from, to )) {
int year = CharScanner.parseIntFromTo ( charArray, from + 0, from + 4 );
int month = CharScanner.parseIntFromTo ( charArray, from +5, from +7 );
int day = CharScanner.parseIntFromTo ( charArray, from +8, from +10 );
int hour = CharScanner.parseIntFromTo ( charArray, from +11, from +13 );
int minute = CharScanner.parseIntFromTo ( charArray, from +14, from +16 );
int second = CharScanner.parseIntFromTo ( charArray, from +17, from +19 );
int miliseconds = CharScanner.parseIntFromTo ( charArray, from +20, from +23 );
TimeZone tz = TimeZone.getTimeZone ( "GMT" );
return toDate ( tz, year, month, day, hour, minute, second, miliseconds );
} else {
return null;
}
}
Das isJsonDate wird wie folgt implementiert:
public static boolean isJsonDate( char[] charArray, int start, int to ) {
boolean valid = true;
final int length = to -start;
if (length != JSON_TIME_LENGTH) {
return false;
}
valid &= (charArray [ start + 19 ] == '.');
if (!valid) {
return false;
}
valid &= (charArray[ start +4 ] == '-') &&
(charArray[ start +7 ] == '-') &&
(charArray[ start +10 ] == 'T') &&
(charArray[ start +13 ] == ':') &&
(charArray[ start +16 ] == ':');
return valid;
}
Wie auch immer ... ich vermute, dass einige Leute, die hierher kommen, nach dem JSON-Datumsstring suchen und obwohl es sich um ein ISO-8601-Datum handelt, ist es ein sehr spezifisches Datum, das eine ganz bestimmte Analyse benötigt.
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;
}
Siehe https://github.com/RichardHightower/boon
Boon verfügt über einen PLIST-Parser (ASCII) und einen JSON-Parser.
Der JSON-Parser ist der schnellste mir bekannte Java-JSON-Parser.
Unabhängig von den Jungs von Gatling Performance verifiziert.
https://github.com/gatling/json-parsers-benchmark
Benchmark Mode Thr Count Sec Mean Mean error Units
BoonCharArrayBenchmark.roundRobin thrpt 16 10 1 724815,875 54339,825 ops/s
JacksonObjectBenchmark.roundRobin thrpt 16 10 1 580014,875 145097,700 ops/s
JsonSmartBytesBenchmark.roundRobin thrpt 16 10 1 575548,435 64202,618 ops/s
JsonSmartStringBenchmark.roundRobin thrpt 16 10 1 541212,220 45144,815 ops/s
GSONStringBenchmark.roundRobin thrpt 16 10 1 522947,175 65572,427 ops/s
BoonDirectBytesBenchmark.roundRobin thrpt 16 10 1 521528,912 41366,197 ops/s
JacksonASTBenchmark.roundRobin thrpt 16 10 1 512564,205 300704,545 ops/s
GSONReaderBenchmark.roundRobin thrpt 16 10 1 446322,220 41327,496 ops/s
JsonSmartStreamBenchmark.roundRobin thrpt 16 10 1 276399,298 130055,340 ops/s
JsonSmartReaderBenchmark.roundRobin thrpt 16 10 1 86789,825 17690,031 ops/s
Es verfügt über den schnellsten JSON-Parser für Streams, Reader, Bytes [], char [], CharSequence (StringBuilder, CharacterBuffer) und String.
Weitere Benchmarks finden Sie unter:
https://github.com/RichardHightower/json-parsers-benchmark