తేదీ తరగతి

1. Dateతరగతి మరియు Unix సమయం

జావా ప్రారంభం నుండి, భాష సమయాలు మరియు తేదీలతో పనిచేయడానికి ఒక ప్రత్యేక తరగతిని కలిగి ఉంది — Date. కాలక్రమేణా, తేదీలతో పనిచేయడానికి అనేక తరగతులు కనిపించాయి, అయితే ప్రోగ్రామర్లు Dateనేటికీ తరగతిని ఉపయోగించడం కొనసాగిస్తున్నారు.

ఎందుకంటే ఇది చాలా సులభం మరియు సౌకర్యవంతంగా ఉంటుంది. మరియు ప్రోగ్రామర్‌గా, మీరు ఏదైనా నిజమైన ప్రాజెక్ట్‌లో దీన్ని ఖచ్చితంగా ఎదుర్కొంటారు. దీన్ని ఉపయోగించాలా వద్దా అనేది మీ ఎంపిక, కానీ మీరు దానిని తెలుసుకోవాలి. కాబట్టి మీ విలువైన సమయాన్ని కొన్ని నిమిషాలు ఇవ్వండి.

Dateక్లాస్‌ని అంత మంచిగా చేసేది ఏమిటి ? దాని సరళత.

తరగతి జనవరి 1, 1970 నుండి గడిచిన మిల్లీసెకన్ల సంఖ్యగాDate తేదీ మరియు సమయ సమాచారాన్ని నిల్వ చేస్తుంది. అది చాలా మిల్లీసెకన్లు, కాబట్టి వాటిని నిల్వ చేయడానికి రకాన్ని ఉపయోగించబడుతుంది.long

కానీ రెండు తేదీల మధ్య ఎంత సమయం గడిచిందో మీరు చాలా సులభంగా కనుగొనవచ్చు: కేవలం ఒక తేదీని మరొకదాని నుండి తీసివేయండి మరియు మీరు తేదీల మధ్య సమీప మిల్లీసెకన్‌కు మధ్య వ్యత్యాసాన్ని పొందుతారు.

తరగతితో పని చేయడానికి ఇక్కడ కొన్ని ఉపయోగకరమైన ఉదాహరణలు ఉన్నాయి Date.

2. ప్రస్తుత తేదీని పొందడం

ప్రస్తుత సమయం మరియు తేదీని పొందడానికి, ఒక Dateవస్తువును సృష్టించండి. ప్రతి కొత్త వస్తువు అది సృష్టించబడిన సమయాన్ని నిల్వ చేస్తుంది. ఇది చాలా సరళంగా కనిపిస్తుంది:

Date current = new Date();

ఈ ఆదేశాన్ని అమలు చేసిన తర్వాత, currentవేరియబుల్ సృష్టించిన వస్తువుకు సూచనను నిల్వ చేస్తుంది Date, ఇది దాని సృష్టి సమయాన్ని అంతర్గతంగా నిల్వ చేస్తుంది - జనవరి 1, 1970 నుండి గడిచిన మిల్లీసెకన్ల సంఖ్య.

స్క్రీన్‌పై ప్రస్తుత తేదీని ప్రదర్శిస్తోంది

ప్రస్తుత తేదీని ప్రదర్శించడానికి, కేవలం: ఎ) కొత్త Dateవస్తువును సృష్టించండి, బి) పద్ధతిని ఉపయోగించి దాన్ని స్క్రీన్‌పై ముద్రించండి System.out.println().

ఉదాహరణ:

Date current = new Date();
System.out.println(current);

Thu Feb 21 14:01:34 EET 2019

కన్సోల్ అవుట్‌పుట్ అంటే ఇక్కడ ఉంది:

3. నిర్దిష్ట తేదీని సెట్ చేయడం

Dateప్రస్తుత సమయాన్ని ఎలా పొందాలో మేము కనుగొన్నాము, కానీ వేరే తేదీ లేదా సమయాన్ని నిల్వ చేసే వస్తువును ఎలా సృష్టించాలి ?

మళ్ళీ, ఇక్కడ ప్రతిదీ చాలా సులభం. నిర్దిష్ట తేదీని సెట్ చేయడానికి, మీరు ఇలా కోడ్ రాయాలి:

Date birthday = new Date(year, month, day);

ప్రతిదీ సరళమైనది మరియు స్పష్టంగా ఉంది, కానీ తెలుసుకోవలసిన రెండు సూక్ష్మ నైపుణ్యాలు ఉన్నాయి:

1. సంవత్సరాన్ని 1900 నుండి లెక్కించాలి.
2. నెలలు సున్నా నుండి లెక్కించబడతాయి.

