Myślę, że to, co wielu ludzi chce robić, to analizuje ciągi dat JSON. Istnieje duża szansa, że jeśli przejdziesz na tę stronę, możesz chcieć przekonwertować datę JSON JavaScript na datę Java.
Aby pokazać, jak wygląda ciąg daty 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)
Ciąg daty JSON to 2013-12-14T01: 55: 33.412Z.
Daty nie są objęte specyfikacją JSON, powiedzmy, ale powyższy jest bardzo specyficznym formatem ISO 8601, podczas gdy ISO_8601 jest znacznie większy i jest to tylko podzbiór, choć bardzo ważny.
Zobacz http://www.json.org
Zobacz http://en.wikipedia.org/wiki/ISO_8601
Zobacz http://www.w3.org/TR/NOTE-datetime
Tak się składa, że napisałem parser JSON i parser PLIST, z których oba używają ISO-8601, ale nie tych samych bitów.
/*
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);
}
Napisałem dwa sposoby, aby to zrobić dla mojego projektu. Jeden standard, jeden szybki.
Ponownie ciąg daty JSON jest bardzo specyficzną implementacją ISO 8601 ....
(Drugą zamieściłem w drugiej odpowiedzi, która powinna działać dla dat PLIST, które są w innym formacie ISO 8601).
Data JSON jest następująca:
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);
}
}
Pliki PLIST (ASCII nie GNUNext) również używają ISO 8601, ale nie milisekund, więc ... nie wszystkie daty ISO-8601 są takie same. (Przynajmniej nie znalazłem jeszcze takiego, który używa milis, a analizator składni, który widziałem, całkowicie pomija strefę czasową OMG).
Teraz szybka wersja (można ją znaleźć w Boon).
public static Date fromJsonDate( String string ) {
return fromJsonDate ( Reflection.toCharArray ( string ), 0, string.length () );
}
Zauważ, że Reflection.toCharArray używa niebezpiecznych, jeśli jest dostępne, ale domyślnie string.toCharArray, jeśli nie.
(Możesz go usunąć z przykładu, zastępując Reflection.toCharArray (string) 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 jest implementowany w następujący sposób:
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;
}
W każdym razie ... przypuszczam, że sporo osób, które tu przychodzą ... może szukało ciągu daty JSON i chociaż jest to data ISO-8601, jest to bardzo konkretna, wymagająca bardzo dokładnej analizy.
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;
}
Zobacz https://github.com/RichardHightower/boon
Boon ma parser PLIST (ASCII) i parser JSON.
Analizator składni JSON jest najszybszym analizatorem składni JSON w języku Java, jaki znam.
Niezależnie zweryfikowane przez kolesie z 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
Ma najszybszy parser JSON dla strumieni, czytników, bajtów [], char [], CharSequence (StringBuilder, CharacterBuffer) i String.
Zobacz więcej testów porównawczych na:
https://github.com/RichardHightower/json-parsers-benchmark