Java- ի ծրագրավորման լեզվով երկու ամսաթվերը համեմատելու բազմաթիվ եղանակներ կան: Համակարգիչներում ամսաթիվը ներկայացված է մի թվով (տվյալների տիպը Երկար) ժամանակի միավորներով, այսինքն ՝ 1970 -ի հունվարի 1 -ից անցած միլիվայրկյանների թիվը: Java- ում Ամսաթիվը օբյեկտ է, ինչը նշանակում է, որ այն ունի համեմատություններ կատարելու մի քանի եղանակ: Երկու ամսաթվերը համեմատելու համար օգտագործվող ցանկացած մեթոդ էապես համեմատում է երկու ամսաթվերի ժամանակային միավորները:
Քայլ
Մեթոդ 1 -ը 4 -ից ՝ համեմատության կիրառումը
Քայլ 1. Օգտագործեք compareTo:
Ամսաթիվ օբյեկտը իրականացնում է Համեմատելի, այնպես որ 2 ամսաթվերը կարող են համեմատվել միմյանց հետ ուղղակիորեն compareTo մեթոդով: Եթե երկու ամսաթվերը ժամանակային միավորներում ունեն նույն թիվը, ապա մեթոդը զրո է վերադարձնում: Եթե երկրորդ ամսաթիվը փոքր է առաջինից, ապա զրոյից փոքր արժեք է վերադարձվում: Եթե երկրորդ ամսաթիվը առաջինից մեծ է, մեթոդը վերադարձնում է զրոյից մեծ արժեք: Եթե երկու ամսաթվերը նույնն են, ապա մեթոդը կվերադառնա անվավեր արժեք:
Քայլ 2. Ստեղծեք ամսաթվի բազմաթիվ օբյեկտներ:
Նախքան դրանք համեմատելը, դուք պետք է ստեղծեք ամսաթվի մի քանի օբյեկտ: Դա անելու ամենահեշտ ձևերից մեկը SimpleDateFormat դասի օգտագործումն է: Այս դասը հեշտացնում է մուտքագրված ամսաթվի արժեքը ամսաթվի օբյեկտի վերածելը:
SimpleDateFormat sdf = նոր SimpleDateFormat («yyyy-MM-dd»): Նոր «Օբյեկտի ամսաթիվ» արժեք հայտարարելու համար ամսաթիվը ստեղծելիս օգտագործեք նույն ամսաթվի ձևաչափը: Ամսաթիվ ամսաթիվ 1 = sdf.parse ("1995-02-23"); // ամսաթիվը ՝ 1995 թվականի փետրվարի 23-ը, ամսաթիվը ՝ 2 = sdf.parse («2001-10-31»); // date2 2001 թվականի հոկտեմբերի 31, ամսաթիվ 3, sdf.parse («1995-02-23»); // ամսաթիվ 3 -ը 1995 թվականի փետրվարի 23 -ն է
Քայլ 3. Համեմատեք Date օբյեկտները:
Հետևյալ ծածկագիրը ձեզ ցույց կտա յուրաքանչյուր դեպքի օրինակներ `փոքրից, հավասարից և մեծից:
date1.compareTo (date2); // date1 <date2, վերադարձնում է 0 -ից պակաս արժեք date2.compareTo (date1); // date2> date1, վերադարձնում է 0 -ից մեծ արժեք 1 date.com.compareTo (date3); // date1 = date3, այնպես որ այն 0 -ով դուրս կգա վահանակի վրա
Մեթոդ 2 4 -ից. Հավասարների օգտագործումը, հետո և առաջ
Քայլ 1. Օգտագործեք հավասարները ՝ հետո և առաջ:
Ամսաթվերը կարելի է համեմատել ՝ օգտագործելով հավասարները, հետո և դրանից առաջ: Եթե երկու ամսաթվերը նույն արժեքն ունեն ժամանակի ընթացքում, ապա հավասարման մեթոդը վերադառնում է ճշմարիտ: Ստորև բերված օրինակը կօգտագործի DateT օբյեկտը, որը ստեղծվել է համեմատության մեթոդի օրինակով:
Քայլ 2. Համեմատեք նախորդ մեթոդի հետ:
Հետևյալ ծածկագիրը ցույց է տալիս դեպքի օրինակ, որը վերադարձնում է ճշմարիտ և կեղծ: Եթե date1- ը ամսաթվից առաջ ամսաթիվ է, ապա նախորդ մեթոդը ճիշտ է դառնում: Հակառակ դեպքում, նախորդ մեթոդը վերադարձնում է կեղծ:
System.out.print (date1.before (date2)); // ցուցադրել «true» արժեքը `System.out.print (date2.before (date2)); // վերադարձնել «կեղծ» արժեքը
Քայլ 3. Համեմատեք ՝ օգտագործելով after մեթոդ:
Հետևյալ ծածկագիրը ցույց է տալիս դեպքի օրինակ, որը վերադարձնում է ճշմարիտ և կեղծ: Եթե date2- ը ամսաթվից հետո ամսաթիվ է, ապա մեթոդը ճիշտ է դառնում: Հակառակ դեպքում, after մեթոդը կվերադառնա false:
System.out.print (date2.after (date1)); // ցուցադրել արժեքը «true» System.out.print (date1.after (date2)); // ցուցադրել «false» արժեքը
Քայլ 4. Համեմատեք հավասարների մեթոդի հետ:
Հետևյալ ծածկագիրը ցույց է տալիս դեպքի օրինակ, որը վերադարձնում է ճշմարիտ և կեղծ: Եթե երկու ամսաթվերը հավասար են, ապա հավասարման մեթոդը վերադառնում է ճշմարիտ: Հակառակ դեպքում, հավասարման մեթոդը վերադարձնում է կեղծ:
System.out.print (date1.equals (date3)); // ցուցադրել «true» արժեքը System.out.print (date1.equals (date2)); // ցուցադրել «false» արժեքը
Մեթոդ 3 4 -ից. Օգտագործելով դասի օրացույցը
Քայլ 1. Օգտագործեք Class Calendar- ը:
Օրացույցի դասը ունի նաև համեմատման, հավասարման, հետո և առաջվա մեթոդներ, որոնք աշխատում են նույնը, ինչ ավելի վաղ նկարագրված էին Ամսաթիվ դասի համար: Այսպիսով, եթե ամսաթվի մասին տեղեկությունները պահվում են դասի օրացույցում, ապա պետք չէ ամսաթիվը հանել միայն համեմատություն կատարելու համար:
Քայլ 2. Ստեղծեք Օրացույցի օրինակ:
Դասի օրացույցում մեթոդներ օգտագործելու համար դուք պետք է ստեղծեք Օրացույցի մի քանի օրինակ: Բարեբախտաբար, կարող եք օգտագործել նախկինում ստեղծված Date օրինակի արժեքները:
Օրացույց 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)); // կվերադարձնի «ճշմարիտ» արժեքը
Քայլ 4. Համեմատեք cal1- ը և cal2- ը ՝ օգտագործելով after մեթոդ:
Հետևյալ կոդը կվերադառնա կեղծ, քանի որ cal1- ը cal2- ից առաջ ամսաթիվ է:
System.out.print (cal1.after (cal2)); // վերադարձնել «կեղծ» արժեքը
Քայլ 5. Համեմատեք cal1- ը և cal2- ը `օգտագործելով equals մեթոդը:
Հետևյալ ծածկագիրը ցույց կտա դեպքի օրինակ, որը վերադարձնում է ճշմարիտ և կեղծ: Իրավիճակը կախված է Օրացույցի օրինակից, որը համեմատվում է: Հետևյալ կոդը հաջորդ տողում կվերադարձնի «ճշմարիտ» արժեքը, այնուհետև «կեղծ»:
System.out.println (cal1.equals (cal3)); // վերադարձնել «ճշմարիտ» արժեքը. cal1 == cal3 System.out.print (cal1.equals (cal2)); // վերադարձնել «կեղծ» արժեքը. cal1! = cal2
Մեթոդ 4 -ից 4 -ը ՝ օգտագործելով getTime
Քայլ 1. Օգտագործեք getTime- ը:
Կարող եք նաև ուղղակիորեն համեմատել երկու ամսաթվերի ժամանակային միավորի արժեքները, չնայած նախորդ երկու մեթոդները կարող են ավելի հեշտ ընթերցվել և նախընտրելի լինել: Այս կերպ դուք կհամեմատեք տվյալների 2 պարզունակ տեսակներ, այնպես որ կարող եք օգտագործել «» և «==» օպերանդները:
Քայլ 2. Ստեղծեք ժամանակի օբյեկտ Երկար թվերի ձևաչափով:
Նախքան ամսաթվերը համեմատելը, դուք պետք է ստեղծեք Long Integer արժեք նախկինում ստեղծված Date օբյեկտից: Բարեբախտաբար, getTime () մեթոդը դա կանի ձեզ համար:
երկար ժամանակ 1 = getTime (ամսաթիվ 1); // հայտարարել պարզունակ ժամանակ 1 ամսաթվի 1 երկար ժամանակ 2 = getTime (ամսաթիվ 2); // հայտարարեք պարզունակ ժամանակի 2 ամսաթվի արժեքը
Քայլ 3. Կատարեք համեմատությունից ավելի քիչ:
Այս երկու ամբողջ արժեքները համեմատելու համար օգտագործեք (<) -ից պակաս օպերանդ: Քանի որ time1- ը փոքր է time2- ից, առաջին հաղորդագրությունը կհայտնվի: Այլ հայտարարությունը ներառված է շարահյուսությունը լրացնելու համար:
if (time1 <time2) {System.out.println ("date1 ամսաթիվը ամսաթվից առաջ 2 է"); // կցուցադրվի, քանի որ time1 <time2} else {System.out.println ("date1 ամսաթիվը ամսաթվից առաջ ամսաթիվ չէ 2"); }
Քայլ 4. Կատարեք համեմատությունից ավելի մեծ:
Այս երկու ամբողջ արժեքները համեմատելու համար օգտագործեք ավելի մեծ (>) օպերանդ: Քանի որ time1- ն ավելի մեծ է քան time2- ը, առաջին հաղորդագրությունը կհայտնվի: Այլ հայտարարությունը ներառված է շարահյուսությունը լրացնելու համար:
if (time2> time1) {System.out.println («date2 ամսաթիվն է ամսաթվից հետո 1»); // կցուցադրվի, քանի որ time2> time1} else {System.out.println ("date2 ամսաթիվը ամսաթվից հետո ամսաթիվ չէ"); }
Քայլ 5. Կատարեք հավասար համեմատություն:
Օպերանդի գործառույթը ստուգելու համար արժեքների հավասարությունը (==) `այս երկու ամբողջ թվերը համեմատելու համար: Քանի որ ժամանակը 1 հավասար է ժամանակի 3 -ին, առաջին հաղորդագրությունը կհայտնվի: Եթե ծրագրի հոսքը մտնում է else հայտարարության մեջ, նշանակում է, որ երկու անգամները չունեն նույն արժեքը:
if (time1 == time2) {System.out.println («երկու ամսաթվերը նույնն են»); } else {System.out.println («1 -ինը նույնը չէ, ինչ 2 -րդը»); // կցուցադրվի, քանի որ ժամանակը 1! = ժամանակ 2}
