Det finns olika sätt att jämföra Java -datum. Internt representeras ett datum som en (lång) tidpunkt - antalet millisekunder som har gått sedan 1 januari 1970. I Java är Date ett objekt, vilket innebär att det innehåller flera metoder för jämförelse. Varje metod för att jämföra två datum jämför i huvudsak datumens tider.
Steg
Metod 1 av 4: Använda comparTo
Steg 1. Använd CompareTo
Date implementes Comparable och så kan två datum jämföras direkt med metoden CompareTo. Om datumen är för samma tidpunkt returnerar metoden noll. Om datumet som jämförs före datumargumentet returneras ett värde mindre än noll. Om datumet som jämförs ligger efter datumargumentet returneras ett värde större än noll. Om datumen är lika returneras värdet 0.
Steg 2. Skapa datumobjekten
Du måste skapa varje datumobjekt innan du kan börja jämföra dem. Ett sätt att göra detta är att använda klassen SimpleDateFormat. Det möjliggör enkel inmatning av datumvärden i datumobjekt.
SimpleDateFormat sdf = new SimpleDateFormat ("åååå-MM-dd"); // För att deklarera värden i nya datumobjekt. använd samma datumformat när du skapar datum Date date1 = 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"); // date3 är 23 februari 1995
Steg 3. Jämför datumobjekten
Koden nedan visar dig varje fall - mindre än, lika med och större än.
date1.compareTo (date2); // date1 <date2, returnerar mindre än 0 date2.compareTo (date1); // date2> date1, returnerar större än 0 date1.compareTo (date3); // date1 = date3, så skrivs ut 0 till konsolen
Metod 2 av 4: Använda lika, efter och före
Steg 1. Använd lika, efter och före
Datum kan jämföras med lika, efter och före metoder. Om två datum är för samma tidpunkt kommer metoden för lika med att returnera sant. Exemplen använder tidigare skapade datum från metoden CompareTo.
Steg 2. Jämför med metoden före
Koden nedan visar ett sant och falskt fall. Om datum1 är före datum2, före avkastning sant. Om det inte är det, före returnerar falskt.
System.out.print (datum1.före (datum2)); // skriver ut äkta System.out.print (date2.before (date2)); // skriver ut falskt
Steg 3. Jämför med eftermetoden
Koden nedan visar ett sant och falskt fall. Om datum2 är efter datum1, efter avkastningen sant. Om det inte är det, efter returer falskt.
System.out.print (date2.after (date1)); // skriver ut true System.out.print (date1.after (date2)); // skriver ut falskt
Steg 4. Jämför med likvärdig metod
Koden nedan visar ett sant och falskt fall. Om datumen är lika, returnerar lika sann. Om de inte är det returnerar lika felaktiga.
System.out.print (date1.equals (date3)); // skriver ut true System.out.print (date1.equals (date2)); // skriver ut falskt
Metod 3 av 4: Använda kalenderklassen
Steg 1. Använd kalendern
Kalenderklassen har också jämförelseTo, lika med, efter och före metoder som fungerar på samma sätt som beskrivs ovan för datumklassen. Så om datuminformationen förvaras i en kalender behöver du inte extrahera datumet bara för att göra en jämförelse.
Steg 2. Skapa instanser av kalendern
För att använda kalendermetoderna behöver du några kalenderinstanser. Lyckligtvis kan du bara ta tiderna från de redan skapade datuminstanserna.
Kalender cal1 = Calendar.getInstance (); // deklarerar cal1 Kalender cal2 = Calendar.getInstance (); // deklarerar cal2 Kalender cal3 = Calendar.getInstance (); // deklarerar cal3 cal1.setTime (datum1); // tillämpar datum på cal1 cal2.setTime (datum2); cal3.setTime (datum3);
Steg 3. Jämför cal1 och cal2 med tidigare
Koden nedan ska skriva ut true eftersom cal1 är före cal2.
System.out.print (cal1.before (cal2)); // kommer att skriva ut true
Steg 4. Jämför cal1 och cal2 med after
Koden nedan ska skriva ut falsk eftersom cal1 är före cal2.
System.out.print (cal1.after (cal2)); // skriver ut falskt
Steg 5. Jämför cal1 och cal2 med lika
Koden nedan visar ett exempel på både ett sant och falskt fall. Villkoret beror på att kalenderinstanserna jämförs. Koden ska skriva ut "true" och sedan "false" på nästa rad.
System.out.println (cal1.equals (cal3)); // skriver ut true: cal1 == cal3 System.out.print (cal1.equals (cal2)); // skriver ut falskt: cal1! = cal2
Metod 4 av 4: Använda getTime
Steg 1. Använd getTime
Det är också möjligt att direkt jämföra tidpunkten för två datum, även om någon av de tidigare metoderna sannolikt kommer att vara mer läsbar och så att föredra. Detta blir en jämförelse av två primitiva datatyper, så det kan göras med "" och "==".
Steg 2. Skapa långtidens objekt
Innan du kan jämföra datum måste du skapa långa heltal med data från de tidigare skapade datumobjekten. Lyckligtvis kommer metoden getTime () att göra det mesta för dig.
long time1 = getTime (date1); // förklarar primitiv tid1 från datum1 lång tid2 = getTime (datum2); // förklarar primitiv tid2 från datum2
Steg 3. Gör en mindre än jämförelse
Använd symbolen mindre än (<) för att jämföra dessa två heltalsvärden. Eftersom tid1 är mindre än tid 2, bör det första meddelandet skrivas ut. Den andra satsen ingår för korrekt syntax.
if (time1 <time2) {System.out.println ("datum1 är före datum2"); // kommer att skriva ut sedan time1 <time2} annars {System.out.println ("datum1 är inte före datum2"); }
Steg 4. Gör en större jämförelse
Använd symbolen större än (>) för att jämföra dessa två heltalsvärden. Eftersom tid1 är större än tid 2, bör det första meddelandet skrivas ut. Den andra satsen ingår för korrekt syntax.
if (time2> time1) {System.out.println ("datum2 är efter datum1"); // kommer att skriva ut sedan time2> time1} annars {System.out.println ("datum2 är inte efter datum1"); }
Steg 5. Gör en likvärdig jämförelse
Använd symbolen för att kontrollera om det är lika (==) för att jämföra dessa två heltalsvärden för jämlikhet. Eftersom tid1 är lika med tid3, bör det första meddelandet skrivas ut. Om programmet kommer till annat -påståendet betyder det att tiderna inte är lika.
if (time1 == time2) {System.out.println ("datumen är lika"); } annat {System.out.println ("datumen är inte lika"); // kommer att skriva ut sedan time1! = time2}
