Java-Daten berechnen

Um die Zeit im Auge zu behalten, zählt Java die Anzahl der Millisekunden ab dem 1. Januar 1970. Dies bedeutet beispielsweise, dass der 2. Januar 1970 86.400.000 Millisekunden später begann. In ähnlicher Weise begann der 31. Dezember 1969 vor dem 1. Januar 1970 mit 86.400.000 Millisekunden. Die Java- DateKlasse verfolgt diese Millisekunden als longWert. Da longes sich um eine vorzeichenbehaftete Zahl handelt, können Daten vor und nach dem Beginn des 1. Januar 1970 ausgedrückt werden. Die größten positiven und negativen Werte, die durch das longGrundelement ausgedrückt werden können, können Daten vorwärts und rückwärts über 290.000.000 Jahre erzeugen, was den Zeitplänen der meisten Menschen entspricht.

Die Date-Klasse

Die Dateim java.utilPaket enthaltene Klasse kapselt einen longWert, der einen bestimmten Zeitpunkt darstellt. Ein nützlicher Konstruktor ist Date()das Erstellen eines DateObjekts, das die Zeit darstellt, zu der das Objekt erstellt wurde. Die getTime()Methode gibt den longWert eines DateObjekts zurück. Im folgenden Programm verwende ich den Date()Konstruktor, um ein Datum basierend auf dem Zeitpunkt der Programmausführung zu erstellen, und die getTime()Methode, um die Anzahl der Millisekunden zu ermitteln, die das Datum darstellt:

import java.util. *; public class Now {public statisch void main (String [] args) {Datum jetzt = neues Datum (); long nowLong = now.getTime (); System.out.println ("Wert ist" + nowLong); }}

Als ich dieses Programm ausführte, gab es mir einen Wert von 972.568.255.150. Eine schnelle Überprüfung mit meinem Taschenrechner bestätigt, dass sich diese Zahl zumindest im richtigen Bereich befindet: Es sind etwas weniger als 31 Jahre, was der richtigen Anzahl von Jahren zwischen dem 1. Januar 1970 und dem Tag entspricht, an dem ich diesen Artikel geschrieben habe. Während Computer von Zahlen wie dem oben genannten Wert leben können, zögern die meisten Menschen, Dinge wie "Wir sehen uns auf 996.321.998.346" zu sagen. Glücklicherweise bietet Java eine Möglichkeit, DateObjekte zu konvertieren Strings, die Datumsangaben auf traditionellere Weise darstellen. Die DateFormatim nächsten Abschnitt beschriebene Klasse kann Stringsmit Schnelligkeit erstellt werden.

Die DateFormat-Klasse

Ein Zweck der

DateFormat

Klasse ist zu erstellen

Strings

auf eine Weise, mit der Menschen leicht umgehen können. Aufgrund von Sprachunterschieden möchten jedoch nicht alle Menschen ein Datum genau gleich sehen. Jemand in Frankreich mag es vorziehen, "25. Dezember 2000" zu sehen, während jemand in den Vereinigten Staaten eher daran gewöhnt ist, "25. Dezember 2000" zu sehen. Wenn also eine Instanz von a

DateFormat

Wenn eine Klasse erstellt wird, enthält das Objekt Informationen zu dem bestimmten Format, in dem das Datum angezeigt werden soll. Um das Standardformat des Computers des Benutzers zu verwenden, können Sie das anwenden

getDateInstance

Methode auf folgende Weise, um die entsprechende zu erstellen

DateFormat

Objekt:

 DateFormat df = DateFormat.getDateInstance (); 

Die DateFormatKlasse befindet sich im java.textPaket.

In einen String konvertieren

DateMit der formatMethode können Sie ein Objekt in eine Zeichenfolge konvertieren . Dies wird im folgenden Demonstrationsprogramm gezeigt:

import java.util. *; import java.text. *; öffentliche Klasse NowString {public static void main (String [] args) {Datum jetzt = neues Datum (); DateFormat df = DateFormat.getDateInstance (); String s = df.format (jetzt); System.out.println ("Heute ist" + s); }}

Die getDateInstanceim obigen Code gezeigte Methode ohne Argumente erstellt ein Objekt im Standardformat oder -stil. Java bietet auch einige alternative Stile für Datumsangaben, die Sie überladen erhalten können getDateInstance(int style). DateFormatBietet der Einfachheit halber einige vorgefertigte Konstanten, die Sie als Argumente in der getDateInstanceMethode verwenden können. Einige Beispiele sind SHORT, MEDIUM, LONG, und FULL, die in dem Programm demonstriert unter:

