విషయము

• అడుగు పెట్టడానికి
• 4 యొక్క విధానం 1: "పోల్చండి" ఆదేశాన్ని ఉపయోగించడం
• 4 యొక్క పద్ధతి 2: "సమానం, తరువాత మరియు ముందు" పద్ధతులను ఉపయోగించడం
• 4 యొక్క విధానం 3: క్యాలెండర్ తరగతిని ఉపయోగించడం
• 4 యొక్క 4 వ పద్ధతి: "getTime" పద్ధతిని ఉపయోగించడం

జావాలో తేదీలను పోల్చడానికి అనేక మార్గాలు ఉన్నాయి. అంతర్గతంగా, తేదీని సమయం (దీర్ఘ) బిందువుగా సూచిస్తారు - జనవరి 1, 1970 నుండి గడిచిన మిల్లీసెకన్ల సంఖ్య. జావాలో, తేదీ తేదీ వస్తువు, అంటే తేదీలను పోల్చడానికి బహుళ పద్ధతులు ఉన్నాయి. రెండు తేదీలను పోల్చే ఏదైనా పద్ధతి ప్రాథమికంగా రెండు తేదీల గడిచిన సమయాన్ని పోల్చి చూస్తుంది.

అడుగు పెట్టడానికి

4 యొక్క విధానం 1: "పోల్చండి" ఆదేశాన్ని ఉపయోగించడం

1. పోల్చడానికి ఉపయోగించండి. తేదీ పోల్చదగిన తేదీ> ను అమలు చేస్తుంది మరియు అందువల్ల రెండు తేదీలను నేరుగా ఒకదానితో ఒకటి పోల్చవచ్చు. తేదీలు ఒకే క్షణాన్ని సమయానికి సూచిస్తే, పద్ధతి సున్నాకి తిరిగి వస్తుంది. పోల్చిన తేదీ తేదీ వాదనకు ముందు ఉంటే, అప్పుడు ప్రతికూల విలువ తిరిగి ఇవ్వబడుతుంది. తేదీ పోల్చిన తేదీ తేదీ వాదన కంటే తరువాతి తేదీ అయితే, సానుకూల విలువ తిరిగి ఇవ్వబడుతుంది. తేదీలు ఒకేలా ఉంటే, సున్నా తిరిగి ఇవ్వబడుతుంది.
2. తేదీ వస్తువులను సృష్టించండి. మీరు ప్రతి తేదీ వస్తువును పోల్చడం ప్రారంభించడానికి ముందు వాటిని సృష్టించాలి. దీనికి ఒక మార్గం సింపుల్‌డేట్ ఫార్మాట్ క్లాస్‌ని వర్తింపచేయడం. తేదీ వస్తువులలో తేదీలను సులభంగా నమోదు చేయడానికి ఇది మిమ్మల్ని అనుమతిస్తుంది.

   సింపుల్‌డేట్‌ఫార్మాట్ sdf = కొత్త సింపుల్‌డేట్ ఫార్మాట్ ("yyyy-MM-dd"); // క్రొత్త తేదీ వస్తువులలో విలువలను ప్రకటించడానికి.తేదీలను సృష్టించేటప్పుడు అదే తేదీ ఆకృతిని ఉపయోగించండి తేదీ date1 = sdf.parse ("1995-02-23"); // తేదీ 1 ఫిబ్రవరి 23, 1995 తేదీ తేదీ 2 = sdf.parse ("2001-10-31"); // తేదీ 2 అక్టోబర్ 31, 2001 తేదీ తేదీ 3 = sdf.parse ("1995-02-23"); // తేదీ 3 ఫిబ్రవరి 23, 1995

3. తేదీ వస్తువులను పోల్చండి. క్రింద ప్రతి కేసును చూపిస్తుంది - కన్నా తక్కువ, సమానం మరియు అంతకంటే ఎక్కువ.

   date1.compareTo (తేదీ 2); // date1 date2, 0 date2.compareTo (date1) కన్నా తక్కువ; // date2> date1, 0 date1.compareTo (date3) కన్నా ఎక్కువ రాబడి; // date1 = date3, రిటర్న్స్ 0

4 యొక్క పద్ధతి 2: "సమానం, తరువాత మరియు ముందు" పద్ధతులను ఉపయోగించడం

