Gratis trinnvis instruksjoner 
Sammenlign datoer i java
Innhold
Det er flere måter å sammenligne datoer på i Java. Internt er en dato representert som et (langt) tidspunkt – antall millisekunder som har gått siden 1. januar 1970. I Java er date Date-objektet, som betyr at det inneholder flere metoder (metoder) for å sammenligne datoer. Enhver metode for å sammenligne to datoer vil i utgangspunktet sammenligne den medgåtte tiden for begge datoene.
Trinn
Metode 1 av 4: Bruke `compareTo`-kommandoen
1. Bruk compareTo. Dato implementerer sammenlignbar
2. Lag Dato-objektene. Du må opprette hvert datoobjekt før du kan sammenligne dem. En måte å gjøre dette på er å bruke SimpleDateFormat-klassen. Lar deg enkelt legge inn datoer i Dato-objekter.
SimpleDateFormat sdf = new SimpleDateFormat(`åååå-MM-dd`); //For å deklarere verdier i nye datoobjekter. Bruk samme datoformat når du oppretter datoer Datodatum1 = sdf.parse(`1995-02-23`); //dato1 er 23. februar 1995 Dato dato2 = sdf.parse(`2001-10-31`); //dato2 er 31. oktober 2001 Dato dato3 = sdf.parse(`1995-02-23`); //dato3 er 23. februar 1995
3. Sammenlign datoobjektene. Nedenfor viser hvert tilfelle – mindre enn, lik og større enn.
dato 1.sammenlignTil(dato2); //dato1 < dato2, mindre enn 0 dato2.sammenligneTil(dato1); //dato2 > dato1, returnerer større enn 0 dato1.sammenligneTil(dato3); //dato1 = dato3, returnerer 0
Metode 2 av 4: Bruke metodene «lik, etter og før»
1. Bruk like, etter og før. Datoer kan sammenlignes med metodene lik, etter og før. Hvis to datoer indikerer samme tid, vil lik-metoden returnere "true". Eksemplene bruker de tidligere opprettede datoene via compareTo-metoden.
2. Sammenlign med før-metoden. Koden nedenfor viser et tilfelle av sant og usant. Hvis dato1 er tidligere enn dato2, er resultatet sant. Hvis ikke, returnerer før falsk.
System.ute.print(dato1.før(dato2)); //print true System.ute.print(dato2.før(dato2)); //skriv ut usann
3. Sammenlign dette med etter-metoden. Koden nedenfor viser et tilfelle av sant og usant. Hvis dato2 er senere enn dato1, returnerer etter sann. Hvis ikke, returnerer falsk.
System.ute.print(dato2.after(date1));//print true System.ute.print(dato1.after(date2));//print false
4. Sammenlign med lik metoden. Koden nedenfor viser et tilfelle av sant og usant. Hvis datoene er like, returnerer equals sant. Hvis ikke, returnerer lik falsk.
System.ute.print(dato1.lik(dato3));//print true System.ute.print(dato1.lik(dato2));//skriv ut usann
Metode 3 av 4: Bruke Kalender-klassen
1. Bruk kalenderklassen. Kalender-klassen har også compareTo, equals, after og before-metoder, som fungerer på samme måte som beskrevet ovenfor for datoklassen. Så hvis datodataene 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 generert av Dato-forekomstene.
Kalenderanrop1 = Kalender.getInstance(); //declares cal1 Kalender cal2 = Kalender.getInstance(); //declares cal2 Kalender cal3 = Kalender.getInstance(); //erklærer cal3 cal1.setTime(dato1); //gjelder dato for cal1 cal2.setTime(dato2); cal3.setTime(dato3);
3. Sammenlign cal1 og cal2 med tidligere. Koden nedenfor returnerer sann fordi cal1 er før cal2.
System.ute.print(cal1.før(cal2)); //print true
4. Sammenlign cal1 og cal2 med etter. Koden nedenfor returnerer usann, fordi cal1 er før cal2.
System.ute.print(cal1.after(cal2)); //skriv ut usann
5. Sammenlign cal1 og cal2 ved å bruke lik. Koden nedenfor viser et eksempel på både sant og usant. Tilstanden avhenger av Kalender-forekomstene som sammenlignes. Koden nedenfor gir "true" og deretter "false" på neste linje.
System.ute.println(cal1.lik(cal3)); //print true: cal1 == cal3 System.ute.print(cal1.lik(cal2)); //print false: call1 != kal2
Metode 4 av 4: Bruke `getTime`-metoden
1. Bruk getTime. Det er også mulig å direkte sammenligne to tidspunkter, selv om noen av de foregående tilnærmingene sannsynligvis vil gi mer lesbare resultater og derfor foretrekkes. Dette er en sammenligning av to primitive datatyper, så kan gjøres med `<`, `>` og `==`.
2. Lag "langtidsobjekter". Før du kan sammenligne datoer, må du lage lange heltall fra dataene til de tidligere opprettede Dato-objektene. Heldigvis vil getTime()-metoden gjøre det meste av jobben for deg.
lang tid1 = getTid(dato1); //erklærer primitiv tid1 fra dato1 lang tid2 = getTime(dato2); //erklærer primitiv tid2 fra dato2
3. Bruk en "mindre enn"-ligning. Bruk et "mindre enn"-symbol (<) for å sammenligne disse to heltallsverdiene. Siden tid1 er mindre enn tid2, bør den første meldingen skrives ut på skjermen. else-setningen er inkludert for riktig syntaks.
if(tid1 < tid2){ System.ute.println(`dato1 er tidligere enn dato2`); //skriv ut fordi tid1 < time2 } else{ System.ute.println(`dato1 er senere enn eller lik dato2`); }4. Gjør en "større enn" sammenligning. Bruk større enn-symbolet (>) for å sammenligne disse to heltallene. Fordi tid1 er større enn tid2, skrives den første meldingen ut på skjermen. else-setningen er inkludert for korrekt syntaks.
if(tid2 > tid1){ System.ute.println(`dato2 kommer etter dato1`); // skriv ut fordi tid2 > time1} annet{ System.ute.println(`dato2 er tidligere enn eller lik dato1`); }5. Gjør en "lik" sammenligning. Bruk symbolet (==) for å sammenligne disse to heltallene. Siden tid1 er lik tid3, bør den første meldingen skrives ut. Hvis programmet kommer til else-setningen, betyr det at tidene ikke er like.
if(tid1 == tid2){ System.ute.println(`Datoene samsvarer`); } annet{ System.ute.println(`Datoene er ikke de samme`); //skriv ut fordi tid1 != tid2 }Artikler om emnet "Sammenlign datoer i java"
Оцените, пожалуйста статью
Populær