import java.util. *; import java.text. *; öffentliche Klasse StyleDemo {public static void main (String [] args) {Datum jetzt = neues Datum (); DateFormat df = DateFormat.getDateInstance (); DateFormat df1 = DateFormat.getDateInstance (DateFormat.SHORT); DateFormat df2 = DateFormat.getDateInstance (DateFormat.MEDIUM); DateFormat df3 = DateFormat.getDateInstance (DateFormat.LONG); DateFormat df4 = DateFormat.getDateInstance (DateFormat.FULL); String s = df.format (jetzt); String s1 = df1.format (jetzt); String s2 = df2.format (jetzt); String s3 = df3.format (jetzt); String s4 = df4.format (jetzt); System.out.println ("(Standard) Heute ist" + s); System.out.println ("(KURZ) Heute ist" + s1); System.out.println ("(MEDIUM) Heute ist" + s2); System.out.println ("(LONG) Heute ist" + s3); System.out.println ("(FULL) Heute ist" + s4); }}

Dieses Programm gibt Folgendes aus:

(Standard) Heute ist der 8. November 2000 (KURZ) Heute ist der 08.11.00 (MITTEL) Heute ist der 8. November 2000 (LANG) Heute ist der 8. November 2000 (VOLL) Heute ist der Mittwoch, der 8. November 2000 

Das gleiche Programm zeigte diese Ausgabe an, nachdem es auf meinem Computer ausgeführt wurde und die regionalen Standardeinstellungen auf Schwedisch geändert wurden:

(Standard) Heute ist 2000-nov-08 (KURZ) Heute ist 2000-11-08 (MITTEL) Heute ist 2000-nov-08 (LANG) Heute ist der 8. November 2000 (VOLL) Heute ist der 8. November 2000 

Daraus können Sie ersehen, dass auf Schwedisch die Monate des Jahres nicht groß geschrieben werden (obwohl November noch November ist). Beachten Sie auch, dass die Versionen LONGund FULLauf Schwedisch identisch sind, während sie sich im amerikanischen Englisch unterscheiden. Darüber hinaus ist es interessant, dass das schwedische Wort für Mittwoch, onsdag , nicht in der FULLVersion enthalten ist, in der die englische FULLVersion den Namen des Tages enthält.

Beachten Sie, dass Sie die getDateInstanceMethode verwenden können, um die Sprache für a zu ändernDateFormatBeispiel; Im obigen Fall wurde dies jedoch auf einem Windows 98-Computer durchgeführt, indem die regionalen Einstellungen über die Systemsteuerung geändert wurden. Die Lehre hier ist, dass die regionale Standardeinstellung von Ort zu Ort variiert, was sowohl Vor- als auch Nachteile hat, die der Java-Programmierer kennen sollte. Ein Vorteil besteht darin, dass der Java-Programmierer eine einzelne Codezeile schreiben kann, um ein Datum anzuzeigen. Das Datum wird jedoch in zehn oder sogar Hunderten verschiedener Formen angezeigt, wenn das Programm auf Computern auf der ganzen Welt ausgeführt wird. Dies kann jedoch ein Nachteil sein, wenn der Programmierer nur ein Format wünscht - was beispielsweise in einem Programm vorzuziehen ist, das Text und Daten gemischt ausgibt. Wenn der Text in Englisch ist, wäre es inkonsistent, Daten in anderen Formaten wie Deutsch oder Spanisch zu haben. Wenn sich der Programmierer auf das regionale Standardformat verlässt,Das Datumsformat hängt von den regionalen Einstellungen des ausführenden Computers ab.

Analysieren eines Strings

Sie können die DateFormatKlasse auch verwenden , um DateObjekte aus a Stringüber die parse()Methode zu erstellen . Diese spezielle Methode kann einen ParseExceptionFehler auslösen, daher müssen Sie geeignete Fehlerbehandlungstechniken verwenden. Ein Beispielprogramm, das a Stringin a verwandelt, Dateist unten dargestellt:

import java.util. *; import java.text. *; öffentliche Klasse ParseExample {public static void main (String [] args) {String ds = "1. November 2000"; DateFormat df = DateFormat.getDateInstance (); try {Date d = df.parse (ds); } catch (ParseException e) {System.out.println ("Analyse nicht möglich" + ds); }}}

Die parse()Methode ist ein nützliches Werkzeug zum Erstellen beliebiger Daten. Ich werde einen anderen Weg untersuchen, um beliebige Daten zu erstellen. Außerdem erfahren Sie, wie Sie elementare Berechnungen mit Datumsangaben durchführen, z. B. das Datum 90 Tage nach einem anderen Datum berechnen. Sie können beide Aufgaben mit der GregorianCalendarKlasse ausführen .

Die GregorianCalendar-Klasse

Eine Möglichkeit, ein Objekt zu erstellen, das ein beliebiges Datum darstellt, besteht darin, den folgenden Konstruktor der GregorianCalendarKlasse zu verwenden, der im java.utilPaket enthalten ist:

 Gregorianischer Kalender (int Jahr, int Monat, int Datum) 

