Indhold

• At træde
• Metode 1 af 4: Brug kommandoen "CompareTo"
• Metode 2 af 4: Brug af metoderne "er lig med, efter og før"
• Metode 3 af 4: Brug af kalenderklassen
• Metode 4 af 4: Brug af "getTime" -metoden

Der er flere måder at sammenligne datoer på Java. Internt er en dato repræsenteret som et (langt) tidspunkt - antallet af millisekunder, der er gået siden 1. januar 1970. I Java er dato datoobjektet, hvilket betyder, at det indeholder flere metoder til sammenligning af datoer. Enhver metode til sammenligning af to datoer sammenligner grundlæggende den forløbne tid for begge datoer.

At træde

Metode 1 af 4: Brug kommandoen "CompareTo"

1. Brug CompareTo. Dato implementerer ComparableDate> og så kan to datoer sammenlignes direkte med hinanden ved hjælp af CompareTo-metoden. Hvis datoerne angiver det samme tidspunkt, returnerer metoden nul. Hvis den dato, der sammenlignes, ligger før datogargumentet, returneres en negativ værdi. Hvis den dato, der sammenlignes, er en senere dato end datoen for argumentet om dato, returneres en positiv værdi. Hvis datoerne er de samme, returneres et nul.
2. Opret datoobjekterne. Du bliver nødt til at oprette hvert datoobjekt, før du kan begynde at sammenligne dem. En måde at gøre dette på er at anvende klassen SimpleDateFormat. Dette giver dig mulighed for nemt at indtaste datoer i datoobjekter.

   SimpleDateFormat sdf = ny SimpleDateFormat ("åååå-MM-dd"); // Til erklæring af værdier i nye datoobjekter.Brug det samme datoformat, når du opretter datoer Date date1 = sdf.parse ("1995-02-23"); // date1 er 23. februar 1995 Date date2 = sdf.parse ("2001-10-31"); // date2 er 31. oktober 2001 Date date3 = sdf.parse ("1995-02-23"); // date3 er 23. februar 1995

3. Sammenlign datoobjekterne. Nedenstående viser hvert tilfælde - mindre end, lig med og større end.

   date1.compareTo (date2); // dato1 dato2, mindre end 0 dato2.compareTo (dato1); // date2> date1, returnerer større end 0 date1.compareTo (date3); // date1 = date3, returnerer 0

Metode 2 af 4: Brug af metoderne "er lig med, efter og før"

1. Brug lig, efter og før. Datoer kan sammenlignes med hinanden ved hjælp af ligemetoden, efter og før metoder. Hvis to datoer angiver samme tid, returnerer ligemetoden "sand". Eksemplerne bruger de tidligere oprettede datoer via CompareTo-metoden.
2. Sammenlign ved hjælp af metoden før. Koden nedenfor viser et tilfælde af sand og falsk. Hvis dato1 er tidligere end dato2, er resultatet sandt. Hvis ikke, returnerer falsk før.

   System.out.print (date1.before (date2)); // udskriv sandt System.out.print (date2.before (date2)); // udskriv falsk

3. Sammenlign dette med eftermetoden. Koden nedenfor viser et tilfælde af sand og falsk. Hvis dato2 er senere end dato1, efter returnerer sand. Hvis ikke, efter returnering falsk.

   System.out.print (date2.after (date1)); // print true System.out.print (date1.after (date2)); // print false

4. Sammenlign ved hjælp af ligemetoden. Koden nedenfor viser et tilfælde af sand og falsk. Hvis datoerne er de samme, svarer returnerer til true. Hvis ikke, svarer lig returnerer falsk.

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

Metode 3 af 4: Brug af kalenderklassen

1. Brug klassen Kalender. Kalenderklassen har også sammenligningsmetoden, er lig med, efter og før-metoderne, som fungerer på samme måde som beskrevet ovenfor for dataklassen. Så hvis datadataene opbevares i en kalender, er der ikke behov for at udtrække "dato", bare for at sammenligne to datoer.
2. Opret forekomst af kalender. For at bruge kalendermetoderne har du brug for nogle kalenderforekomster. Heldigvis kan du bruge tiden som genereret af datoinstanserne.

   Kalender cal1 = Calendar.getInstance (); // erklærer cal1 Kalender cal2 = Calendar.getInstance (); // erklærer cal2 Kalender cal3 = Calendar.getInstance (); // erklærer cal3 cal1.setTime (date1); // anvender dato for cal1 cal2.setTime (date2); cal3.setTime (dato3);

3. Sammenlign cal1 og cal2 ved hjælp af før. Koden nedenfor returnerer sand, fordi cal1 er tidligere end cal2.

   System.out.print (cal1.before (cal2)); // print sandt

4. Sammenlign cal1 og cal2 ved hjælp af efter. Koden nedenfor returnerer falsk, fordi cal1 er tidligere end cal2.

   System.out.print (cal1.after (cal2)); // udskriv falsk

5. Sammenlign cal1 og cal2 ved hjælp af lig. Koden nedenfor viser et eksempel på både sand og falsk. Betingelsen afhænger af, hvilke kalenderforekomster der sammenlignes. Koden nedenfor returnerer "sand" og derefter "falsk" på den næste linje.

   System.out.println (cal1.equals (cal3)); // print true: cal1 == cal3 System.out.print (cal1.equals (cal2)); // print false: cal1! = cal2

Metode 4 af 4: Brug af "getTime" -metoden

1. Brug getTime. Det er også muligt direkte at sammenligne to tidspunkter, selvom en af ​​de foregående fremgangsmåder sandsynligvis giver mere læsbare resultater og derfor foretrækkes. Dette er en sammenligning af to primitive datatyper, så det kan gøres med "", ">" og "==".
2. Opret de "lange" objekter. Inden du kan sammenligne datoer, skal du oprette lange heltal ud fra dataene fra de tidligere oprettede datoobjekter. Heldigvis vil metoden getTime () gøre det meste af arbejdet for dig.

   lang tid1 = getTime (dato1); // erklærer primitiv tid1 af dato1 lang tid2 = getTime (dato2); // erklærer primitiv tid2 af dato2

3. Brug en "mindre end" ligning. Brug et "mindre end" symbol () til at sammenligne disse to heltal værdier. Da tid1 er mindre end tid2, skal den første besked udskrives på skærmen. Den ellers erklæring er inkluderet for den korrekte syntaks.

   hvis (tid1 tid2) {System.out.println ("dato1 er tidligere end dato2"); // print fordi time1 time2} ellers {System.out.println ("date1 er senere end eller lig med date2"); }

4. Lav en "større end" sammenligning. Brug symbolet "større end" (>) til at sammenligne disse to heltal. Da tid1 er større end tid2, udskrives den første besked på skærmen. Den ellers erklæring er inkluderet for korrekt syntaks.

   hvis (tid2> tid1) {System.out.println ("dato2 kommer efter dato1"); // print fordi time2> time1} ellers {System.out.println ("date2 er tidligere end eller lig med date1"); }

5. Lav en "lig med" sammenligning. Brug symbolet (==) til at sammenligne disse to heltal. Da tid1 er lig med tid3, skal den første besked udskrives. Hvis programmet kommer til den anden erklæring, betyder det, at tidspunkterne ikke er de samme.

   hvis (tid1 == tid2) {System.out.println ("Datoer er ens"); } andet {System.out.println ("Datoer er ikke ens"); // udskriv fordi tid1! = tid2}