Innhold

• Å trå
• Metode 1 av 4: Bruk kommandoen "CompareTo"
• Metode 2 av 4: Bruk av metodene "er lik, etter og før"
• Metode 3 av 4: Bruke kalenderklassen
• Metode 4 av 4: Bruke "getTime" -metoden

Det er flere måter å sammenligne datoer på Java. Internt er en dato representert som et (langt) tidspunkt - antall millisekunder som har gått siden 1. januar 1970. I Java er dato Date-objektet, noe som betyr at den inneholder flere metoder for å sammenligne datoer. Enhver metode for å sammenligne to datoer vil i utgangspunktet sammenligne tiden som har gått fra begge datoene.

Å trå

Metode 1 av 4: Bruk kommandoen "CompareTo"

1. Bruk CompareTo. Dato implementerer ComparableDate> og så kan to datoer sammenlignes direkte med hverandre ved hjelp av comparTo-metoden. Hvis datoene indikerer samme tidspunkt, vil metoden gi null. Hvis datoen som sammenlignes er før dataargumentet, vil en negativ verdi bli returnert. Hvis datoen som sammenlignes er en senere dato enn datoen for argumentet, vil en positiv verdi bli returnert. Hvis datoene er de samme, vil null bli returnert.
2. Lag Date-objektene. Du må opprette hvert datoobjekt før du kan begynne å sammenligne dem. En måte å gjøre dette på er å bruke SimpleDateFormat-klassen. Dette lar deg enkelt skrive inn datoer i Date-objekter.

   SimpleDateFormat sdf = ny SimpleDateFormat ("åååå-MM-dd"); // For å deklarere verdier i nye datoobjekter.Bruk samme datoformat når du oppretter 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 datoobjektene. Nedenfor vises hvert tilfelle - mindre enn, lik og større enn.

   date1.compareTo (date2); // date1 date2, less than 0 date2.compareTo (date1); // date2> date1, returnerer større enn 0 date1.compareTo (date3); // date1 = date3, returnerer 0

Metode 2 av 4: Bruk av metodene "er lik, etter og før"

1. Bruk lik, etter og før. Datoer kan sammenlignes med hverandre ved å bruke lik, etter og før metoder. Hvis to datoer indikerer samme tid, vil likemetoden returnere "sann". Eksemplene bruker de tidligere opprettede datoene via sammenligningsmetoden.
2. Sammenlign med metoden før. Koden nedenfor viser et tilfelle av sant og usant. Hvis dato1 er tidligere enn dato2, er resultatet sant. Hvis ikke, returnerer falske.

   System.out.print (date1.before (date2)); // skriv ut System.out.print (date2.before (date2)); // skriv ut falsk

3. Sammenlign dette med ettermetoden. Koden nedenfor viser et tilfelle av sant og usant. Hvis dato2 er senere enn dato1, etter returnerer sant. Hvis ikke, etter retur falsk.

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

4. Sammenlign med likemetoden. Koden nedenfor viser et tilfelle av sant og usant. Hvis datoene er de samme, tilsvarer retur sant. Hvis ikke, tilsvarer retur falsk.

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

Metode 3 av 4: Bruke kalenderklassen

1. Bruk Kalender-klassen. Kalenderklassen har også sammenligne-, lik-, etter- og før-metodene, som fungerer på samme måte som beskrevet ovenfor for dataklassen. Så hvis datadataene holdes i en kalender, er det ikke nødvendig å trekke ut "dato", bare for å sammenligne to datoer.
2. Opprett forekomst av kalender. For å bruke kalendermetodene trenger du noen kalenderforekomster. Heldigvis kan du bruke tiden som genereres av datoinstansene.

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

3. Sammenlign cal1 og cal2 ved hjelp av før. Koden nedenfor returnerer sann fordi cal1 er tidligere enn cal2.

   System.out.print (cal1.before (cal2)); // trykk sant

4. Sammenlign cal1 og cal2 ved å bruke etter. Koden nedenfor returnerer falsk, fordi cal1 er tidligere enn cal2.

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

5. Sammenlign cal1 og cal2 ved å bruke like. Koden nedenfor viser et eksempel på både sant og usant. Betingelsen avhenger av at kalenderforekomstene blir sammenlignet. Koden nedenfor returnerer "true" og deretter "false" på neste linje.

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

Metode 4 av 4: Bruke "getTime" -metoden

1. Bruk getTime. Det er også mulig å sammenligne to tidspunkter direkte, selv om noen av de ovennevnte tilnærmingene sannsynligvis vil gi mer lesbare resultater og derfor er foretrukket. Dette er en sammenligning av to primitive datatyper, så kan gjøres med "", ">" og "==".
2. Lag de "lange" objektene. Før du kan sammenligne datoer, må du opprette lange heltall fra dataene til de tidligere opprettet Date-objektene. Heldigvis vil getTime () -metoden gjøre det meste av jobben for deg.

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

3. Bruk en "mindre enn" ligning. Bruk et "mindre enn" symbol () for å sammenligne disse to heltallene. Siden tid1 er mindre enn tid2, bør den første meldingen skrives ut på skjermen. Den ellers uttalelsen er inkludert for riktig syntaks.

   hvis (tid1 tid2) {System.out.println ("dato1 er tidligere enn dato2"); // skriv ut fordi tid1 tid2} annet {System.out.println ("dato1 er senere enn eller lik dato2"); }

4. Gjør en "større enn" sammenligning. Bruk symbolet "større enn" (>) for å sammenligne disse to heltallene. Siden tid1 er større enn tid2, skrives den første meldingen ut på skjermen. Den andre uttalelsen er inkludert for riktig syntaks.

   hvis (tid2> tid1) {System.out.println ("dato2 kommer etter dato1"); // skriv ut fordi tid2> tid1} annet {System.out.println ("dato2 er tidligere enn eller lik dato1"); }

5. Gjør en "lik" sammenligning. Bruk symbolet (==) til å sammenligne disse to heltallene. Siden tid1 er lik tid3, bør den første meldingen skrives ut. Hvis programmet kommer til den andre uttalelsen, betyr det at tidene ikke er de samme.

   if (time1 == time2) {System.out.println ("Datoene er like"); } annet {System.out.println ("Datoene er ikke like"); // skriv ut fordi time1! = time2}