Note that for the month, January is 0, February is 1, and so on, until December, which is 11. Since those are not the numbers most of us associate with the months of the year, programs will probably be more readable if they use the constants of the parent Calendar class: JANUARY, FEBRUARY, and so on. So, to create an object representing the date that Wilbur and Orville Wright first flew their motored aircraft (December 17, 1903), you can use:

 GregorianCalendar firstFlight = new GregorianCalendar(1903, Calendar.DECEMBER, 17); 

For clarity's sake, you should use the preceding form. However, you should also learn how to read the shorter form, below. The following example represents the same December 17, 1903, date (remember, in the shorter form 11 represents December):

 GregorianCalendar firstFlight = new GregorianCalendar(1903, 11, 17); 

In the previous section, you learned how to turn Date objects into Strings. You will do the same again; but first, you need to convert a GregorianCalendar object to a Date. To do so, you will use the getTime() method, which GregorianCalendar inherits from its parent Calendar class. The getTime() method returns a Date corresponding to a GregorianCalendar object. You can put the whole process of creating a GregorianCalendar object, converting it to a Date, and getting and outputting the corresponding String in the following program:

 import java.util.*; import java.text.*; public class Flight { public static void main(String[] args) { GregorianCalendar firstFlight = new GregorianCalendar(1903, Calendar.DECEMBER, 17); Date d = firstFlight.getTime(); DateFormat df = DateFormat.getDateInstance(); String s = df.format(d); System.out.println("First flight was " + s); } } 

Sometimes it is useful to create an instance of the GregorianCalendar class representing the day the instance was created. To do so, simply use the GregorianCalendar constructor taking no arguments, such as:

 GregorianCalendar thisday = new GregorianCalendar(); 

A sample program to output today's date, starting with a GregorianCalendar object is:

 import java.util.*; import java.text.*; class Today { public static void main(String[] args) { GregorianCalendar thisday = new GregorianCalendar(); Date d = thisday.getTime(); DateFormat df = DateFormat.getDateInstance(); String s = df.format(d); System.out.println("Today is " + s); } } 

Note the similarities between the Date() constructor and the GregorianCalendar() constructor: both create an object, which in simple terms, represents today.

Date manipulation

The GregorianCalendar class offers methods for manipulating dates. One useful method is add(). With the add() method, you can add such time units as years, months, and days to a date. To use the add() method, you must supply the field being increased, and the integer amount by which it will increase. Some useful constants for the fields are DATE, MONTH, YEAR, and WEEK_OF_YEAR. The add() method is used in the program below to calculate a date 80 days in the future. Phileas Fogg, the central character in Jules Verne's Around the World in 80 Days, could have used such a program to calculate a date 80 days from his departure on October 2, 1872:

 import java.util.*; import java.text.*; public class World { public static void main(String[] args) { GregorianCalendar worldTour = new GregorianCalendar(1872, Calendar.OCTOBER, 2); worldTour.add(GregorianCalendar.DATE, 80); Date d = worldTour.getTime(); DateFormat df = DateFormat.getDateInstance(); String s = df.format(d); System.out.println("80 day trip will end " + s); } } 

While the example is a bit fanciful, adding days to a date is a common operation: video rentals can be due in 3 days, a library may lend books for 21 days, stores frequently require purchased items to be exchanged within 30 days. The following program shows a calculation using years:

 import java.util.*; import java.text.*; public class Mortgage { public static void main(String[] args) { GregorianCalendar mortgage = new GregorianCalendar(1997, Calendar.MAY, 18); mortgage.add(Calendar.YEAR, 15); Date d = mortgage.getTime(); DateFormat df = DateFormat.getDateInstance(); String s = df.format(d); System.out.println("15 year mortgage amortized on " + s); } } 

One important side effect of the add() method is that it changes the original date. Sometimes it is important to have both the original date and the modified date. Unfortunately, you cannot simply create a new GregorianCalendar object set equal to the original. The reason is that the two variables have a reference to one date. If the date is changed, both variables now refer to the changed date. Instead, a new object should be created. The following example will demonstrate this:

import java.util. *; import java.text. *; öffentliche Klasse ThreeDates {public static void main (String [] args) {GregorianCalendar gc1 = neuer GregorianCalendar (2000, Calendar.JANUARY, 1); GregorianCalendar gc2 = gc1; GregorianCalendar gc3 = neuer GregorianCalendar (2000, Calendar.JANUARY, 1); // Drei Daten, die alle dem 1. Januar 2000 entsprechen gc1.add (Calendar.YEAR, 1); // gc1 und gc2 werden geändert DateFormat df = DateFormat.getDateInstance (); Datum d1 = gc1.getTime (); Datum d2 = gc2.getTime (); Datum d3 = gc3.getTime (); String s1 = df.format (d1); String s2 = df.format (d2); String s3 = df.format (d3); System.out.println ("gc1 ist" + s1); System.out.println ("gc2 ist" + s2); System.out.println ("gc3 ist" + s3); }}