Tartalom

• Lépni
• 1. módszer a 4-ből: Az "összehasonlít" parancs használata
• 2. módszer a 4-ből: A "egyenlő, után és előtt" módszerek használata
• 3/4 módszer: A Naptár osztály használata
• 4. Módszer a 4-ből: A "getTime" módszer használata

A Java dátumainak összehasonlítására többféle lehetőség van. Belsőleg a dátum (hosszú) időpontként jelenik meg - az ezredmásodpercek száma, amely eltelt 1970. január 1. óta. A Java-ban a dátum a Date objektum, ami azt jelenti, hogy többféle módszert tartalmaz a dátumok összehasonlítására. Bármely módszer két dátum összehasonlítására alapvetően mindkét dátum eltelt idejét fogja összehasonlítani.

Lépni

1. módszer a 4-ből: Az "összehasonlít" parancs használata

1. Használja a CompareTo elemet. A dátum megvalósítja a ComparableDate> elemet, így két dátum közvetlenül összehasonlítható egymással az összehasonlító módszerrel. Ha a dátumok ugyanazt az időpontot jelzik, akkor a módszer nullát ad vissza. Ha az összehasonlított dátum a dátum argumentum előtt van, akkor negatív értéket ad vissza. Ha az összehasonlított dátum későbbi, mint a dátum argumentum, akkor egy pozitív értéket adunk vissza. Ha a dátumok megegyeznek, akkor egy nullát adunk vissza.
2. Hozza létre a Dátum objektumokat. Az összehasonlítás megkezdése előtt minden dátumobjektumot létre kell hoznia. Ennek egyik módja a SimpleDateFormat osztály alkalmazása. Ez lehetővé teszi a dátumok egyszerű beírását a Dátum objektumokba.

   SimpleDateFormat sdf = új SimpleDateFormat ("éééé-hh-nn"); // Új dátum objektumok értékeinek deklarálásához.Használja ugyanazt a dátumformátumot a dátumok létrehozásakor. Date date1 = sdf.parse ("1995-02-23"); // dátum1 1995. február 23. dátum dátum2 = sdf.parse ("2001-10-31"); // dátum2 2001. október 31. dátum dátum3 = sdf.parse ("1995-02-23"); // date3 1995. február 23

3. Hasonlítsa össze a dátumobjektumokat. Az alábbiakban minden esetet bemutatunk - kisebb, egyenlő és nagyobb, mint.

   dátum1.compareTo (dátum2); // date1 date2, kevesebb, mint 0 date2.compareTo (date1); // dátum2> dátum1, nagyobb, mint 0 dátum1.compareTo (dátum3); // dátum1 = dátum3, 0-t ad vissza

2. módszer a 4-ből: A "egyenlő, után és előtt" módszerek használata

1. Használjon egyenlőt, után és előtt. A dátumokat összehasonlíthatjuk egymással az egyenlő, utána és előtti módszerekkel. Ha két dátum ugyanazt az időt jelzi, akkor az equals módszer "true" értéket ad vissza. A példák a korábban létrehozott dátumokat használják az összehasonlítás módszerrel.
2. Hasonlítsa össze az előző módszerrel. Az alábbi kód igaz és hamis esetet mutat. Ha a date1 korábbi, mint a date2, az eredmény igaz. Ha nem, akkor a false értéket adja vissza.

   System.out.print (date1.before (date2)); // print true System.out.print (date2.before (date2)); // hamis nyomtatás

3. Hasonlítsa ezt össze az after módszerrel. Az alábbi kód igaz és hamis esetet mutat. Ha a date2 későbbi, mint a date1, akkor a true után ad vissza. Ha nem, miután hamis értéket ad vissza.

   System.out.print (dátum2.after (dátum1)); // igaz nyomtatás System.out.print (dátum1.after (dátum2)); // hamis nyomtatás

4. Hasonlítsa össze az egyenlő módszerrel. Az alábbi kód igaz és hamis esetet mutat. Ha a dátumok megegyeznek, az equals értéke true. Ha nem, akkor az egyenlő hamis értékkel tér vissza.

   System.out.print (dátum1.egyenlő (dátum3)); // igaz nyomtatás System.out.print (dátum1.egyenlő (dátum2)); // hamis nyomtatás

3/4 módszer: A Naptár osztály használata

