1. Überblick über Daten in Java <br /> ist ein sehr komplexer Inhalt in Java. Für ein Datum in verschiedenen Sprach- und Länderumgebungen sind die Internationalisierung von Daten, die Umwandlung zwischen Daten und Zeit, die Addition und Subtraktion von Daten und das Anzeigeformat von Daten sehr komplizierte Probleme.
In Java beinhaltet das Operationsdatum hauptsächlich die folgenden Klassen:
1. Java.util.date
Der Klassendatum repräsentiert einen bestimmten Moment, der auf Millisekunden genau ist. Ausgehend von JDK 1.1 sollte die Kalenderklasse verwendet werden, um die Konvertierung zwischen Datums- und Zeitfeldern zu implementieren, und die DateFormat -Klasse sollte verwendet werden, um Datumszeichenfolgen zu formatieren und zu analysieren. Die Methode, die Datum als Jahr, Monat, Tag, Stunde, Minute und zweite Werte zu interpretieren, wird aufgegeben.
2. Java.Text.DateFormat (Abstract Class)
DateFormat ist eine abstrakte Klasse von Unterklassen mit Datums-/Zeitformatierung, die Daten oder Zeiten auf sprachunabhängige Weise formatieren und analysieren. Datums-/Zeitformatierungsunterklassen (z. B. SimpleDateFormat) Ermöglichen Sie eine Formatierung (d. H. Datum-> Text), Analyse (Text-> Datum) und Standardisierung. Bezeichnen Sie das Datum als Datumsobjekt oder als Anzahl der Millisekunden ab dem Moment, in dem GMT (GMT) 1970, 1. Januar 00:00:00 Uhr.
3..
SimpleDateFormat ist eine bestimmte Klasse, die die Daten formatiert und analysiert. Es ermöglicht das Formatieren (Datum-> Text), Analyse (Text-> Datum) und Normalisierung.
Mit SimpledateFormat können Sie einen beliebigen benutzerdefinierten Datum-Zeit-Format-Modus auswählen. Es wird jedoch weiterhin empfohlen, GetTimeInstance, GetDateinstance oder GetDatetimeInstance in DateFormat zu verwenden, um ein neues Datum-Zeit-Formatierer zu erstellen.
4.. Java.util.Calendar (abstrakte Klasse)
Die Kalenderklasse ist eine abstrakte Klasse, die einige Methoden zum Umwandeln eines bestimmten Moments in eine Reihe von Kalenderfeldern wie Jahr, Monat, Day_of_month, Stunde usw. bietet und einige Methoden zum Manipulieren von Kalenderfeldern wie das Erhalten des Datums der nächsten Woche bietet. Der Augenblick kann als Millisekundenwert ausgedrückt werden, der der Versatz aus der Epoche ist (d. H. 00: 00: 00.000, GMT, 1. Januar 1970, GMT).
Wie bei anderen lokalempfindlichen Klassen bietet der Kalender eine Klassenmethode, um ein gemeinsames Objekt dieser Art zu erhalten. Die GetInstance -Methode von Calendar gibt ein Kalenderobjekt zurück, dessen Kalenderfelder bis zum aktuellen Datum und zum aktuellen Uhrzeit initialisiert wurden.
5. Java.util.gregoriancalendar (direkte Unterklasse des Kalenders)
Gregoriancalendar ist eine konkrete Kalenderunterklasse, die ein Standardkalendersystem bietet, das von den meisten Ländern der Welt verwendet wird.
Gregoriancalendar ist ein Hybridkalender, der sowohl die Julian- als auch die gregorianischen Kalendersysteme mit Unterstützung einer einzigen Diskontinuität unterstützt, die dem Gregorianischen Datum, als der Gregorianische Kalender gegründet wurde, entspricht (einige Länder wurden am 15. Oktober 1582 und später ins andere gegründet). Das Startdatum kann vom Anrufer durch Aufrufen von Setgregorianchange () geändert werden.
2. Verwendung von java.util.date
1. Einführung in die API von Java.util.date
Die Klasse java.util.date stellt einen bestimmten Moment dar, der auf Millisekunden genau ist. Es gibt viele Methoden, aber viele sind veraltet und werden nicht empfohlen. In den folgenden Methoden sind nicht veraltet:
Zusammenfassung der Konstruktionsmethoden
--------------------------
Datum()
Weisen Sie ein Datumsobjekt zu und initialisieren Sie dieses Objekt mit der aktuellen Zeit, um die Zeit anzugeben, in der es zugewiesen wurde (genau auf Millisekunden).
Datum (langes Datum)
Weisen Sie ein Datumsobjekt zu und initialisieren Sie dieses Objekt, um die angegebene Anzahl von Millisekunden seit der Standard -Benchmark -Zeit darzustellen ("Epoche", dh 00:00:00 GMT am 1. Januar 1970).
Methodenzusammenfassung
--------------------------
boolean nach (Datum wann)
Tests, ob dieses Datum nach dem angegebenen Datum erfolgt.
boolean vor (Datum wann)
Tests, ob dieses Datum vor dem angegebenen Datum liegt.
Objektklone ()
Gibt eine Kopie dieses Objekts zurück.
int vergleicheto (Datum eines anderenDate)
Vergleichen Sie die Reihenfolge von zwei Daten.
booleschen gleich (Objekt OBJ)
Vergleichen Sie die Gleichheit von zwei Daten.
lange Getzeit ()
Gibt die Anzahl der Millisekunden zurück, die bis zu diesem Datum Objekt seit dem 1. Januar 1970 00:00:00 GMT dargestellt werden.
int Hashcode ()
Gibt den Hash -Code -Wert dieses Objekts zurück.
Leere (lange Zeit)
Legen Sie dieses Datumsobjekt fest, um den Zeitpunkt der Zeit Millisekunden nach 00:00:00 GMT am 1. Januar 1970 darzustellen.
String toString ()
Konvertieren Sie dieses Datumsobjekt in Zeichenfolge der folgenden Form: dow mon dd hh: mm: ss zzz yyyy wo:
Dow ist ein Tag der Woche (Sonne, Mon, Di, Mi, Thu, Fr, Sa).
Mon ist der Monat (Jan, Februar, März, April, Juni, Juni, August, September, Oktober, November, Dezember).
DD ist ein Tag im Januar (01 bis 31), der als zweistellige Dezimalzahl angezeigt wird.
HH ist die Tagesstunde (00 bis 23), die als zweistellige Dezimalzahl angezeigt wird.
MM ist das Minuten (00 bis 59) in der Stunde und wird als zweistellige Dezimalzahl angezeigt.
SS ist die Anzahl der Sekunden (00 bis 61) in einer Minute, die als zweistellige Dezimalzahl angezeigt wird.
Zzz ist die Zeitzone (und spiegelt die Tagesrettungszeit wider). Die Standard -Zeitzone -Abkürzung umfasst die mit Methoden analysierte Zeitzone Abkürzung. Wenn keine Zeitzoneninformationen bereitgestellt werden, ist Zzz leer, d. H. Es sind überhaupt keine Zeichen enthalten.
Yjyy ist ein Jahr, das als 4-stellige Dezimalzahl angezeigt wird.
Hier ist ein umfassendes Beispiel für die Datumsklasse:
public class testDate {public static void main (String [] args) {TestDate testDate = new TestDate (); testDate.getSystemCurrentTime (); testDate.getCurrentDate (); } / *** Erhalten Sie die aktuelle Systemzeit* system Zeit---"); System.out.println (System.currentTimemillis ()); } public void getCurrentDate () {System.out.println ("--- Erhalten Sie die aktuelle Zeit des Systems ---"); // Erstellen und initialisieren Sie ein Datum (der Anfangswert ist das aktuelle Datum) Datum = neues Datum (); System.out.println ("Das aktuelle Datum ist =" + Datum.toString ()); System.out.println ("Die Anzahl der Millisekunden, die seit dem 1. Januar 1970 =" + Datum.getTime ()); }} 2. Verwendung von Java.Text.DateFormat Abstract -Klasse
DateFormat ist eine abstrakte Klasse von Unterklassen mit Datums-/Zeitformatierung, die Daten oder Zeiten auf sprachunabhängige Weise formatieren und analysieren. Datums-/Zeitformatierungsunterklassen (z. B. SimpleDateFormat) Ermöglichen Sie eine Formatierung (d. H. Datum-> Text), Analyse (Text-> Datum) und Standardisierung. Bezeichnen Sie das Datum als Datumsobjekt oder als Anzahl der Millisekunden ab dem Moment, in dem GMT (GMT) 1970, 1. Januar 00:00:00 Uhr.
DateFormat bietet eine Anzahl von Klassenmethoden, um das Standarddatum/die Zeitformaterin basierend auf Standard- oder angegebenem Gebietsschema und mehreren Formatierungsstilen zu erhalten. Formatstile umfassen Voll, lang, mittel und kurz. Weitere Details und Beispiele für die Verwendung dieser Stile finden Sie in der Methodenbeschreibung.
DateFormat hilft bei der Format- und Analyse von Daten für jedes Gebietsschema. Seit Monaten, Wochen und sogar Kalenderformaten (Mond- und Solarkalender) kann der Code für die Konventionen des Gebietsschemas völlig irrelevant sein.
Verwenden Sie eine statische Fabrikmethode, um ein Datum im aktuellen Gebietsschema zu formatieren:
mystring = dateFormat.getDateinstance (). Format (myDate);
Wenn Sie mehrere Daten formatieren, ist es effizienter, das Format zu erhalten und es mehrmals zu verwenden, damit das System nicht mehrmals Informationen über die Umweltsprache und nationale Vereinbarungen erhalten muss.
DateFormat df = dateFormat.getDateinstance (); für (int i = 0; i <mydate.length; ++ i) {output.println (df.format (mydate [i]) +";"); }
Um die Daten verschiedener Orte zu formatieren, geben Sie sie im Anruf von getDateinstance () an.
DateFormat df = DateFormat.getDatEnstance (DateFormat.long, Locale.France);
DateFormat kann auch zur Analyse verwendet werden.
mydate = df.parse (mystring);
Verwenden Sie GetDateinstance, um das Standarddatumformat für dieses Land zu erhalten. Einige andere statische Fabrikmethoden werden ebenfalls bereitgestellt. Verwenden Sie GetTimeInstance, um das Zeitformat für dieses Land zu erhalten. Verwenden Sie GetDatetimeInstance, um Datums- und Uhrzeitformate zu erhalten. Unterschiedliche Optionen können in diese Werksmethoden übergeben werden, um die Länge des Ergebnisses zu steuern (von kurz bis mittel bis lang bis lang). Das genaue Ergebnis hängt vom Gebietsschema ab, aber normalerweise:
Kurz ist eine Zahl vollständig, z. B. 12.13.52 oder 15:30 Uhr
Medium ist länger, wie am 12. Januar 1952
Lang ist länger, wie 12. Januar 1952 oder 15:30:32 Uhr
Full ist vollständig angegeben, wie am Dienstag, 12. April 1952 n. Chr. Oder 15:30:42 PST.
Wenn Sie möchten, können Sie die Zeitzone auch im Format festlegen. Wenn Sie die Formatierung oder Analyse mehr Kontrolle auferlegen möchten (oder dem Benutzer mehr Kontrolle geben können), können Sie versuchen, das aus der Fabrikmethode erhaltene DateFormat auf SimpleDateFormat zu gießen. Dies funktioniert für die meisten Länder; Denken Sie daran, es in Sonderformaten in einen Try -Block zu setzen.
Sie können auch die Analyse- und Formatierungsmethode mit Parseposition und Feldposition verwenden, um Teile eines Stringschritts Schritt für Schritt zu analysieren. Richten Sie ein bestimmtes Feld aus oder finden Sie heraus, wo die Zeichenfolge auf dem Bildschirm ausgewählt ist.
DateFormat ist nicht synchron. Es wird empfohlen, für jeden Thread unabhängige Formatinstanzen zu erstellen. Wenn mehrere Threads gleichzeitig auf ein Format zugreifen, muss es extern synchronisiert bleiben.
A.
SimpleDateFormat ist eine bestimmte Klasse, die die Daten formatiert und analysiert. Es ermöglicht das Formatieren (Datum-> Text), Analyse (Text-> Datum) und Normalisierung.
Mit SimpledateFormat können Sie einen beliebigen benutzerdefinierten Datum-Zeit-Format-Modus auswählen. Es wird jedoch weiterhin empfohlen, GetTimeInstance, GetDateinstance oder GetDatetimeInstance in DateFormat zu verwenden, um ein neues Datum-Zeit-Formatierer zu erstellen. Jede solche Klassenmethode kann ein im Standardformatmodus initialisiertes Datum/Uhrzeitformater zurückgeben. Das Formatmuster kann nach Bedarf mit der Methode für applyPattern geändert werden. Weitere Informationen zur Verwendung dieser Methoden finden Sie unter DateFormat.
Datums- und Uhrzeitmodus
Das Datums- und Uhrzeitformat wird in der Datums- und Zeitmusterzeichenfolge angegeben. In Datums- und Zeitmuster -Zeichenfolgen werden nicht geeignete Buchstaben 'a' bis 'z' und 'a' zu 'z' als Musterbuchstaben interpretiert, um Datums- oder Zeitzeichenfolge darzustellen. Der Text kann in einzelne Zitate (') eingeschlossen werden, um eine Erklärung zu vermeiden. "''" bedeutet einzelne Zitate. Alle anderen Charaktere werden nicht interpretiert; Sie werden einfach in die Ausgangszeichenfolge kopiert oder bei der Analyse an die Eingangszeichenfolge angepasst.
Weitere Referenzinformationen können die JDK -API -Dokumentation anzeigen. Hier ist ein umfassendes Beispiel:
public class testDateFormat {public static void main (String [] args) löst ParseException {testDateFormat tdf = new TestDateFormat () aus; tdf.dateFormat (); } /*** Testen Sie die SimpleDateFormat -Klasse* @throws ParseException* /public void dateFormat () löscht ParseException {// Datum Datum erstellen date = new Date (); // Erstellen Sie verschiedene Datumsformate DateFormat df1 = dateFormat.getInstance (); DateFormat df2 = new SimpledateFormat ("yyyy-MM-01 HH: MM: SS EE"); DateFormat df3 = dateFormat.getDatEnstance (DateFormat.full, Locale.china); // Erstellen Sie ein Datumsformat mit einer angegebenen Länge des angegebenen Landes. Die Länge ist unterschiedlich und die angezeigte Datumsintegrität ist ebenfalls unterschiedlich. DateFormat DF4 = NEU SimpledateFormat ("Yyyyyy Year Mm Monat DD Day HH Hour MM Minute SS Sekunden ee", Lokale.china); DateFormat df5 = new SimpledateFormat ("yyyy-mm-dd hh: mm: ss eeeeee", locale.us); DateFormat df6 = new SimpledateFormat ("yyyy-mm-dd"); // Ausgabedaten in verschiedenen Formaten System.out.println ("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- df3.Fachat (Datum)); DF5.FORMAT (Datum)); Datum Datum2 = df2.Parse ("2016-01-24 02:51:07 Sonntag"); Datum Datum 3 = df3.Parse ("2016-01-24"); Datum Datum4 = df4.Parse ("2016-01-24 02:51:18 Sonntag"); Datum Datum6 = df6.Parse ("2016-01-24"); System.out.println ("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- System.out.println (Datum2); 4.. Java.util.Calendar (abstrakte Klasse)
java.util.calendar ist eine abstrakte Klasse, eine abstrakte Darstellung der Systemzeit. Es bietet einige Methoden, um einen bestimmten Moment in eine Reihe von Kalenderfeldern wie Jahr, Monat, Day_of_month, Stunde usw. umzuwandeln, und bietet einige Methoden zum Manipulieren von Kalenderfeldern (z. B. das Datum der nächsten Woche). Der Augenblick kann als Millisekundenwert ausgedrückt werden, der der Versatz aus der Epoche ist (d. H. 00: 00: 00.000, GMT, 1. Januar 1970, GMT).
Wie bei anderen lokalempfindlichen Klassen bietet der Kalender eine Klassenmethode, um ein gemeinsames Objekt dieser Art zu erhalten. Die GetInstance -Methode von Calendar gibt ein Kalenderobjekt zurück, dessen Kalenderfelder bis zum aktuellen Datum und zum aktuellen Uhrzeit initialisiert wurden.
Eine Instanz des Kalenders ist eine abstrakte Darstellung der Systemzeit. Aus Kalenderinstanz können Sie Informationen wie Jahr, Monat, Tag, Woche, Monat und Monat kennen. Es gibt eine statische Methode, die (int x) in der Kalenderklasse erhalten wird. Durch diese Methode erhalten Sie einige Werte (Jahr, Monat, Tag, Woche, Monat usw.) Informationen über die relevante Instanz. Parameter X ist ein im Kalender definierter Renditewert.
Einige Fallen im Kalender können leicht fallen:
1. Die Woche des Kalenders beginnt am Sonntag mit einem konstanten Wert von 0.
2. Der Monat des Kalenders beginnt ab Januar mit einem konstanten Wert von 0.
3. Der erste Tag des Kalenders eines jeden Monats ist 1.
5. Java.util.gregoriancalendar (direkte Unterklasse des Kalenders)
Gregoriancalendar ist eine konkrete Kalenderunterklasse, die ein Standardkalendersystem bietet, das von den meisten Ländern der Welt verwendet wird. Verwendet in Verbindung mit der calender abstrakten Klasse.
Hier ist ein umfassendes Beispiel, um die Verwendung der Kalenderklasse zu sehen:
public class testcalendar {public static void main (String [] args) löst ParseException aus {TestCalendar testCalendar = new TestCalendar (); TestCalendar.TestCalendar (); TestCalendar.TestCalendar2 (); } public void testcalendar () {// So erstellen Sie Kalender Kalender Kalender NOW1 = CALENDAR.getInstance (); Kalender NOW2 = neuer Gregoriancalendar (); Kalender Now3 = New Gregoriancalendar (2016, 01, 24); Kalender NOW4 = NEU Gregoriancalendar (2016, 01, 24, 15, 55); // Trail: Der Monat des Kalenders beträgt 0 ~ 11 Kalender Now5 = neuer Gregoriancalendar (2016, 01, 24, 15, 55, 44); Kalender NOW6 = NEU Gregoriancalendar (Locale.us); Kalender NOW7 = NEU Gregoriancalendar (TimeZone.getTimeZone ("GMT-8: 00"); // Kalender Now2.Settime (neues Datum ()) festlegen; System.out.println (Now2); NOW2.Settimeinmillis (neues Datum (). GetTime ()); System.out.println (Now2); // Definieren Sie das chinesische Ausgangsformat des Datums und geben Sie das Datum SimpleDateFormat DF = New SimpledateFormat ("Yyjyy Year Mm Monat DD DAY HH HOST MM Minute SS Sekunden E", Laceale.china); System.out.println ("Holen Sie sich die chinesische Formatierung des Datums:" + df.format (now5.getTime ()); System.out.println (); System.out.println ("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- System; System.out.println (" Get Year: " + Now 5.get (Kalender.year). NOW5.GET (CALENDAR.MOND); NOW5.GET (CALENDAR.SECOND)); System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- "März", "April", "May", "June", "Juli", "August", "September", "Oktober", "November", "Dezember"}; System.out.println ("Now5 -Objekt ist:" + Monate [Now5.get (Kalender.month)]); } public void testCalendar2 () löst ParseException aus {// Erhalten Sie die maximale Anzahl von Tagen im aktuellen Monat Kalender cal = calender.getInstance (); int maxday = cal.getacualMaximum (Calendar.day_of_month); int mindday = cal.getActualminimum (Calendar.day_of_month); System.out.println (maxday); // Nehmen Sie den letzten Tag des Monats dateFormat Formatter3 = new SimpledateFormat ("yyyy-mm-"+maxagay); System.out.println (format3.Format (cal.getTime ())); // Nehmen Sie den letzten Tag des Monats dateFormat Formatter4 = new SimpledateFormat ("yyyy-mm-"+minday); System.out.println (Formatter4.Format (cal.getTime ())); // Die Anzahl der Tage zwischen zwei Datteln java.text.SimpledateFormat format = new Java.Text.SimpledateFormat ("yyyy-mm-dd") finden; 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 ("Anzahl der Tage Apart ="+Tag); // Datum vor einem Jahr java.text.format formatter5 = new java.text.SimpledateFormat ("yyyy-mm-dd"); java.util.date TodayDate = new java.util.date (); Long beforeTime = (TodayDate.getTime ()/1000) -60*60*24*365; Heutedate.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 ())); // Der Montag und Sonntag der aktuellen Woche SimpleDateFormat DateFormat = new SimpledateFormat ("yyyymmdd"); Gregoriancalendar Gregoriancalendar = New Gregoriancalendar (); int DayinWeek = Gregoriancalendar.get (Calendar.day_of_week); int offset = 0; if (DayinWeek == 1) {// Sonntag Offset = 6; } else {// Montag bis Samstag 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 ("Montag dieser Woche:" + sday); System.out.println ("Sonntag dieser Woche:" + eday); }}3. Zusammenfassung
Es gibt oft fünf Aspekte von Daten in Java:
1. Erschöpfungsdatum
2. Anzeige des Datumsformates
3. Date Conversion (hauptsächlich gegenseitige Konvertierung mit Saiten)
V.
5. Vergleich der Datumsgröße und Addition und Subtraktion von Daten.
Das obige ist die für Sie zusammengefasste Java -Datums- und Zeitnutzungsmethode. Ich hoffe, es wird für Ihr Lernen hilfreich sein.