Inhalt

• Ze trëppelen
• Method 1 vu 4: Benotzt de Kommando "CompareTo"
• Method 2 vu 4: Mat de Methoden "Gläich, no a vir"
• Methode 3 vu 4: Benotzt d'Kalennerklass
• Method 4 vu 4: Mat der "getTime" Method

Et gi verschidde Weeër fir Datumen op Java ze vergläichen. Intern gëtt en Datum als (laange) Zäitpunkt duergestallt - d'Zuel vu Millisekonnen, déi zënter dem 1. Januar 1970 passéiert sinn. A Java ass den Datum den Dateobjekt, dat heescht datt et méi Methode enthält fir d'Deeg ze vergläichen. All Methode fir zwee Datumen ze vergläichen vergläicht am Fong déi vergaangen Zäit vu béiden Datumen.

Ze trëppelen

Method 1 vu 4: Benotzt de Kommando "CompareTo"

1. Benotzt CompareTo. Datum implementéiert ComparableDate> a sou kënnen zwee Datumen direkt matenee verglach ginn mat der CompareTo Method. Wann d'Datume de selwechte Moment an der Zäit uginn, gëtt d'Method null zréck. Wann den Datum dee verglach gëtt virum Datumargument ass, gëtt en negativen Wäert zréckginn. Wann den Datum dee verglach gëtt e spéideren Datum ass wéi dee vum Datumargument, da gëtt e positive Wäert zréckginn. Wann d'Datume sëlwecht sinn, gëtt eng Null zréckginn.
2. Erstellt d'Datum Objekter. Dir musst all Datum Objet erstellen ier Dir kënnt matenee vergläichen. Ee Wee fir dëst ze maachen ass d'SimpleDateFormat Klass z'applizéieren. Dëst erlaabt Iech ganz einfach Datumen an Date Objekter anzeginn.

   SimpleDateFormat sdf = nei SimpleDateFormat ("yyyy-MM-dd"); // Fir Wäerter an neien Datumobjekter ze deklaréieren.Benotzt datselwecht Datumformat wann Dir Datumen erstallt Date date1 = sdf.parse ("1995-02-23"); // date1 ass den 23. Februar 1995 Datum date2 = sdf.parse ("2001-10-31"); // date2 ass den 31. Oktober 2001 Datum date3 = sdf.parse ("1995-02-23"); // date3 ass den 23. Februar 1995

3. Vergläicht d'Datum Objekter. Déi ënnescht weist all Fall - manner wéi, gläich a méi grouss wéi.

   date1.compareTo (date2); // date1 date2, manner wéi 0 date2.compareTo (date1); // date2> date1, gëtt méi grouss wéi 0 date1.compareTo (date3); // Datum1 = Datum3, zréck 0

Method 2 vu 4: Mat de Methoden "Gläich, no a vir"

1. Benotzt gläichberechtegt, no a virdrun. Datumer kënne matenee verglach ginn mat de Gläicher, no a virum Methoden. Wann zwee Datumen déiselwecht Zäit uginn, gëtt déi gläich Method "richteg" zréck. D'Beispiller benotzen déi virdrun erstallt Datume via der CompareTo Method.
2. Vergläicht mat der Method virdrun. De Code hei ënnen weist e Fall vu richteg a falsch. Wann Date1 méi fréi wéi Date2 ass, ass d'Resultat wouer. Wann net, ier zréck falsch.

   System.out.print (date1.before (date2)); // Drécken richteg System.out.print (date2.before (date2)); // falsch drécken

3. Vergläicht dëst mat der After Method. De Code hei ënnen weist e Fall vu richteg a falsch. Wann Date2 méi spéit ass wéi Date1, da gëtt et richteg. Wann net, nom Retour falsch.

   System.out.print (Date2.after (Date1)); // Drécken richteg System.out.print (Date1.after (Date2)); // falsch drécken

4. Vergläicht mat der Gläichmethod. De Code hei ënnen weist e Fall vu richteg a falsch. Wann d'Datume déiselwecht sinn, ass Gläichwäerter richteg. Wann net, ass gläich zréck falsch.

   System.out.print (date1.equals (date3)); // print true System.out.print (date1.equals (date2)); // print falsch

Methode 3 vu 4: Benotzt d'Kalennerklass