1. తరువాత మరియు ముందు, సమానంగా ఉపయోగించండి. తేదీలను ఒకదానితో ఒకటి సమానంగా, తరువాత మరియు ముందు పద్ధతులను ఉపయోగించి పోల్చవచ్చు. రెండు తేదీలు ఒకేసారి సూచిస్తే, సమాన పద్ధతి "ట్రూ" గా తిరిగి వస్తుంది. ఉదాహరణలు పోలిక పద్ధతి ద్వారా గతంలో సృష్టించిన తేదీలను ఉపయోగిస్తాయి.
2. ముందు పద్ధతిని ఉపయోగించి సరిపోల్చండి. దిగువ కోడ్ నిజమైన మరియు తప్పుడు కేసును చూపుతుంది. తేదీ 1 తేదీ 2 కంటే ముందే ఉంటే, ఫలితం నిజం. కాకపోతే, తప్పుడు తిరిగి ఇచ్చే ముందు.

   System.out.print (date1.before (date2)); // ప్రింట్ ట్రూ System.out.print (date2.before (date2)); // తప్పుడు ముద్రణ

3. దీన్ని తరువాత పద్ధతితో పోల్చండి. దిగువ కోడ్ నిజమైన మరియు తప్పుడు కేసును చూపుతుంది. తేదీ 2 తేదీ 1 కంటే తరువాత ఉంటే, తిరిగి వచ్చిన తర్వాత నిజం. కాకపోతే, తప్పుడు తిరిగి వచ్చిన తర్వాత.

   System.out.print (date2.after (date1)); // నిజమైన System.out.print (date1.after (date2)); // ప్రింట్ తప్పుడు

4. సమాన పద్ధతిని ఉపయోగించి సరిపోల్చండి. దిగువ కోడ్ నిజమైన మరియు తప్పుడు కేసును చూపుతుంది. తేదీలు ఒకేలా ఉంటే, సమానమైన రాబడి నిజమైనది. కాకపోతే, రిటర్న్స్ తప్పుడు సమానం.

   System.out.print (date1.equals (date3)); // ప్రింట్ ట్రూ System.out.print (date1.equals (date2)); // ప్రింట్ తప్పుడు

4 యొక్క విధానం 3: క్యాలెండర్ తరగతిని ఉపయోగించడం

1. క్యాలెండర్ తరగతిని ఉపయోగించండి. క్యాలెండర్ తరగతిలో పోలిక ఉంది, సమానం, తరువాత మరియు ముందు పద్ధతులు ఉన్నాయి, ఇవి తేదీ తరగతి కోసం పైన వివరించిన విధంగానే పనిచేస్తాయి. కాబట్టి తేదీ డేటాను క్యాలెండర్‌లో ఉంచినట్లయితే, "తేదీ" ను సంగ్రహించాల్సిన అవసరం లేదు, కేవలం రెండు తేదీలను పోల్చడానికి.
2. క్యాలెండర్ యొక్క ఉదాహరణను సృష్టించండి. క్యాలెండర్ పద్ధతులను ఉపయోగించడానికి మీకు కొన్ని క్యాలెండర్ ఉదంతాలు అవసరం. అదృష్టవశాత్తూ, తేదీ ఉదంతాల ద్వారా ఉత్పత్తి చేయబడిన సమయాన్ని మీరు ఉపయోగించవచ్చు.

   క్యాలెండర్ cal1 = Calendar.getInstance (); // cal1 క్యాలెండర్ cal2 = Calendar.getInstance () ను ప్రకటిస్తుంది; // cal2 క్యాలెండర్ ప్రకటించింది cal3 = Calendar.getInstance (); // cal3 cal1.setTime (date1) ను ప్రకటిస్తుంది; // cal1 cal2.setTime (date2) కు తేదీని వర్తిస్తుంది; cal3.setTime (తేదీ 3);

3. ముందు ఉపయోగించి cal1 మరియు cal2 ను పోల్చండి. కాల్ 1 కాల్ 2 కంటే ముందే ఉన్నందున దిగువ కోడ్ నిజం అవుతుంది.

   System.out.print (cal1.before (cal2)); // ప్రింట్ ట్రూ

4. తర్వాత ఉపయోగించి cal1 మరియు cal2 ను పోల్చండి. దిగువ కోడ్ తప్పుగా వస్తుంది, ఎందుకంటే cal1 cal2 కన్నా ముందే ఉంటుంది.

   System.out.print (cal1.after (cal2)); // తప్పుడు ముద్రణ