1. Használja a Naptár osztályt. A Naptár osztály rendelkezik az összehasonlítás, az egyenlő, utána és az előtte módszerrel is, amelyek ugyanúgy működnek, mint a fentiekben a dátumosztálynál leírtak. Tehát, ha a dátumadatokat naptárban őrzik, akkor nem kell kivonni a "dátumot", csak két dátumot kell összehasonlítani.
2. Hozzon létre egy példányt a Naptárból. A Naptár metódusainak használatához néhány Naptár-példányra van szükség. Szerencsére felhasználhatja a Dátum példányok által generált időt.

   Naptár cal1 = Naptár.getInstance (); // kijelenti cal1 Naptár cal2 = Calendar.getInstance (); // kijelenti cal2 Naptár cal3 = Calendar.getInstance (); // deklarálja cal3 cal1.setTime (dátum1); // dátumot alkalmaz a cal1 cal2.setTime (dátum2); cal3.setTime (dátum3);

3. Hasonlítsa össze a cal1 és a cal2 elemeket az előző használatával. Az alábbi kód igaz, mivel a cal1 korábbi, mint a cal2.

   System.out.print (cal1.before (cal2)); // print true

4. Hasonlítsa össze a cal1 és a cal2 paramétereket az after használatával. Az alábbi kód hamis értéket ad vissza, mert a cal1 korábbi, mint a cal2.

   System.out.print (cal1.after (cal2)); // hamis nyomtatás

5. Hasonlítsa össze a cal1 és a cal2 egyenlő értékeket. Az alábbi kód mind az igaz, mind a hamis példát mutatja. A feltétel az összehasonlított Naptár-példányoktól függ. Az alábbi kód "igaz", majd "hamis" értéket ad vissza a következő sorban.

   System.out.println (cal1.equals (cal3)); // print true: cal1 == cal3 System.out.print (cal1.equals (cal2)); // hamis nyomtatás: cal1! = cal2

4. Módszer a 4-ből: A "getTime" módszer használata

1. Használja a getTime alkalmazást. Két idõpont közvetlen összehasonlítása is lehetséges, bár a fenti megközelítések bármelyike ​​valószínûleg olvashatóbb eredményeket hoz, és ezért elõnyösebb. Ez két primitív adattípus összehasonlítása, így elvégezhető a "", ">" és a "==" karakterekkel.
2. Hozza létre a "hosszú" objektumokat. A dátumok összehasonlítása előtt hosszú egész számokat kell létrehoznia a korábban létrehozott Dátum objektumok adataiból. Szerencsére a getTime () metódus elvégzi az Ön munkájának nagy részét.

   hosszú idő1 = getTime (dátum1); // deklarálja a dátum primitív idejét1 hosszú idő2 = getTime (dátum2); // deklarálja a dátum2 primitív időpontját2

3. Használjon "kevesebb, mint" egyenletet. Használjon "kevesebb, mint" szimbólumot (), hogy összehasonlítsa ezt a két egész értéket. Mivel az time1 kevesebb, mint time2, az első üzenetet ki kell nyomtatni a képernyőre. Az else utasítás tartalmazza a helyes szintaxist.

   if (time1 time2) {System.out.println ("dátum1 korábbi, mint dátum2"); // nyomtat, mert time1 time2} else {System.out.println ("date1 későbbi vagy egyenlő, mint date2"); }

4. Végezzen "nagyobb, mint" összehasonlítást. Használja a "nagyobb, mint" szimbólumot (>) e két egész szám összehasonlításához. Mivel az 1. idő nagyobb, mint a 2. idő, az első üzenet kinyomtatásra kerül a képernyőn. Az else utasítás tartalmazza a helyes szintaxist.

   if (idő2> idő1) {System.out.println ("a dátum2 dátum után1 jön"); // nyomtat, mert time2> time1} else {System.out.println ("a date2 korábbi, vagy egyenlő a date1-vel"); }

5. Végezzen "egyenlő" összehasonlítást. Használja a (==) szimbólumot a két egész szám összehasonlításához. Mivel az 1. idő megegyezik a 3. idővel, az első üzenetet ki kell nyomtatni. Ha a program eljut az else utasításhoz, az azt jelenti, hogy az idők nem ugyanazok.

   if (time1 == time2) {System.out.println ("A dátumok megegyeznek"); } else {System.out.println ("A dátumok nem egyenlőek"); // nyomtat, mert time1! = time2}