Je pense que ce que beaucoup de gens veulent faire, c'est analyser les chaînes de date JSON. Si vous arrivez sur cette page, il y a de fortes chances que vous souhaitiez convertir une date JSON JavaScript en date Java.
Pour montrer à quoi ressemble une chaîne de 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 chaîne de date JSON est 2013-12-14T01: 55: 33.412Z.
Les dates ne sont pas couvertes par les spécifications JSON, mais ce qui précède est un format ISO 8601 très spécifique, tandis que ISO_8601 est beaucoup plus grand et c'est un simple sous-ensemble, bien que très important.
Voir http://www.json.org
Voir http://en.wikipedia.org/wiki/ISO_8601
Voir http://www.w3.org/TR/NOTE-datetime
En l'occurrence, j'ai écrit un analyseur JSON et un analyseur PLIST qui utilisent tous les deux ISO-8601 mais pas les mêmes 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);
}
J'ai écrit deux façons de le faire pour mon projet. Un standard, un rapide.
Encore une fois, la chaîne de date JSON est une implémentation très spécifique de l'ISO 8601 ....
(J'ai posté l'autre dans l'autre réponse qui devrait fonctionner pour les dates PLIST, qui sont un format ISO 8601 différent).
La date JSON est la suivante:
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);
}
}
Les fichiers PLIST (ASCII non GNUNext) utilisent également ISO 8601 mais pas de millisecondes donc ... toutes les dates ISO-8601 ne sont pas identiques. (Au moins, je n'en ai pas encore trouvé un qui utilise des milis et l'analyseur que j'ai vu ignorer complètement le fuseau horaire OMG).
Maintenant, pour la version rapide (vous pouvez le trouver à Boon).
public static Date fromJsonDate( String string ) {
return fromJsonDate ( Reflection.toCharArray ( string ), 0, string.length () );
}
Notez que Reflection.toCharArray utilise dangereux s'il est disponible mais par défaut à string.toCharArray sinon.
(Vous pouvez le retirer de l'exemple en remplaçant Reflection.toCharArray (string) par 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 est implémenté comme suit:
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;
}
Quoi qu'il en soit ... je suppose que bon nombre de personnes qui viennent ici .. pourraient rechercher la chaîne de date JSON et bien qu'il s'agisse d'une date ISO-8601, elle est très spécifique et nécessite une analyse très spécifique.
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;
}
Voir https://github.com/RichardHightower/boon
Boon a un analyseur PLIST (ASCII) et un analyseur JSON.
L'analyseur JSON est l'analyseur JSON Java le plus rapide que je connaisse.
Vérifié indépendamment par les gars de 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
Il possède l'analyseur JSON le plus rapide pour les flux, lecteurs, octets [], char [], CharSequence (StringBuilder, CharacterBuffer) et String.
Voir plus de repères sur:
https://github.com/RichardHightower/json-parsers-benchmark