analyser ce type de format de date en java? [dupliquer]
-
26-09-2019 - |
Question
Cette question a déjà une réponse ici:
ce serait la meilleure façon d'analyser ce format de date ci-dessous en java:
2010-09-18T10:00:00.000+01:00
i lu le api DateFormat en java et ne pouvait pas trouver une méthode qui prend une chaîne ou même ce type de format de date comme paremeter à analyser? Quand je veux dire par Parse je veux dire que je veux extraire la « date (jour mois et année) », « temps » et « fuseau horaire » en objets de chaîne séparés.
Merci d'avance
La solution
Une autre réponse, puisque vous semblez se concentrer sur déchirer simplement la part String
(pas une bonne idée, à mon humble avis.) Supposons que la chaîne est valide ISO8601. Pouvez-vous supposer qu'il sera toujours sous la forme que vous citez, ou est-ce juste valide 8601? Dans ce dernier cas, vous devez faire face à un tas de scénarios comme ces gars-là ont fait .
Le regex ils sont venus avec pour valider 8601 alternatives est:
^([\+-]?\d{4}(?!\d{2}\b))((-?)((0[1-9]|1[0-2])(\3([12]\d|0[1-9]|3[01]))?|W([0-4]\d|5[0-2])
(-?[1-7])?|(00[1-9]|0[1-9]\d|[12]\d{2}|3([0-5]\d|6[1-6])))([T\s]((([01]\d|2[0-3])
((:?)[0-5]\d)?|24\:?00)([\.,]\d+(?!:))?)?(\17[0-5]\d([\.,]\d+)?)?
([zZ]|([\+-])([01]\d|2[0-3]):?([0-5]\d)?)?)?)?$
Comprendre comment taquinent les groupes de capture corrects me fait patraque. Néanmoins, ce qui suit fonctionnera pour votre cas:
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Regex8601
{
static final Pattern r8601 = Pattern.compile("(\\d{4})-(\\d{2})-(\\d{2})T((\\d{2}):"+
"(\\d{2}):(\\d{2})\\.(\\d{3}))((\\+|-)(\\d{2}):(\\d{2}))");
//2010-09-18T10:00:00.000+01:00
public static void main(String[] args)
{
String thisdate = "2010-09-18T10:00:00.000+01:00";
Matcher m = r8601.matcher(thisdate);
if (m.lookingAt()) {
System.out.println("Year: "+m.group(1));
System.out.println("Month: "+m.group(2));
System.out.println("Day: "+m.group(3));
System.out.println("Time: "+m.group(4));
System.out.println("Timezone: "+m.group(9));
} else {
System.out.println("no match");
}
}
}
Autres conseils
Si vous faites quoi que ce soit non trivial avec les dates et heures, recommande l'utilisation de JodaTime . Voir cette vaste discussion SO , y compris ISO8601. Voir aussi " Dois-je utiliser des données natif / temps ... ".
Voici un extrait de code exemple, tiré de cet exemple , si vous voulez utiliser SimpleDateFormat
JDK.
// 2004-06-14T19:GMT20:30Z
// 2004-06-20T06:GMT22:01Z
// http://www.cl.cam.ac.uk/~mgk25/iso-time.html
//
// http://www.intertwingly.net/wiki/pie/DateTime
//
// http://www.w3.org/TR/NOTE-datetime
//
// Different standards may need different levels of granularity in the date and
// time, so this profile defines six levels. Standards that reference this
// profile should specify one or more of these granularities. If a given
// standard allows more than one granularity, it should specify the meaning of
// the dates and times with reduced precision, for example, the result of
// comparing two dates with different precisions.
// The formats are as follows. Exactly the components shown here must be
// present, with exactly this punctuation. Note that the "T" appears literally
// in the string, to indicate the beginning of the time element, as specified in
// ISO 8601.
// Year:
// YYYY (eg 1997)
// Year and month:
// YYYY-MM (eg 1997-07)
// Complete date:
// YYYY-MM-DD (eg 1997-07-16)
// Complete date plus hours and minutes:
// YYYY-MM-DDThh:mmTZD (eg 1997-07-16T19:20+01:00)
// Complete date plus hours, minutes and seconds:
// YYYY-MM-DDThh:mm:ssTZD (eg 1997-07-16T19:20:30+01:00)
// Complete date plus hours, minutes, seconds and a decimal fraction of a
// second
// YYYY-MM-DDThh:mm:ss.sTZD (eg 1997-07-16T19:20:30.45+01:00)
// where:
// YYYY = four-digit year
// MM = two-digit month (01=January, etc.)
// DD = two-digit day of month (01 through 31)
// hh = two digits of hour (00 through 23) (am/pm NOT allowed)
// mm = two digits of minute (00 through 59)
// ss = two digits of second (00 through 59)
// s = one or more digits representing a decimal fraction of a second
// TZD = time zone designator (Z or +hh:mm or -hh:mm)
public static Date parse( String input ) throws java.text.ParseException
{
//NOTE: SimpleDateFormat uses GMT[-+]hh:mm for the TZ which breaks
//things a bit. Before we go on we have to repair this.
SimpleDateFormat df = new SimpleDateFormat( "yyyy-MM-dd'T'HH:mm:ssz" );
//this is zero time so we need to add that TZ indicator for
if ( input.endsWith( "Z" ) ) {
input = input.substring( 0, input.length() - 1) + "GMT-00:00";
} else {
int inset = 6;
String s0 = input.substring( 0, input.length() - inset );
String s1 = input.substring( input.length() - inset, input.length() );
input = s0 + "GMT" + s1;
}
return df.parse( input );
}
Cette date est format ISO 8601 . Voilà un lien vers un analyseur spécifique à ce format qui utilise le Java API SimpleDateFormat analyse syntaxique interne.
Vous devez utiliser SimpleDateFormat ,
Trouver des exemples et ici pour commencer
. Vous pouvez utiliser javax.xml.datatype.DatatypeFactory#newXMLGregorianCalendar(String lexicalRepresentation)
(API docs ). Le retour XMLGregorianCalendar vous donne accès à tous les champs séparés.
Utilisez SimpleDateFormat , avec le comme motif yyy-MM-dd'T'HH:mm:ss.SSSZ
Mise à jour SimpleDateFormat ne fonctionnera pas avec le format de date ISO 8601. utilisez plutôt JodaTime à la place. Il fournit ISOChronology conforme à la norme ISO 8601 .
bref exemple peut être trouvé sur SO .
La solution est plus facile ceci:
Date date = null;
SimpleDateFormat isoFormatWithMillis = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSXXX");
try {
date = isoFormatWithMillis.parse("2010-09-18T10:00:00.000+01:00");
} catch (ParseException e) {
e.printStackTrace();
}
System.out.println(date);
imprimera Sat Sep 18 11:00:00 CEST 2010
.
Si vous utilisez Java 7 ou vous pouvez consulter plus tôt à cette