ఉదాహరణకు, నేను మార్చి 21, 1989న జన్మించాను. మార్చి మూడవ నెల, కాబట్టి నేను వ్రాయవలసి ఉంది:

Date current = new Date(89, 2, 21);
System.out.println(current);

Tue Mar 21 00:00:00 EET 1989

నెలలు సున్నా నుండి లెక్కించబడ్డాయి, కానీ రోజులు కాదు ఇది కొంచెం వింతగా ఉంది, సరియైనదా?

నిజమైన ప్రోగ్రామర్లు ప్రబలంగా ఉండాలని మరియు నెల రోజులను సున్నా నుండి లెక్కించాలని మేము భావిస్తున్నాము. ఓహ్, ఈ కన్ఫార్మిస్ట్‌లు 🙂

నిర్దిష్ట సమయాన్ని సెట్ చేస్తోంది

నిర్దిష్ట సమయాన్ని సెట్ చేయడం కూడా చాలా సులభం: దీని కోసం, మీరు ఇలా ఒక ప్రకటన రాయాలి:

Date birthday = new Date(year, month, day, hour, minutes, seconds);

గంటలు, నిమిషాలు మరియు సెకన్లు సున్నా నుండి లెక్కించబడతాయి: మీ లోపల ఉన్న ప్రోగ్రామర్‌ని ఊపిరి పీల్చుకోండి.

ఉదాహరణ:

Date current = new Date(105, 5, 4, 12, 15, 0);
System.out.println(current);

Sat Jun 04 12:15:00 EEST 2005

మేము సమయం 12:15 మరియు జూన్ 4, 2005 తేదీని సెట్ చేసాము . ప్రోగ్రామర్ కాని వారికి చదవడం కొంచెం కష్టం, కానీ ఇది తప్పక పని చేస్తుంది.

4. తేదీ అంశాలతో పని చేయడం

Dateమీరు ఆబ్జెక్ట్‌ను ప్రదర్శించడం కంటే ఎక్కువ చేయవచ్చు . ఇది అంతర్గతంగా నిల్వ చేయబడిన తేదీ యొక్క వ్యక్తిగత అంశాలను పొందడానికి మిమ్మల్ని అనుమతించే పద్ధతులను కలిగి ఉంది:

int getYear()

int getMonth()

int getDate()

int getDay()

int getHours()

int getMinutes()

int getSeconds()

ఉదాహరణ:

Date current = new Date(105, 5, 4, 12, 15, 0);
System.out.println(current.getYear());
System.out.println(current.getMonth());
System.out.println(current.getDate());
System.out.println(current.getDay());

105
5
4
6

మార్గం ద్వారా, ఒక Dateవస్తువు తేదీ యొక్క వ్యక్తిగత అంశాలను పొందడానికి మిమ్మల్ని అనుమతించడమే కాకుండా, వాటిని మార్చడానికి కూడా అనుమతిస్తుంది:

5. మిల్లీసెకన్లు

మేము ఇంతకు ముందు చెప్పినట్లుగా, Dateఆబ్జెక్ట్ జనవరి 1, 1970 నుండి గడిచిన మిల్లీసెకన్ల సంఖ్యను నిల్వ చేస్తుంది.

మనకు ఆ సంఖ్య అవసరమైతే, మనం దానిని వస్తువు నుండి పొందవచ్చు Date:

long time = date.getTime();

పద్ధతి ఆబ్జెక్ట్ getTime()లోపల నిల్వ చేయబడిన మిల్లీసెకన్ల సంఖ్యను అందిస్తుంది Date.

మీరు మిల్లీసెకన్ల సంఖ్యను పొందడమే కాకుండా, ఇప్పటికే ఉన్న వస్తువులో ఆ సంఖ్యను కూడా మార్చవచ్చు:

Date date = new Date();
date.setTime(1117876500000L);

మార్గం ద్వారా, ఆబ్జెక్ట్ Dateసృష్టించబడినప్పుడు దానికి సమయాన్ని కేటాయించడం ద్వారా మీరు దీన్ని మరింత సంక్షిప్తంగా వ్రాయవచ్చు:

Date date = new Date(1117876500000L);

6. తేదీలను పోల్చడం

మీరు రెండు తేదీలను సరిపోల్చండి మరియు ఏది ముందుగా వచ్చిందో తెలుసుకోవాలనుకుంటే, మీకు మూడు ఎంపికలు ఉన్నాయి

మొదటి మార్గం ఏమిటంటే అవి ప్రతి స్టోర్‌లోని మిల్లీసెకన్ల సంఖ్యను సరిపోల్చడం:

if (date1.getTime() < date2.getTime())

రెండవ మార్గంbefore() వస్తువు యొక్క పద్ధతిని ఉపయోగించడం Date:

