Gratis trin for trin instruktioner 
Sammenlign datoer i java
Indhold
Der er flere måder at sammenligne datoer på i 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 date Date-objektet, hvilket betyder, at det indeholder flere metoder (metoder) til at sammenligne datoer. Enhver metode til at sammenligne to datoer vil grundlæggende sammenligne den forløbne tid for begge datoer.
Trin
Metode 1 af 4: Brug af `compareTo`-kommandoen
1. Brug compareTo. Dato implementerer Sammenlignelig
2. Opret Dato-objekterne. Du bliver nødt til at oprette hvert datoobjekt, før du kan sammenligne dem. En måde at gøre dette på er at anvende klassen SimpleDateFormat. Giver dig mulighed for nemt at indtaste datoer i Dato-objekter.
SimpleDateFormat sdf = new SimpleDateFormat(`åååå-MM-dd`); //Til at deklarere værdier i nye datoobjekter. Brug samme datoformat, når du opretter 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 den 23. februar 1995
3. Sammenlign datoobjekterne. Nedenstående viser hvert tilfælde - mindre end, lig med og større end.
dato 1.sammenligneTil(dato2); //dato1 < dato2, mindre end 0 dato2.sammenligneTil(dato1); //dato2 > dato1, returnerer større end 0 dato1.sammenligneTil(dato3); //dato1 = dato3, returnerer 0
Metode 2 af 4: Brug af metoderne `lig med, efter og før`
1. Brug lige, efter og før. Datoer kan sammenlignes ved hjælp af lig-, efter- og før-metoderne. Hvis to datoer angiver samme tid, vil lig-metoden returnere `sand`. Eksemplerne bruger de tidligere oprettede datoer via compareTo-metoden.
2. Sammenlign med før-metoden. Koden nedenfor viser et tilfælde af sand og falsk. Hvis dato1 er tidligere end dato2, er resultatet sandt. Hvis ikke, før returnerer falsk.
System.ud.print(dato1.før(dato2)); //print true System.ud.print(dato2.før(dato2)); //print falsk
3. Sammenlign dette med efter-metoden. Koden nedenfor viser et tilfælde af sand og falsk. Hvis dato2 er senere end dato1, returnerer efter sand. Hvis ikke, returnerer efter falsk.
System.ud.print(dato2.after(date1));//print true System.ud.print(dato1.after(date2));//print false
4. Sammenlign ved hjælp af lig-metoden. Koden nedenfor viser et tilfælde af sand og falsk. Hvis datoerne er ens, returnerer lig sand. Hvis ikke, returnerer lig falsk.
System.ud.print(dato1.er lig med(dato3));//print true System.ud.print(dato1.er lig med(dato2));//udskriv falsk
Metode 3 af 4: Brug af klassen Kalender
1. Brug klassen Kalender. Kalender-klassen indeholder også compareTo, equals, after og before-metoder, som fungerer på samme måde som beskrevet ovenfor for datoklassen. Så hvis datodata opbevares i en kalender, er der ingen grund til at udtrække `dato` bare for at sammenligne to datoer.
2. Opret forekomst af kalender. For at bruge Kalender-metoderne skal du bruge nogle Kalender-forekomster. Heldigvis kan du bruge tiden som genereret af Dato-forekomsterne.
Kalenderopkald1 = Kalender.getInstance(); //declares cal1 Kalender cal2 = Kalender.getInstance(); //declares cal2 Kalender cal3 = Kalender.getInstance(); //erklærer cal3 cal1.setTime(dato1); //gælder dato på cal1 cal2.sætTid(dato2); cal3.setTime(dato3);
3. Sammenlign cal1 og cal2 ved at bruge før. Koden nedenfor returnerer sand, fordi cal1 er før cal2.
System.ud.print(cal1.før(cal2)); //print true
4. Sammenlign cal1 og cal2 med efter. Koden nedenfor returnerer falsk, fordi cal1 er før cal2.
System.ud.print(cal1.after(cal2)); //print falsk
5. Sammenlign cal1 og cal2 ved at bruge lig. Koden nedenfor viser et eksempel på både sand og falsk. Betingelsen afhænger af de kalenderforekomster, der sammenlignes. Koden nedenfor giver `sand` og derefter `falsk` på næste linje.
System.ud.println(cal1.er lig med (cal3)); //print true: cal1 == cal3 System.ud.print(cal1.er lig med (cal2)); //print false: call1 != cal2
Metode 4 af 4: Brug af `getTime`-metoden
1. Brug getTime. Det er også muligt direkte at sammenligne to tidspunkter, selvom enhver af de foregående tilgange sandsynligvis vil give 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` tid objekter. Før du kan sammenligne datoer, skal du oprette lange heltal fra dataene fra de tidligere oprettede Dato-objekter. Heldigvis vil getTime()-metoden gøre det meste af arbejdet for dig.
lang tid1 = getTime(dato1); //erklærer primitiv tid1 fra dato1 lang tid2 = getTime(dato2); //erklærer primitiv tid2 fra dato2
3. Brug en `mindre end`-ligning. Brug et "mindre end" symbol (<) for at sammenligne disse to heltalsværdier. Da tid1 er mindre end tid2, bør den første besked udskrives på skærmen. else-sætningen er inkluderet for den korrekte syntaks.
hvis (tid1 < tid2){ System.ud.println(`dato1 er tidligere end dato2`); //print fordi tid1 < time2 } else{ System.ud.println(`dato1 er senere end eller lig med dato2`); }4. Lav en `større end` sammenligning. Brug symbolet større end (>) for at sammenligne disse to heltal. Fordi tid1 er større end tid2, udskrives den første besked på skærmen. else-sætningen er inkluderet for korrekt syntaks.
hvis (tid2 > tid1){ System.ud.println(`dato2 kommer efter dato1`); // print fordi tid2 > time1} andet{ System.ud.println(`dato2 er tidligere end eller lig med dato1`); }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 else-sætningen, betyder det, at tiderne ikke er ens.
if(tid1 == tid2){ System.ud.println(`Datoerne matcher`); } andet{ System.ud.println(`Datoerne er ikke de samme`); //print fordi tid1 != tid2 }Artikler om emnet "Sammenlign datoer i java"
Оцените, пожалуйста статью
Populær
