Penso che molte persone vogliano analizzare le stringhe di date JSON. C'è una buona possibilità se vieni in questa pagina che potresti voler convertire una data JSON JavaScript in una data Java.
Per mostrare l'aspetto di una stringa di date JSON:
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)
La stringa di data JSON è 2013-12-14T01: 55: 33.412Z.
Le date non sono coperte dalle specifiche JSON per dire, ma quanto sopra è un formato ISO 8601 molto specifico, mentre ISO_8601 è molto più grande e questo è un semplice sottoinsieme anche se molto importante.
Vedi http://www.json.org
Vedi http://en.wikipedia.org/wiki/ISO_8601
Vedi http://www.w3.org/TR/NOTE-datetime
Accade di aver scritto un parser JSON e un parser PLIST che usano entrambi ISO-8601 ma non gli stessi bit.
/*
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);
}
Ho scritto due modi per farlo per il mio progetto. Uno standard, uno veloce.
Ancora una volta, la stringa di date JSON è un'implementazione molto specifica di ISO 8601 ....
(Ho pubblicato l'altro nell'altra risposta che dovrebbe funzionare per le date PLIST, che sono in un diverso formato ISO 8601).
La data di JSON è la seguente:
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);
}
}
Anche i file PLIST (ASCII non GNUNext) usano ISO 8601 ma nessun millisecondo quindi ... non tutte le date ISO-8601 sono uguali. (Almeno non ne ho ancora trovato uno che usi milis e il parser che ho visto salta del tutto il fuso orario OMG).
Ora per la versione veloce (la puoi trovare in Boon).
public static Date fromJsonDate( String string ) {
return fromJsonDate ( Reflection.toCharArray ( string ), 0, string.length () );
}
Si noti che Reflection.toCharArray utilizza non sicuro se disponibile, ma per impostazione predefinita è string.toCharArray in caso contrario.
(È possibile estrarlo dall'esempio sostituendo Reflection.toCharArray (stringa) con string.toCharArray ()).
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;
}
}
IsJsonDate è implementato come segue:
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;
}
Comunque ... la mia ipotesi è che un bel po 'di persone che vengono qui potrebbero cercare la stringa di date JSON e sebbene sia una data ISO-8601, è molto specifica che necessita di un'analisi molto specifica.
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;
}
Vedi https://github.com/RichardHightower/boon
Boon ha un parser PLIST (ASCII) e un parser JSON.
Il parser JSON è il parser Java JSON più veloce che io conosca.
Verificato indipendentemente dai ragazzi di Gatling Performance.
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
Ha il parser JSON più veloce per stream, lettori, byte [], char [], CharSequence (StringBuilder, CharacterBuffer) e String.
Vedi altri benchmark su:
https://github.com/RichardHightower/json-parsers-benchmark