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