A Java dátumok összehasonlításának különféle módjai vannak. Belsőleg a dátumot (hosszú) időpontban ábrázolják - az 1970. január 1. óta eltelt ezredmásodpercek számát. A Java -ban a Date egy objektum, ami azt jelenti, hogy több összehasonlítási módszert is tartalmaz. Bármely módszer két dátum összehasonlítására lényegében összehasonlítja a dátumokat.
Lépések
1. módszer a 4 -ből: Az összehasonlítás használata
1. lépés. Használja az összehasonlítót
A dátum végrehajtása Összehasonlítható, és így két dátum közvetlenül összehasonlítható az összehasonlító módszerrel. Ha a dátumok ugyanarra az időpontra vonatkoznak, a módszer nullát ad vissza. Ha az összehasonlított dátum a dátum argumentum előtt van, akkor a nulla értéknél kisebb érték kerül visszaadásra. Ha az összehasonlított dátum a dátum argumentum után van, akkor a nullánál nagyobb érték kerül visszaadásra. Ha a dátumok megegyeznek, akkor 0 értéket adunk vissza.
2. lépés. Hozza létre a dátum objektumokat
Az összehasonlítás megkezdése előtt létre kell hoznia minden dátumobjektumot. Ennek egyik módja a SimpleDateFormat osztály használata. Lehetővé teszi a dátumértékek egyszerű bevitelét a dátum objektumokba.
SimpleDateFormat sdf = új SimpleDateFormat ("yyyy-MM-dd"); // Értékek deklarálásához új dátum objektumokban. ugyanazt a dátumformátumot használja a dátumok létrehozásakor Dátum dátum1 = sdf.parse ("1995-02-23"); // a dátum1 1995. február 23. Dátum dátuma2 = sdf.parse ("2001-10-31"); // a dátum2 2001. október 31. Dátum dátuma3 = sdf.parse ("1995-02-23"); // a dátum3 1995. február 23
3. lépés Hasonlítsa össze a dátum objektumokat
Az alábbi kód minden esetet megmutat - kisebb, egyenlő és nagyobb, mint.
date1.compareTo (dátum2); // dátum1 <dátum2, kevesebb, mint 0 dátum2.compareTo (dátum1); // dátum2> dátum1, nagyobb, mint 0 date1.compareTo (dátum3); // dátum1 = dátum3, így 0 -t nyomtat a konzolra
2. módszer a 4 -ből: Egyenlők használata, utána és előtte
1. lépés. Használjon egyenlőt, utána és előtt
A dátumokat össze lehet hasonlítani az egyenlőkkel, a módszerek után és előtt. Ha két dátum ugyanarra az időpontra vonatkozik, akkor az egyenlő módszer igaz értéket ad vissza. A példák az összehasonlítás módszerből korábban létrehozott dátumokat fogják használni.
2. lépés. Hasonlítsa össze az előző módszerrel
Az alábbi kód igaz és hamis esetet mutat. Ha a dátum1 a dátum2 előtt van, az előtt igaz értéket ad vissza. Ha nem, akkor a hamis értéket adja vissza.
System.out.print (dátum1.előtte (dátum2)); // kinyomtatja a valódi System.out.print (dátum2.előtte (dátum2)); // hamisan nyomtat
3. lépés. Hasonlítsa össze az utólagos módszerrel
Az alábbi kód igaz és hamis esetet mutat. Ha a dátum2 a dátum1 utáni, akkor az igaz értéket adja vissza. Ha nem, akkor a visszatérés után hamis.
System.out.print (date2.after (date1)); // igaz nyomtatása System.out.print (date1.after (date2)); // hamis nyomtatás
4. lépés. Hasonlítsa össze az egyenlő módszerrel
Az alábbi kód igaz és hamis esetet mutat. Ha a dátumok egyenlők, akkor az egyenlő érték igaz értéket ad vissza. Ha nem, akkor az egyenlő hamis értéket ad vissza.
System.out.print (date1.equals (date3)); // igaz nyomtatás System.out.print (date1.equals (date2)); // hamis nyomtatás
3. módszer a 4 -ből: A naptár osztály használata
1. lépés. Használja a naptárat
A naptárosztály rendelkezik összehasonlító (ToTo), egyenlő, utána és előtt metódusokkal is, amelyek ugyanúgy működnek, mint a dátumosztálynál leírtak. Tehát ha a dátuminformációkat naptárban tárolják, akkor nincs szükség a dátum kivonására csak az összehasonlítás elvégzése érdekében.
2. lépés. Hozzon létre naptári példányokat
A Naptár módszerek használatához néhány naptári példányra lesz szüksége. Szerencsére csak megragadhatja az időt a már létrehozott dátumpéldányokból.
Naptár cal1 = Calendar.getInstance (); // deklarálja a cal1 naptárat cal2 = Calendar.getInstance (); // deklarálja a cal2 naptárat cal3 = Calendar.getInstance (); // deklarálja a cal3 cal1.setTime (dátum1); // dátumot alkalmaz a cal1 cal2.setTime (dátum2); cal3.setTime (dátum3);
Lépés 3. Hasonlítsa össze a cal1 és cal2 értékeket az előző használatával
Az alábbi kódnak igaznak kell lennie, mivel a cal1 a cal2 előtt van.
System.out.print (cal1.before (cal2)); // igaz lesz
Lépés 4. Hasonlítsa össze a cal1 és a cal2 értékeket a after használatával
Az alábbi kódnak hamisnak kell lennie, mivel a cal1 a cal2 előtt van.
System.out.print (cal1.after (cal2)); // hamisan nyomtat
5. lépés Hasonlítsa össze a cal1 és a cal2 egyenlőt
Az alábbi kód egy példát mutat igaz és hamis esetre. A feltétel függ az összehasonlított naptári példányoktól. A kódnak "igaz", majd "hamis" -t kell nyomtatnia a következő sorban.
System.out.println (cal1.equals (cal3)); // igaz nyomtatás: cal1 == cal3 System.out.print (cal1.equals (cal2)); // hamisan nyomtat: cal1! = cal2
4. módszer a 4 -ből: A getTime használata
1. lépés. Használja a getTime programot
Lehetőség van két dátum időpontjának közvetlen összehasonlítására is, bár a korábbi megközelítések bármelyike valószínűleg olvashatóbb és így előnyösebb. Ez két primitív adattípus összehasonlítása lesz, így a "" és a "==" segítségével is elvégezhető.
2. lépés. Hozzon létre hosszú időtartamú objektumokat
Mielőtt összehasonlíthatja a dátumokat, hosszú egész számokat kell létrehoznia a korábban létrehozott Dátum objektumok adataival. Szerencsére a getTime () módszer elvégzi a legtöbb munkát helyetted.
hosszú idő1 = getTime (dátum1); // deklarálja a primitív időt1 dátumtól1 hosszú idő2 = getTime (dátum2); // deklarálja a primitív időt2 dátumtól2
Lépés 3. Végezzen kisebb összehasonlítást
Használja a kevesebb, mint szimbólumot (<) e két egész érték összehasonlításához. Mivel az 1. idő kevesebb, mint a 2. idő, az első üzenetet ki kell nyomtatni. Az else utasítás a megfelelő szintaxis érdekében szerepel.
if (idő1 <idő2) {System.out.println ("dátum1 dátum előtt van"); // az idő1 óta fog nyomtatni <idő2} else {System.out.println ("dátum1 nem dátum előtt 2"); }
4. lépés: Végezzen nagyobbat, mint az összehasonlítás
Használja a nagyobb mint szimbólumot (>) e két egész érték összehasonlításához. Mivel az idő1 nagyobb, mint a 2 -es, az első üzenetet ki kell nyomtatni. Az else utasítás a megfelelő szintaxis érdekében szerepel.
if (time2> time1) {System.out.println ("dátum2 a dátum1 után"); // idő óta fog nyomtatni2> idő1} else {System.out.println ("dátum2 nem dátum1 után"); }
5. lépés. Végezzen egyenlő összehasonlítást
A szimbólum használatával ellenőrizze az egyenlőséget (==), és hasonlítsa össze a két egész szám egyenlőségét. Mivel az idő1 egyenlő az idővel3, az első üzenetet ki kell nyomtatni. Ha a program eljut az else utasításhoz, az azt jelenti, hogy az idő nem egyenlő.
if (time1 == time2) {System.out.println ("a dátumok egyenlők"); } else {System.out.println ("a dátumok nem egyenlők"); // idő óta fog nyomtatni! = time2}