if (date1.before(date2))

ఇది ఇలా ఉంది: date1ముందు వచ్చినట్లయితే date2, అప్పుడు...

మూడవ మార్గంafter() వస్తువు యొక్క పద్ధతిని ఉపయోగించడం Date:

if (date2.after(date1))

ఇది ఇలా ఉంది: date2తర్వాత ఉంటే date1, అప్పుడు...

7. DateFormatతరగతి

గుర్తుంచుకోండి, మేము తేదీని స్క్రీన్‌పై ప్రదర్శించినప్పుడు, మేము ఇలాంటివి చూశాము: Thu Feb 21 14:01:34 EET 2019. ప్రతిదీ సరిగ్గా ఉన్నట్లు అనిపిస్తుంది, అయితే సాధారణ మనుషుల కంటే ప్రోగ్రామర్‌ల కోసం తేదీ ఎలా ప్రదర్శించబడుతుందో ఫార్మాట్‌లో ఎక్కువగా ఉంటుంది. మేము వినియోగదారుల కోసం తేదీని మరింత స్పష్టంగా ప్రదర్శించాలనుకుంటున్నాము. ఏదో Tuesday, February 21.

మరియు సంవత్సరం లేకుండా. లేదా అవసరమైతే ఒక సంవత్సరం పాటు. సాధారణంగా, మేము తేదీని వివిధ మార్గాల్లో ప్రదర్శించగలగాలి.

దీని కోసం ఒక ప్రత్యేక తరగతి ఉంది: SimpleDateFormat.

ఉదాహరణ:

Date current = new Date(105, 5, 4, 12, 15, 0);
SimpleDateFormat formatter = new SimpleDateFormat("MMM-dd-YYYY");
String message = formatter.format(current);
System.out.println(message);

Jun-04-2005

ప్రోగ్రామ్ ఏమి ప్రదర్శించబడిందో చూడండి: Jun-04-2005. అది అస్సలు కాదు.

తేడా ఏమిటంటే, మేము ఆ వస్తువును కాకుండా , ఒక వస్తువుపై పద్ధతిని Dateకాల్ చేయడం ద్వారా పొందిన ప్రత్యేక స్ట్రింగ్‌ను ప్రదర్శించాము . కానీ అది కూడా ఇక్కడ ప్రధాన అంశం కాదు.format()SimpleDateFormat

వస్తువు SimpleDateFormatసృష్టించబడినప్పుడు, మేము స్ట్రింగ్‌లో "MMM-dd-YYYY"పారామీటర్‌గా పాస్ చేసాము. కన్సోల్ అవుట్‌పుట్‌లో మనం చివరికి చూసిన తేదీ ఆకృతిని తెలియజేసేది ఈ స్ట్రింగ్.

• MMM నెల పేరును ప్రదర్శించడానికి సూచిస్తుంది, మూడు అక్షరాలను ఉపయోగించి సంక్షిప్తీకరించబడింది
• dd నెలలోని రోజును ప్రదర్శించాలని సూచిస్తుంది
• నాలుగు అంకెలను ఉపయోగించి సంవత్సరాన్ని ప్రదర్శించాలని YYYY సూచిస్తుంది

మనం నెలను సంఖ్యలుగా అవుట్‌పుట్ చేయాలనుకుంటే, బదులుగా MMM, మనం వ్రాయవలసి ఉంటుంది MM, ఇది నమూనాను ఇస్తుంది "MM-dd-YYYY". స్క్రీన్ అవుట్‌పుట్ ఉంటుంది06-04-2005

మేము ఈ తరగతిని తరువాత మరింత వివరంగా చర్చిస్తాము.

8. Date.parseపద్ధతి

తరగతి Dateఇంకేదైనా ఆసక్తికరమైన మరియు ఉపయోగకరమైనది చేయగలదు - ఇది స్ట్రింగ్ నుండి తేదీని పొందవచ్చు. లేదా, ప్రోగ్రామర్లు చెప్పినట్లు, ఇది స్ట్రింగ్‌ను అన్వయించగలదు.

parse()దీనికి ప్రత్యేక పద్ధతి ఉంది . పార్సింగ్ ఇలా కనిపిస్తుంది:

Date date = new Date();
date.setTime( Date.parse("Jul 06 12:15:00 2019") );

మార్గం ద్వారా, ఈ కోడ్ మరింత సంక్షిప్తంగా వ్రాయవచ్చు:

Date date = new Date("Jul 06 12:15:00 2019");

మేము ఇతర పాఠాలలో స్ట్రింగ్‌ల పార్సింగ్‌ను మరింత వివరంగా పరిశీలిస్తాము .