1. Benotzt d'Kalenner Klass. D'Kalennerklass huet och de CompareTo, gläich, no a vir Methoden, déi op déiselwecht Manéier funktionnéieren wéi uewen beschriwwen fir d'Datumklass. Also wann d'Datendaten an engem Kalenner gehale ginn, brauch et keen "Datum" ze extrahieren, just fir zwee Datumen ze vergläichen.
2. Erstellt Instanz vum Kalenner. Fir d'Kalendermethoden ze benotzen braucht Dir e puer Kalennerinstanzen. Glécklecherweis kënnt Dir d'Zäit benotze wéi generéiert vun den Dateinstanzen.

   Kalenner cal1 = Calendar.getInstance (); // erkläert cal1 Kalenner cal2 = Calendar.getInstance (); // erkläert cal2 Kalenner cal3 = Calendar.getInstance (); // erkläert cal3 cal1.setTime (date1); // gëlt Datum op cal1 cal2.setTime (date2); cal3.setTime (Datum3);

3. Vergläicht cal1 a cal2 mat virdrun. De Code hei drënner gëtt richteg well cal1 éischter wéi cal2 ass.

   System.out.print (cal1.before (cal2)); // Drécken richteg

4. Vergläicht cal1 a cal2 mat after. De Code hei ënnendrënner falsch, well cal1 ass méi fréi wéi cal2.

   System.out.print (cal1.after (cal2)); // falsch drécken

5. Vergläicht cal1 a cal2 mat gläichen. De Code hei ënnen weist e Beispill vu richteg a falsch. D'Konditioun hänkt vun de Kalennerinstanzen of, déi verglach ginn. De Code hei drënner gëtt "richteg" an duerno "falsch" op der nächster Zeil.

   System.out.println (cal1.equals (cal3)); // Drécken richteg: cal1 == cal3 System.out.print (cal1.equals (cal2)); // falsch ausdrécken: cal1! = cal2

Method 4 vu 4: Mat der "getTime" Method

1. Benotzt getTime. Et ass och méiglech direkt zwee Zäitpunkte mateneen ze vergläichen, obschonn ee vun de genannten Approche méiglecherweis méi liesbar Resultater gëtt a gëtt also bevorzugt. Dëst ass e Verglach vun zwou primitiven Datentypen, also ka mat "", ">" a "==" gemaach ginn.
2. Erstellt déi "laang" Objeten. Ier Dir Datume vergläicht, musst Dir laang ganz Zuelen aus den Date vun de virdrun erstallt Date-Objekter erstellen. Glécklecherweis wäert d'Method getTime () de gréissten Deel vun der Aarbecht fir Iech maachen.

   laang time1 = getTime (date1); // erkläert primitiv Zäit1 vum Datum1 laang Zäit2 = getTime (Datum2); // erkläert primitiv Zäit2 vum Datum2

3. Benotzt eng "manner wéi" Equatioun. Benotzt e "manner wéi" Symbol () fir dës zwou ganz Wäerter ze vergläichen. Well time1 manner wéi time2 ass, soll deen éischte Message um Bildschierm gedréckt ginn. Déi aner Ausso ass fir déi richteg Syntax abegraff.

   wann (time1 time2) {System.out.println ("Date1 ass méi fréi wéi Date2"); // drécken well Zäit1 Zäit2} anescht {System.out.println ("Date1 ass méi spéit wéi oder gläich wéi Date2"); }

4. Maacht e "méi wéi" Verglach. Benotzt d'Symbol "méi grouss wéi" (>) fir dës zwou ganz Zuelen ze vergläichen. Well time1 méi grouss ass wéi time2, gëtt déi éischt Noriicht um Bildschierm gedréckt. Déi aner Ausso ass fir d'korrekt Syntax abegraff.

   wann (Zäit2> Zäit1) {System.out.println ("Datum2 kënnt nom Datum1"); // drécken well Zäit2> Zäit1} anescht {System.out.println ("Date2 ass méi fréi wéi oder gläich wéi Date1"); }

5. Maacht e "gläich" Verglach. Benotzt d'Symbol (==) fir dës zwou ganz Zuelen ze vergläichen. Zënter Zäit1 ass gläich wéi Zäit3, soll den éischte Message gedréckt ginn. Wann de Programm op déi aner Ausso kënnt, heescht et datt d'Zäite net déiselwecht sinn.

   wann (time1 == time2) {System.out.println ("D'Datume si gläich"); } soss {System.out.println ("D'Datumer sinn net gläich"); // drécken well Zäit1! = Zäit2}