5. సమానంగా ఉపయోగించి కాల్ 1 మరియు కాల్ 2 ను పోల్చండి. దిగువ కోడ్ నిజమైన మరియు తప్పుడు రెండింటికి ఉదాహరణను చూపుతుంది. క్యాలెండర్ ఉదంతాలను పోల్చినప్పుడు ఈ పరిస్థితి ఆధారపడి ఉంటుంది. దిగువ కోడ్ తదుపరి పంక్తిలో "ట్రూ" మరియు "తప్పుడు" ను అందిస్తుంది.

   System.out.println (cal1.equals (cal3)); // ముద్రణ నిజం: cal1 == cal3 System.out.print (cal1.equals (cal2)); // తప్పుడు ముద్రణ: cal1! = cal2

4 యొక్క 4 వ పద్ధతి: "getTime" పద్ధతిని ఉపయోగించడం

1. GetTime ఉపయోగించండి. పైన పేర్కొన్న ఏవైనా విధానాలు మరింత చదవగలిగే ఫలితాలను ఇచ్చే అవకాశం ఉన్నప్పటికీ, రెండు టైమ్ పాయింట్లను నేరుగా పోల్చడం కూడా సాధ్యమే. ఇది రెండు ఆదిమ డేటా రకాల పోలిక, కాబట్టి "", ">" మరియు "==" తో చేయవచ్చు.
2. "దీర్ఘ" సమయ వస్తువులను సృష్టించండి. మీరు తేదీలను పోల్చడానికి ముందు, మీరు గతంలో సృష్టించిన తేదీ వస్తువుల డేటా నుండి దీర్ఘ పూర్ణాంకాలను సృష్టించాలి. అదృష్టవశాత్తూ, getTime () పద్ధతి మీ కోసం చాలా పనిని చేస్తుంది.

   long time1 = getTime (date1); // తేదీ 1 యొక్క ఆదిమ సమయం 1 ని ప్రకటిస్తుంది 2 = getTime (date2); // తేదీ 2 యొక్క ఆదిమ సమయం 2 ను ప్రకటిస్తుంది

3. "కంటే తక్కువ" సమీకరణాన్ని ఉపయోగించండి. ఈ రెండు పూర్ణాంక విలువలను పోల్చడానికి "కంటే తక్కువ" గుర్తు () ను ఉపయోగించండి. సమయం 1 సమయం 2 కన్నా తక్కువగా ఉన్నందున, మొదటి సందేశాన్ని తెరపై ముద్రించాలి. సరైన వాక్యనిర్మాణం కోసం మిగతా స్టేట్మెంట్ చేర్చబడింది.

   if (time1 time2) {System.out.println ("date1 date2 కన్నా ముందే ఉంది"); // ప్రింట్ ఎందుకంటే time1 time2} else {System.out.println ("date1 డేట్ 2 కన్నా ఎక్కువ లేదా సమానం"); }

4. "కంటే ఎక్కువ" పోలిక చేయండి. ఈ రెండు పూర్ణాంకాలను పోల్చడానికి "కంటే ఎక్కువ" గుర్తు (>) ఉపయోగించండి. Time1 time2 కన్నా ఎక్కువ కాబట్టి, మొదటి సందేశం తెరపై ముద్రించబడుతుంది. సరైన వాక్యనిర్మాణం కోసం మిగతా స్టేట్మెంట్ చేర్చబడింది.

   if (time2> time1) {System.out.println ("date2 date1 తర్వాత వస్తుంది"); // ప్రింట్ ఎందుకంటే time2> time1} else {System.out.println ("date2 డేట్ 1 కంటే ముందే లేదా సమానంగా ఉంటుంది"); }

5. "సమానమైన" పోలిక చేయండి. ఈ రెండు పూర్ణాంకాలను పోల్చడానికి చిహ్నాన్ని (==) ఉపయోగించండి. Time1 time3 కి సమానం కాబట్టి, మొదటి సందేశాన్ని ముద్రించాలి. ప్రోగ్రామ్ వేరే స్టేట్‌మెంట్‌కు వస్తే, సమయం ఒకేలా ఉండదని అర్థం.

   if (time1 == time2) {System.out.println ("తేదీలు సమానం"); . else {System.out.println ("తేదీలు సమానం కాదు"); // ప్రింట్ ఎందుకంటే టైమ్ 1! = టైమ్ 2}