1. Présentation des dates dans Java <Br /> La date est un contenu très complexe en Java. Pour une date dans différents environnements linguistiques et pays, l'internationalisation des dates, la conversion entre les dates et le temps, l'ajout et la soustraction des dates, et le format d'affichage des dates sont tous des problèmes très compliqués.
En Java, la date de fonctionnement implique principalement les classes suivantes:
1. Java.util.date
La date de classe représente un moment spécifique, précis pour les millisecondes. À partir de JDK 1.1, la classe de calendrier doit être utilisée pour implémenter la conversion entre les champs de date et d'heure, et la classe DateFormat doit être utilisée pour formater et analyser les chaînes de date. La méthode de la date d'interpréter les dates comme l'année, le mois, le jour, l'heure, la minute et la deuxième valeur est abandonnée.
2. Java.text.dateformat (classe abstraite)
DateFormat est une classe abstraite de sous-classes de dattes / heure qui formatent et analysent les dates ou les temps d'une manière indépendante du langage. Les sous-classes de formatage de date / heure (telles que SimpledateFormat) permettent la mise en forme (c'est-à-dire la date-> texte), l'analyse (text-> date) et la normalisation. Indique la date comme un objet de date, ou comme le nombre de millisecondes à partir du moment où GMT (GMT) 1970, 1er janvier, 00:00:00.
3. Java.text.simpledateFormat (sous-classe directe de DateFormat)
SimpledateFormat est une classe spécifique qui formate et analyse les dates d'une manière liée aux paramètres régionaux. Il permet le formatage (date-> texte), l'analyse (text-> date) et la normalisation.
SimpledateFormat vous permet de sélectionner tout mode de format de date-date défini par l'utilisateur. Cependant, il est toujours recommandé d'utiliser GetTimeInstance, GetDateInstance ou GetDatetimeInstance dans DateFormat pour créer un nouveau formateur de date d'heure.
4. Java.util.calendar (classe abstraite)
La classe de calendrier est une classe abstraite qui fournit quelques méthodes pour convertir un moment spécifique en un ensemble de champs de calendrier tels que l'année, le mois, le jour_of_month, l'heure, etc., et fournit des méthodes pour manipuler des champs de calendrier tels que l'obtention de la date de la semaine prochaine. L'instant peut être exprimé comme une valeur milliseconde, qui est le décalage de l'époque (c'est-à-dire 00: 00: 00.000, GMT, 1er janvier 1970, GMT).
Comme les autres classes sensibles aux paramètres régionaux, Calendar fournit une méthode de classe GetInstance pour obtenir un objet commun de ce type. La méthode GetInstance de Calendar renvoie un objet calendrier dont les champs de calendrier ont été initialisés par la date et l'heure actuelles.
5. Java.util.gregoriancalendar (sous-classe directe du calendrier)
Gregoriancalendar est une sous-classe de calendrier en béton qui fournit un système de calendrier standard utilisé par la plupart des pays du monde.
GregorianCalendar est un calendrier hybride qui prend en charge les systèmes de calendrier julien et grégorien avec le soutien d'une seule discontinuité, qui correspond par défaut à la date grégorienne lorsque le calendrier grégorien a été fondé (certains pays ont été fondés le 15 octobre 1582 et plus tard dans d'autres). La date de début peut être modifiée par l'appelant en appelant setGregorianChange ().
2. Utilisation de java.util.date
1. Introduction à l'API de java.util.date
La classe java.util.date représente un moment spécifique, précis pour les millisecondes. Il existe de nombreuses méthodes fournies, mais beaucoup sont obsolètes et ne sont pas recommandées. Le suivant ne répertorie que les méthodes qui ne sont pas obsolètes:
Résumé des méthodes de construction
----------------------
Date()
Attribuez un objet à date et initialisez cet objet avec l'heure actuelle pour indiquer l'heure à laquelle il a été alloué (précis aux millisecondes).
Date (date longue)
Attribuez un objet de date et initialisez cet objet pour représenter le nombre spécifié de millisecondes depuis l'heure de référence standard (appelée "époque", c'est-à-dire 00:00:00 GMT le 1er janvier 1970).
Résumé de la méthode
----------------------
booléen après (date quand)
Teste si cette date est après la date spécifiée.
booléen avant (date quand)
Teste si cette date est avant la date spécifiée.
Objet clone ()
Renvoie une copie de cet objet.
int compareto (date autre
Comparez l'ordre de deux dates.
booléen égaux (objet obj)
Comparez l'égalité de deux dates.
long gettime ()
Renvoie le nombre de millisecondes représentées par cet objet de date depuis le 1er janvier 1970 00:00:00 GMT.
int hashcode ()
Renvoie la valeur du code de hachage de cet objet.
vide settime (longtemps)
Définissez cet objet de date pour représenter le moment dans le temps des millisecondes après 00:00:00 GMT le 1er janvier 1970.
String toString ()
Convertissez cet objet de date en chaîne du formulaire suivant: Dow mon dd hh: mm: ss zzz yyyy où:
Dow est un jour de la semaine (soleil, lun, mar, mer, jeu, ven, samedi).
Lun est le mois (janvier, février, mars, avril, mai, juin, juil, août, sept. Oct, nov, déc).
DD est un jour de janvier (01 à 31) affiché comme un numéro décimal à deux chiffres.
HH est l'heure de la journée (00 à 23), affichée comme un numéro décimal à deux chiffres.
MM est les minutes (00 à 59) dans l'heure et est affichée comme un numéro décimal à deux chiffres.
SS est le nombre de secondes (00 à 61) en une minute, affichée comme un numéro décimal à deux chiffres.
ZZZ est le fuseau horaire (et reflète l'heure d'été). L'abréviation du fuseau horaire standard comprend l'abréviation du fuseau horaire reconnu par l'analyse de la méthode. Si les informations de fuseau horaire ne sont pas fournies, ZZZ est vide, c'est-à-dire qu'aucun caractères n'est inclus du tout.
Yyyy est un an, affiché comme un numéro décimal à 4 chiffres.
Voici un exemple complet de la classe de date:
classe publique TestDate {public static void main (String [] args) {testdate testDate = new TestDate (); testDate.getSystemCurrentTime (); testDate.getCurrentDate (); } / ** * Obtenez le temps du système actuel * System.CurrentTimemillis () Renvoie le temps du système actuel, et le résultat commence à 0h00 du 1er janvier 1970. System.out.println (System.CurrentTimemillis ()); } public void getCurrentDate () {System.out.println ("--- Obtenez l'heure actuelle du système ---"); // Créer et initialiser une date (la valeur initiale est la date actuelle) Date de date = new Date (); System.out.println ("La date actuelle est =" + date.toString ()); System.out.println ("Le nombre de millisecondes expérimenté depuis le 1er janvier 1970 =" + date.getTime ()); }} 2. Utilisation de Java.Text.Dateformat Résumé Classe
DateFormat est une classe abstraite de sous-classes de dattes / heure qui formatent et analysent les dates ou les temps d'une manière indépendante du langage. Les sous-classes de formatage de date / heure (telles que SimpledateFormat) permettent la mise en forme (c'est-à-dire la date-> texte), l'analyse (text-> date) et la normalisation. Indique la date comme un objet de date, ou comme le nombre de millisecondes à partir du moment où GMT (GMT) 1970, 1er janvier, 00:00:00.
DateFormat fournit un certain nombre de méthodes de classe pour obtenir le formateur de date / heure par défaut en fonction des styles de paramètre par défaut ou des paramètres régionaux et multiples. Les styles de format incluent complet, long, moyen et court. Plus de détails et d'exemples d'utilisation de ces styles sont fournis dans la description de la méthode.
DateFormat aide à formater et à analyser les dates pour tout lieu. Pendant des mois, des semaines et même des formats de calendrier (calendrier lunaire et solaire), le code peut être complètement sans rapport avec les conventions locales.
Pour formater une date dans les paramètres régionaux actuels, utilisez une méthode d'usine statique:
myString = dateFormat.getDateInstance (). Format (mydate);
Si vous formatez plusieurs dates, il est plus efficace d'obtenir le format et de l'utiliser plusieurs fois, de sorte que le système n'a pas à obtenir des informations sur la langue de l'environnement et les accords nationaux plusieurs fois.
DateFormat df = dateFormat.getDateInstance (); pour (int i = 0; i <mydate.length; ++ i) {output.println (df.format (mydate [i]) + ";"); }
Pour formater les dates de différents endroits, spécifiez-le dans l'appel à getDateInstance ().
DATEFORMAT DF = DATEFormat.getDateInstance (dateFormat.Long, Locale.France);
DateFormat peut également être utilisé pour l'analyse.
MyDate = df.Parse (MyString);
Utilisez GetDateInstance pour obtenir le format de date standard pour ce pays. Certaines autres méthodes d'usine statiques sont également fournies. Utilisez GetTimeInstance pour obtenir le format d'heure pour ce pays. Utilisez GetDateTimeInstance pour obtenir des formats de date et d'heure. Différentes options peuvent être transmises dans ces méthodes d'usine pour contrôler la longueur du résultat (de court à moyen à long à pleine). Le résultat exact dépend de l'endroit, mais généralement:
La courte est entièrement un nombre, comme 12.13.52 ou 15h30
Le médium est plus long, comme le 12 janvier 1952
Long est long, comme le 12 janvier 1952 ou 15:30:32
Full est entièrement spécifié, comme le mardi 12 avril 1952 après JC ou 15:30:42 PM PST.
Si vous le souhaitez, vous pouvez également définir le fuseau horaire sur le format. Si vous souhaitez imposer plus de contrôle sur le formatage ou l'analyse (ou donner à l'utilisateur plus de contrôle), vous pouvez essayer de lancer le DateFormat obtenu à partir de la méthode d'usine à SimpledateFormat. Cela fonctionne pour la plupart des pays; N'oubliez pas de le mettre dans un bloc d'essai en cas de formats spéciaux.
Vous pouvez également utiliser la méthode d'analyse et de formatage avec une position par Parse et FieldPosition pour analyser les parties d'une chaîne étape par étape. Alignez un champ spécifique ou découvrez où la chaîne est sélectionnée à l'écran.
DateFormat n'est pas synchrone. Il est recommandé de créer des instances de format indépendant pour chaque thread. Si plusieurs threads accèdent à un format en même temps, il doit rester synchronisé en externe.
3. Utilisation de java.text.simpledateFormat (sous-classe directe de DateFormat)
SimpledateFormat est une classe spécifique qui formate et analyse les dates d'une manière liée aux paramètres régionaux. Il permet le formatage (date-> texte), l'analyse (text-> date) et la normalisation.
SimpledateFormat vous permet de sélectionner tout mode de format de date-date défini par l'utilisateur. Cependant, il est toujours recommandé d'utiliser GetTimeInstance, GetDateInstance ou GetDatetimeInstance dans DateFormat pour créer un nouveau formateur de date d'heure. Chaque méthode de classe peut renvoyer un formateur de date / heure initialisé en mode format par défaut. Le modèle de format peut être modifié à l'aide de la méthode ApplaidPattern au besoin. Pour plus d'informations sur l'utilisation de ces méthodes, voir DateFormat.
Mode de date et d'heure
Le format de date et d'heure est spécifié par la chaîne de date et d'heure. Dans les chaînes de motifs de date et de délai, les lettres non cotées «a« à «z» et «a» à «z» sont interprétées comme des lettres de modèle pour représenter des éléments de la chaîne de date ou de temps. Le texte peut être enfermé en citations uniques (') pour éviter les explications. "''" signifie citations simples. Tous les autres personnages ne sont pas interprétés; Ils sont simplement copiés sur la chaîne de sortie lorsqu'ils sont formatés ou correspondants à la chaîne d'entrée lorsqu'ils sont analysés.
Pour plus d'informations de référence, vous pouvez afficher la documentation de l'API JDK. Voici un exemple complet:
classe publique TestDateFormat {public static void main (String [] args) lève ParseException {testDateFormat tdf = new TestDateFormat (); tdf.dateFormat (); } / ** * Testez la classe SimpledateFormat * @throws parseException * / public void dateFormat () lève ParseException {// Créer la date de date = new Date (); // Créer des formats de date différents DATEFORMAT DF1 = DATEFormat.getInstance (); DateFormat df2 = new SimpledateFormat ("Yyyy-MM-01 HH: MM: SS EE"); DATEFORMAT DF3 = DATEFORMAT.GetDateInstance (DateFormat.Full, Locale.China); // Créez un format de date avec une longueur spécifiée du pays spécifié. La longueur est différente et l'intégrité de la date affichée est également différente. DateFormat DF4 = Nouveau simpletateFormat ("Yyyyy Year Mm Moids DD DD HH Hour MM Minute SS Seconds EE", Locale.China); DateFormat df5 = new SimpledateFormat ("Yyyy-mm-dd HH: MM: SS Eeeeee", Locale.us); DateFormat df6 = new SimpledateFormat ("yyyy-mm-dd"); // Dates de sortie dans différents formats System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- DF3.Format (date)); DF5.Format (date); Date Date2 = DF2.Parse ("2016-01-24 02:51:07 Dimanche"); Date Date3 = DF3.Parse ("2016-01-24"); Date Date4 = DF4.Parse ("2016-01-24 02:51:18 Dimanche"); Date Date6 = DF6.Parse ("2016-01-24"); System.out.println ("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- System.out.println (Date2); 4. Java.util.calendar (classe abstraite)
Java.util.calendar est une classe abstraite, une représentation abstraite du temps du système. Il fournit quelques méthodes pour convertir un moment spécifique en un ensemble de champs de calendrier tels que l'année, le mois, le jour_of_month, l'heure, etc., et fournit quelques méthodes pour manipuler les champs de calendrier (comme l'obtention de la date de la semaine prochaine). L'instant peut être exprimé comme une valeur milliseconde, qui est le décalage de l'époque (c'est-à-dire 00: 00: 00.000, GMT, 1er janvier 1970, GMT).
Comme les autres classes sensibles aux paramètres régionaux, Calendar fournit une méthode de classe GetInstance pour obtenir un objet commun de ce type. La méthode GetInstance de Calendar renvoie un objet calendrier dont les champs de calendrier ont été initialisés par la date et l'heure actuelles.
Une instance de calendrier est une représentation abstraite du temps du système. À partir de l'instance de calendrier, vous pouvez connaître des informations telles que l'année, le mois, le jour, la semaine, le mois et le mois. Il existe une méthode statique GET (int x) dans la classe de calendrier. Grâce à cette méthode, vous pouvez obtenir certaines valeurs (année, mois, jour, semaine, mois, etc.) des informations sur l'instance pertinente. Le paramètre x est une valeur de rendement, définie dans le calendrier.
Certains pièges dans le calendrier peuvent facilement tomber:
1. La semaine du calendrier commence dimanche, avec une valeur constante de 0.
2. Le mois du calendrier commence à partir de janvier, avec une valeur constante de 0.
3. Le premier jour de Calendar de chaque mois est 1.
5. Java.util.gregoriancalendar (sous-classe directe du calendrier)
Gregoriancalendar est une sous-classe de calendrier en béton qui fournit un système de calendrier standard utilisé par la plupart des pays du monde. Utilisé en conjonction avec la classe abstraite du calendrier.
Voici un exemple complet pour voir l'utilisation de la classe de calendrier:
classe publique TestCalendar {public static void main (String [] args) lève ParseException {testCalendar testCalendar = new TestCalendar (); TestCalendar.TestCalendar (); TestCalendar.TestCalendar2 (); } public void testCalendar () {// Comment créer Calendar Calendar Calendar NOW1 = Calendar.GetInSance (); Calendrier maintenant2 = new GregorianCalendar (); Calendrier Now3 = New GregorianCalendar (2016, 01, 24); Calendrier Now4 = New GregorianCalendar (2016, 01, 24, 15, 55); // Trail: le mois du calendrier est de 0 à 11 calendrier maintenant 5 = New Gregoriancalendar (2016, 01, 24, 15, 55, 44); Calendrier Now6 = New GregorianCalendar (Locale.us); Calendar Now7 = New GregorianCalendar (Timezone.getTimeZone ("GMT-8: 00")); // Set Calendar Now2.SetTime (new Date ()); System.out.println (NOW2); Now2.SetTimeInmillis (new Date (). GetTime ()); System.out.println (NOW2); // Définissez le format de sortie chinois de la date et de la sortie La date SimpledateFormat DF = new SimpledateFormat ("Yyyyy Year Mm Mois DD DD HH Hour Mm Minute SS Seconds E", Locale.China); System.out.println ("Obtenez la sortie formatée chinoise de la date:" + df.format (now5.getTime ())); System.out.println (); System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Now5.get (Calendar.Month)); Now5.get (Calendar.Second)); System.out.println ("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- "March", "April", "May", "juin", "juillet", "August", "Septembre", "Octobre", "novembre", "décembre"}; System.out.println ("Le mois de l'objet NOW5 est:" + mois [NOW5.get (calendar.month)]); } public void testCalendar2 () lève ParseException {// Obtenez le nombre maximum de jours dans le mois en cours Calendar Cal = Calendar.getInstance (); int maxday = cal.getactualmaximum (calendar.day_of_month); int MindDay = cal.getactualMinimum (calendar.day_of_month); System.out.println (Maxday); // Prenez le dernier jour du mois DateFormat Formatter3 = new SimpledateFormat ("yyyy-mm -" + maxday); System.out.println (format3.format (cal.getTime ())); // Prenez le dernier jour du mois DateFormat Formatter4 = new SimpledateFormat ("Yyyy-mm -" + Minday); System.out.println (formatter4.format (cal.getTime ())); // Trouvez le nombre de jours entre deux dates java.text.SimpledateFormat format = new Java.Text.SimpledateFormat ("yyyy-mm-dd"); java.util.date Begindate = Format.Parse ("2007-12-24"); java.util.date enddate = format.parse ("2007-12-25"); Long Day = (enddate.getTime () - Begindate.getTime ()) / (24 * 60 * 60 * 1000); System.out.println ("Nombre de jours d'intervalle =" + jour); // Date il y a un an java.text.format Formatter5 = new Java.Text.SimpledateFormat ("Yyyy-mm-dd"); java.util.date dès aujourd'hui = new Java.util.date (); long beforetime = (TodayDate.getTime () / 1000) -60 * 60 * 24 * 365; TodayDate.SetTime (BeforEtime * 1000); String Beforedate = Formatter5.Format (TodayDate); System.out.println (Beforedate); Calendar Calendar = calendar.getInstance (); calendar.add (calendar.year, -1); System.out.println (formatter5.format (calendar.getTime ())); // le lundi et le dimanche de la semaine en cours simpletateFormat DateFormat = new SimpledateFormat ("yyyymmdd"); Gregoriancalendar GregorianCalendar = New GregorianCalendar (); int dayinweek = gregoriancalendar.get (calendar.day_of_week); int offset = 0; if (dayinweek == 1) {// dimanche offset = 6; } else {// lundi au samedi offset = dayinweek - 2; } gregoriancalendar.add (gregoriancalendar.day_of_month, -offset); String sday = dateFormat.format (GregorianCalendar.getTime ()); gregoriancalendar.add (gregoriancalendar.day_of_month, 6); String Eday = DateFormat.Format (GregorianCalendar.getTime ()); System.out.println ("Lundi de cette semaine:" + Sday); System.out.println ("Dimanche de cette semaine:" + Eday); }}3. Résumé
Il y a souvent cinq aspects des dates en Java:
1. Date de création
2. Affichage du format de date
3. Conversion de date (principalement conversion mutuelle avec les chaînes)
4. Obtenez les dates de l'âge moyen, du mois, du jour, de l'heure, de la minute, du deuxième, de la semaine, du mois, etc.
5. Comparaison de la taille de la date et de l'addition et de la soustraction des dates.
Ce qui précède est la méthode de la date de la date et du temps Java résumé pour vous. J'espère que ce sera utile à votre apprentissage.