Instrucțiuni gratuite pas cu pas 
Jämför datum i java
Det finns flera sätt att jämföra datum i Java. Internt representeras ett datum som en (lång) tidpunkt – antalet millisekunder som har gått sedan 1 januari 1970. I Java är date objektet Date, vilket betyder att det innehåller flera metoder (metoder) för att jämföra datum. Varje metod för att jämföra två datum kommer i princip att jämföra den förflutna tiden för båda datumen.
Steg
Metod 1 av 4: Använd kommandot `compareTo`
1. Använd compareTo. Datum implementerar Jämförbar
2. Skapa Date-objekten. Du måste skapa varje datumobjekt innan du kan jämföra dem. Ett sätt att göra detta är att använda klassen SimpleDateFormat. Låter dig enkelt ange datum i Date-objekt.
SimpleDateFormat sdf = new SimpleDateFormat(`åååå-MM-dd`); //För att deklarera värden i nya datumobjekt. Använd samma datumformat när du skapar datum. Datedatum1 = sdf.parse(`1995-02-23`); //datum1 är 23 februari 1995 Datum datum2 = sdf.parse(`2001-10-31`); //datum2 är 31 oktober 2001 Datum datum3 = sdf.parse(`1995-02-23`); //datum3 är 23 februari 1995
3. Jämför datumobjekten. Nedan visas varje fall – mindre än, lika med och större än.
datum 1.compareTo(datum2); //datum1 < datum2, mindre än 0 datum2.compareTo(datum1); //datum2 > datum1, returnerar större än 0 datum1.compareTo(datum3); //datum1 = datum3, returnerar 0
Metod 2 av 4: Använder metoderna "lika med, efter och före"
1. Använd lika, efter och före. Datum kan jämföras med metoderna lika, efter och före. Om två datum indikerar samma tid, returnerar lika-metoden "true". Exemplen använder de tidigare skapade datumen via compareTo-metoden.
2. Jämför med före-metoden. Koden nedan visar ett fall av sant och falskt. Om datum1 är tidigare än datum2 är resultatet sant. Om inte, returnerar innan falskt.
Systemet.ut.print(datum1.före(datum2)); //print true System.ut.print(datum2.före(datum2)); //skriv ut falskt
3. Jämför detta med eftermetoden. Koden nedan visar ett fall av sant och falskt. Om datum2 är senare än datum1, returnerar efter sant. Om inte, efter returnerar falskt.
Systemet.ut.print(datum2.after(date1));//print true System.ut.print(datum1.after(date2));//print false
4. Jämför med metoden lika. Koden nedan visar ett fall av sant och falskt. Om datumen är lika, returnerar equals sant. Om inte, returnerar lika falskt.
Systemet.ut.print(datum1.equals(date3));//print true System.ut.print(datum1.lika med(datum2));//skriv ut falskt
Metod 3 av 4: Använda klassen Kalender
1. Använd klassen Kalender. Klassen Kalender har också metoderna compareTo, equals, after och before, som fungerar på samma sätt som beskrivits ovan för datumklassen. Så om datumdata sparas i en kalender finns det inget behov av att extrahera "datum" bara för att jämföra två datum.
2. Skapa instans av kalender. För att använda kalendermetoderna behöver du några kalenderinstanser. Lyckligtvis kan du använda tiden som genereras av Date-instanserna.
Kalendersamtal1 = Kalender.getInstance(); //declares cal1 Kalender cal2 = Kalender.getInstance(); //declares cal2 Kalender cal3 = Kalender.getInstance(); //deklarerar cal3 cal1.setTime(datum1); //tillämpar datum på cal1 cal2.setTime(datum2); cal3.setTime(datum3);
3. Jämför cal1 och cal2 med tidigare. Koden nedan returnerar sant eftersom cal1 är före cal2.
Systemet.ut.print(cal1.före(cal2)); //skriv ut sant
4. Jämför cal1 och cal2 med efter. Koden nedan returnerar false, eftersom cal1 är före cal2.
Systemet.ut.print(cal1.after(cal2)); //skriv ut falskt
5. Jämför cal1 och cal2 med lika. Koden nedan visar ett exempel på både sant och falskt. Villkoret beror på vilka Kalender-instanser som jämförs. Koden nedan ger `true` och sedan `false` på nästa rad.
Systemet.ut.println(cal1.lika med (cal3)); //print true: cal1 == cal3 System.ut.print(cal1.lika med (cal2)); //print false: call1 != kal2
Metod 4 av 4: Använda `getTime`-metoden
1. Använd getTime. Det är också möjligt att direkt jämföra två tidpunkter, även om vilken som helst av de föregående tillvägagångssätten sannolikt kommer att ge mer läsbara resultat och därför är att föredra. Detta är en jämförelse av två primitiva datatyper, så kan göras med `<`, `>` och `==`.
2. Skapa de "långa" objekten. Innan du kan jämföra datum måste du skapa långa heltal från data från tidigare skapade Date-objekt. Lyckligtvis kommer metoden getTime() att göra det mesta av arbetet åt dig.
long time1 = getTime(date1); //deklarerar primitiv tid1 från datum1 lång tid2 = getTime(datum2); //deklarerar primitiv tid2 från datum2
3. Använd en "mindre än"-ekvation. Använd en "mindre än"-symbol (<) för att jämföra dessa två heltalsvärden. Eftersom tid1 är mindre än tid2 bör det första meddelandet skrivas ut på skärmen. else-satsen ingår för korrekt syntax.
om(tid1 < tid2){ System.ut.println(`datum1 är tidigare än datum2`); //skriv ut eftersom tid1 < time2 } else{ System.ut.println(`datum1 är senare än eller lika med datum2`); }4. Gör en "större än" jämförelse. Använd symbolen större än (>) för att jämföra dessa två heltal. Eftersom tid1 är längre än tid2 skrivs det första meddelandet ut på skärmen. else-satsen ingår för korrekt syntax.
if(tid2 > tid1){ System.ut.println(`datum2 kommer efter datum1`); // skriv ut eftersom tid2 > time1} else{ System.ut.println(`datum2 är tidigare än eller lika med datum1`); }5. Gör en "lika med" jämförelse. Använd symbolen (==) för att jämföra dessa två heltal. Eftersom tid1 är lika med tid3 bör det första meddelandet skrivas ut. Om programmet kommer till else-satsen betyder det att tiderna inte är lika.
if(tid1 == tid2){ System.ut.println(`Datumen matchar`); } annat{ System.ut.println(`Datumen är inte desamma`); //skriv ut eftersom tid1 != tid2 } "Jämför datum i java"
Оцените, пожалуйста статью
