Java– ს თარიღების შედარების სხვადასხვა გზა არსებობს. შინაგანად, თარიღი წარმოდგენილია როგორც დროის (გრძელი) მომენტი - მილიწამების რაოდენობა, რომელიც გავიდა 1970 წლის 1 იანვრიდან. ჯავაში თარიღი არის ობიექტი, რაც იმას ნიშნავს, რომ იგი მოიცავს შედარების მრავალ მეთოდს. ორი თარიღის შედარების ნებისმიერი მეთოდი არსებითად შეადარებს თარიღების დროს.
ნაბიჯები
მეთოდი 1 -დან 4 -დან: შედარებითTo- ს გამოყენება
ნაბიჯი 1. გამოიყენეთ compareTo
თარიღი ახორციელებს შესადარებელს და ასე რომ ორი თარიღი შეიძლება პირდაპირ შევადაროთ შედარების მეთოდს. თუ თარიღები მითითებულია დროის ერთსა და იმავე დროს, მეთოდი ბრუნდება ნულოვანი. თუ შედარების თარიღი თარიღის არგუმენტამდეა, ნულზე ნაკლები მნიშვნელობა უბრუნდება. თუ შედარების თარიღი არის თარიღის არგუმენტის შემდეგ, ნულზე მეტი მნიშვნელობა უბრუნდება. თუ თარიღები ტოლია, 0 მნიშვნელობა უბრუნდება.
ნაბიჯი 2. შექმენით თარიღის ობიექტები
თქვენ უნდა შექმნათ თითოეული თარიღის ობიექტი, სანამ დაიწყებთ მათ შედარებას. ამის ერთ -ერთი გზაა SimpleDateFormat კლასის გამოყენება. ეს საშუალებას გაძლევთ ადვილად შეიყვანოთ თარიღის მნიშვნელობები თარიღის ობიექტებში.
SimpleDateFormat sdf = ახალი SimpleDateFormat ("yyyy-MM-dd"); // ახალი თარიღის ობიექტებში მნიშვნელობების გამოცხადებისთვის. თარიღების შექმნისას გამოიყენეთ იგივე თარიღის ფორმატი Date date1 = sdf.parse ("1995-02-23"); // თარიღი 1 არის 1995 წლის 23 თებერვალი თარიღი თარიღი 2 = sdf.parse ("2001-10-31"); // თარიღი 2 არის 2001 წლის 31 ოქტომბერი თარიღი თარიღი 3 = sdf.parse ("1995-02-23"); // თარიღი 3 არის 1995 წლის 23 თებერვალი
ნაბიჯი 3. შეადარეთ თარიღის ობიექტები
ქვემოთ მოყვანილი კოდი გაჩვენებთ თითოეულ შემთხვევას - ნაკლები, თანაბარი და უფრო დიდი ვიდრე.
date1.compareTo (თარიღი 2); // date1 <date2, აბრუნებს 0 -ზე ნაკლებს date2.compareTo (date1); // date2> date1, აბრუნებს 0 -ზე მეტს date1.compareTo (date3); // თარიღი 1 = თარიღი 3, ასე დაბეჭდება 0 კონსოლზე
მეთოდი 2 -დან 4: თანაბარი, შემდეგ და ადრე გამოყენება
ნაბიჯი 1. გამოიყენეთ თანაბარი, შემდეგ და ადრე
თარიღები შეიძლება შევადაროთ ტოლებს, მეთოდების შემდგომ და ადრე. თუ ორი თარიღი ერთსა და იმავე დროს არის, ტოლობის მეთოდი დაბრუნდება ჭეშმარიტი. მაგალითები გამოიყენებს ადრე შექმნილ თარიღებს შედარებითTo მეთოდით.
ნაბიჯი 2. შეადარეთ წინა მეთოდის გამოყენებით
ქვემოთ მოყვანილი კოდი აჩვენებს ჭეშმარიტ და ცრუ შემთხვევას. თუ თარიღი 1 თარიღამდეა 2, მაშინ დაბრუნდება ჭეშმარიტი. თუ ეს ასე არ არის, ადრე დაბრუნდება false.
System.out.print (date1. ადრე (date2)); // ბეჭდავს ნამდვილ System.out.print (date2. ადრე (date2)); // ბეჭდავს ცრუ
ნაბიჯი 3. შეადარეთ შემდგომი მეთოდის გამოყენებით
ქვემოთ მოყვანილი კოდი აჩვენებს ჭეშმარიტ და მცდარ შემთხვევას. თუ თარიღი 2 არის თარიღის შემდეგ 1, მაშინ დაბრუნდება ჭეშმარიტი. თუ ეს ასე არ არის, დაბრუნების შემდეგ false.
System.out.print (date2.after (date1)); // ბეჭდავს ნამდვილ System.out.print (date1.after (date2)); // ბეჭდავს false
ნაბიჯი 4. შეადარეთ თანაბარი მეთოდის გამოყენებით
ქვემოთ მოყვანილი კოდი აჩვენებს ჭეშმარიტ და მცდარ შემთხვევას. თუ თარიღები თანაბარია, ტოლი ბრუნდება true. თუ ისინი არ არიან, ტოლია აბრუნებს ცრუ.
System.out.print (date1.equals (date3)); // ბეჭდავს ნამდვილ System.out.print (date1.equals (date2)); // ბეჭდავს false
მეთოდი 3 დან 4: კალენდარული კლასის გამოყენება
ნაბიჯი 1. გამოიყენეთ კალენდარი
კალენდარულ კლასს ასევე აქვს შედარება, უდრის, მეთოდების შემდგომ და ადრე, რომლებიც მუშაობს ისევე, როგორც ზემოთ აღწერილი თარიღის კლასისთვის. ასე რომ, თუ თარიღის ინფორმაცია კალენდარში ინახება, არ არის საჭირო თარიღის ამოღება მხოლოდ შედარების მიზნით.
ნაბიჯი 2. კალენდრის მაგალითების შექმნა
კალენდრის მეთოდების გამოსაყენებლად დაგჭირდებათ კალენდრის რამდენიმე შემთხვევა. საბედნიეროდ, თქვენ შეგიძლიათ უბრალოდ აითვისოთ დრო უკვე შექმნილი თარიღის შემთხვევებიდან.
კალენდარი cal1 = Calendar.getInstance (); // აცხადებს cal1 კალენდარს cal2 = Calendar.getInstance (); // აცხადებს cal2 კალენდარს cal3 = Calendar.getInstance (); // აცხადებს cal3 cal1.setTime (თარიღი 1); // ეხება თარიღს cal1 cal2.setTime (თარიღი 2); cal3.setTime (თარიღი 3);
ნაბიჯი 3. შეადარეთ cal1 და cal2 ადრე
ქვემოთ მოყვანილი კოდი უნდა იყოს დაბეჭდილი true რადგან cal1 არის cal2- მდე.
System.out.print (cal1. ადრე (cal2)); // დაიბეჭდება true
ნაბიჯი 4. შეადარეთ cal1 და cal2 გამოყენებით after
ქვემოთ მოყვანილი კოდი უნდა დაბეჭდოს მცდარი, რადგან cal1 არის cal2– მდე.
System.out.print (cal1. შემდეგ (cal2)); // ბეჭდავს ცრუ
ნაბიჯი 5. შეადარეთ cal1 და cal2 თანაბარი გამოყენებით
ქვემოთ მოყვანილი კოდი აჩვენებს როგორც ჭეშმარიტი, ასევე ყალბი შემთხვევის მაგალითს. მდგომარეობა დამოკიდებულია კალენდარული შემთხვევების შედარებაზე. კოდი უნდა დაბეჭდოს "ჭეშმარიტი", შემდეგ "ცრუ" მომდევნო სტრიქონზე.
System.out.println (cal1.equals (cal3)); // ბეჭდავს true: cal1 == cal3 System.out.print (cal1.equals (cal2)); // ბეჭდავს ცრუ: cal1! = cal2
მეთოდი 4 -დან 4 -დან: გამოიყენეთ getTime
ნაბიჯი 1. გამოიყენეთ getTime
ასევე შესაძლებელია უშუალოდ შევადაროთ ორი თარიღის დროის წერტილი, თუმცა ნებისმიერი წინა მიდგომა სავარაუდოდ უფრო წაკითხული და სასურველია. ეს იქნება ორი პრიმიტიული მონაცემთა ტიპის შედარება, ასე რომ ეს შეიძლება გაკეთდეს "" და "==".
ნაბიჯი 2. შექმენით დიდი ხნის ობიექტები
სანამ შეადარებთ თარიღებს, თქვენ უნდა შექმნათ გრძელი რიცხვები ადრე შექმნილი თარიღის ობიექტების მონაცემებით. საბედნიეროდ, getTime () მეთოდი შეასრულებს სამუშაოს უმეტესობას თქვენთვის.
long time1 = getTime (თარიღი 1); // აცხადებს პრიმიტიულ დროს 1 თარიღიდან 1 გრძელი დრო 2 = getTime (თარიღი 2); // აცხადებს პრიმიტიულ დროს 2 თარიღიდან 2
ნაბიჯი 3. გააკეთეთ შედარებით ნაკლები
გამოიყენეთ ნაკლები სიმბოლო (<) ამ ორი მთლიანი მნიშვნელობის შესადარებლად. ვინაიდან დრო 1 ნაკლებია დრო 2 -ზე, პირველი შეტყობინება უნდა დაიბეჭდოს. Else განცხადება შედის შესაბამისი სინტაქსისთვის.
if (time1 <time2) {System.out.println ("date1 is before date2"); // იბეჭდება დროიდან 1 <დრო 2} სხვა {System.out.println ("თარიღი 1 არ არის თარიღამდე 2"); }
ნაბიჯი 4. გააკეთეთ შედარებაზე მეტი
გამოიყენეთ მეტი ვიდრე სიმბოლო (>) ამ ორი მთლიანი მნიშვნელობის შესადარებლად. ვინაიდან დრო 1 მეტია დრო 2 -ზე, პირველი შეტყობინება უნდა დაიბეჭდოს. Else განცხადება შედის შესაბამისი სინტაქსისთვის.
if (time2> time1) {System.out.println ("date2 is after date1"); // იბეჭდება დროიდან 2> დრო 1} სხვა {System.out.println ("თარიღი 2 არ არის თარიღის შემდეგ 1"); }
ნაბიჯი 5. გააკეთეთ თანაბარი შედარება
გამოიყენეთ სიმბოლო, რომ შეამოწმოთ თანასწორობა (==) ამ ორი მთლიანი მნიშვნელობის შესადარებლად თანასწორობისთვის. ვინაიდან დრო 1 უდრის დროს 3, პირველი შეტყობინება უნდა დაიბეჭდოს. თუ პროგრამა სხვა განცხადებას მიაღწევს, ეს ნიშნავს, რომ დრო არ არის თანაბარი.
if (დრო 1 == დრო 2) {System.out.println ("თარიღები თანაბარია"); } else {System.out.println ("თარიღები არ არის თანაბარი"); // იბეჭდება დროიდან 1! = დრო 2}
