సమయానికి ఎలా కోల్పోకూడదు: తేదీ సమయం మరియు క్యాలెండర్

హాయ్! ఈ రోజు మనం ఇంతకు ముందు చూడని కొత్త డేటా రకంతో పని చేయడం ప్రారంభిస్తాము, అవి తేదీలు. తేదీ అంటే ఏమిటో నేను వివరించాల్సిన అవసరం లేదు. :) సూత్రప్రాయంగా, మేము ప్రస్తుత తేదీ మరియు సమయాన్ని సాధారణ జావా స్ట్రింగ్‌లో నిల్వ చేయవచ్చు.

public class Main {
   public static void main(String[] args) {

       String date = "June 11, 2018";
       System.out.println(date);
   }
}

కానీ ఈ విధానం అనేక లోపాలను కలిగి ఉంది. తరగతి Stringటెక్స్ట్‌తో పని చేయడానికి రూపొందించబడింది మరియు దాని పద్ధతులు ఈ పనికి తగినవి. మనం ఏదో ఒక విధంగా తేదీని మార్చవలసి వస్తే (ఉదాహరణకు 2 గంటలు జోడించండి), Stringఅంత బాగా పని చేయదు. లేదా మేము ప్రోగ్రామ్ కంపైల్ చేయబడినప్పుడు ప్రస్తుత తేదీ మరియు సమయాన్ని ప్రదర్శించాలనుకుంటే. Stringఇక్కడ కూడా సహాయం చేయదు: మీరు కోడ్‌ను వ్రాసి దాన్ని అమలు చేసే సమయానికి, సమయం మారుతుంది మరియు కన్సోల్ తప్పు సమాచారాన్ని ప్రదర్శిస్తుంది. అందుకే జావా సృష్టికర్తలు తేదీలు మరియు సమయంతో పనిచేయడానికి అనేక తరగతులను అందించారు. వీటిలో మొదటిదిjava.util.Date

తేదీ తరగతి

మేము దాని పూర్తి పేరును పేర్కొన్నాము, ఎందుకంటే మరొక జావా ప్యాకేజీలో తరగతి ఉంది java.sql.Date. వాటిని కలపవద్దు! మీరు దాని గురించి తెలుసుకోవలసిన మొదటి విషయం ఏమిటంటే, ఇది జనవరి 1, 1970 నుండి గడిచిన మిల్లీసెకన్ల సంఖ్యగా తేదీని నిల్వ చేస్తుంది. ఈ సమయ వ్యవస్థకు దాని స్వంత పేరు కూడా ఉంది: " యునిక్స్-టైమ్ " కాకుండా ఆసక్తికరమైన విధానం, కాదు' మీరు అంగీకరిస్తారా? :) గుర్తుంచుకోవలసిన రెండవ విషయం ఇది: మీరు Dateడిఫాల్ట్ కన్‌స్ట్రక్టర్‌ని ఉపయోగించి ఆబ్జెక్ట్‌ను సృష్టించినట్లయితే, ఫలితం ఆబ్జెక్ట్ సృష్టించబడిన ప్రస్తుత తేదీ మరియు సమయాన్ని సూచిస్తుంది . Stringఒక తేదీగా సూచించబడిన తేదీ అటువంటి పనితో పోరాడుతుందని మేము చెప్పినట్లు గుర్తుందా ? తరగతి Dateదానిని సులభంగా నిర్వహిస్తుంది.

public class Main {
   public static void main(String[] args) {

       Date date = new Date();
       System.out.println(date);
   }
}

ఈ కోడ్‌ని అనేకసార్లు అమలు చేయండి మరియు మీరు సమయం పదేపదే మారడాన్ని చూస్తారు. :) సమయం మిల్లీసెకన్లుగా నిల్వ చేయబడినందున ఇది సాధ్యమవుతుంది: అవి సమయం యొక్క చాలా చిన్న యూనిట్లు, కాబట్టి ఫలితాలు చాలా ఖచ్చితమైనవి. తరగతి Dateమరొక కన్స్ట్రక్టర్: మీరు జనవరి 1, 1970న 00:00 నుండి అవసరమైన తేదీకి ఖచ్చితమైన మిల్లీసెకన్ల సంఖ్యను పాస్ చేయవచ్చు మరియు సంబంధిత తేదీ ఆబ్జెక్ట్ సృష్టించబడుతుంది:

public class Main {
   public static void main(String[] args) {

       Date date = new Date(1212121212121L);
       System.out.println(date);
   }
}

కన్సోల్ అవుట్‌పుట్: మే 30 04:20:12 GMT 2008 మే 30, 2008ని పొందుతాము. "శుక్రవారం" అనేది వారంలోని రోజుని సూచిస్తుంది (శుక్రవారం, దుహ్), మరియు GMT అనేది టైమ్ జోన్ (గ్రీన్‌విచ్ మీన్ టైమ్). మిల్లీసెకన్లు s గా పాస్ చేయబడతాయి long, ఎందుకంటే మిల్లీసెకన్ల సంఖ్య సాధారణంగా ఒకకి సరిపోదు int. కాబట్టి, మనం తేదీలతో ఏ ఆపరేషన్లు చేయాల్సి ఉంటుంది? బాగా, అత్యంత స్పష్టమైన, వాస్తవానికి, పోలిక . ఒక తేదీ మరొకటి ముందు లేదా తర్వాత వస్తుందో లేదో నిర్ణయించడానికి. ఇది అనేక విధాలుగా చేయవచ్చు. ఉదాహరణకు, మీరు Date.getTime()పద్ధతికి కాల్ చేయవచ్చు, ఇది జనవరి 1, 1970 అర్ధరాత్రి నుండి గడిచిన మిల్లీసెకన్ల సంఖ్యను అందిస్తుంది. కేవలం రెండు తేదీ ఆబ్జెక్ట్‌లకు కాల్ చేసి, ఫలితాలను సరిపోల్చండి:

public class Main {
   public static void main(String[] args) {

       Date date1 = new Date();

       Date date2 = new Date();

       System.out.println((date1.getTime() > date2.getTime())?
               "date1 is later than date2" : "date1 is earlier than date2");
   }
}

అవుట్‌పుట్: date1 తేదీ2 కంటే ముందు ఉంది, అయితే మరింత అనుకూలమైన మార్గం కూడా ఉంది, అంటే తేదీ తరగతి అందించిన ప్రత్యేక పద్ధతులను ఉపయోగించడం ద్వారా: before(), after()మరియు equals(). అవన్నీ బూలియన్ విలువను అందిస్తాయి. before()మా తేదీ ఆర్గ్యుమెంట్‌గా ఆమోదించబడిన తేదీ కంటే ముందు ఉందో లేదో ఈ పద్ధతి తనిఖీ చేస్తుంది:

public class Main {
   public static void main(String[] args) throws InterruptedException {

       Date date1 = new Date();

       Thread.sleep(2000);// Suspend the program for 2 seconds
       Date date2 = new Date();

       System.out.println(date1.before(date2));
   }
}

కన్సోల్ అవుట్‌పుట్: నిజం అదేవిధంగా, after()మా తేదీ ఆర్గ్యుమెంట్‌గా ఆమోదించబడిన తేదీ కంటే ఆలస్యంగా ఉందో లేదో తెలుసుకోవడానికి పద్ధతి తనిఖీ చేస్తుంది:

public class Main {
   public static void main(String[] args) throws InterruptedException {

       Date date1 = new Date();

       Thread.sleep(2000);// Suspend the program for 2 seconds
       Date date2 = new Date();

       System.out.println(date1.after(date2));
   }
}

కన్సోల్ అవుట్‌పుట్: తప్పు మా ఉదాహరణలలో, మేము 2 సెకన్ల పాటు "ప్రోగ్రామ్‌ని నిద్రపోయేలా" ఉంచాము, తద్వారా రెండు తేదీలు వేర్వేరుగా ఉంటాయని హామీ ఇవ్వబడుతుంది. వేగవంతమైన కంప్యూటర్లలో, సృష్టి date1మరియు మధ్య సమయం date2ఒక మిల్లీసెకన్ల కంటే తక్కువగా ఉండవచ్చు, దీని వలన రెండూ before()తప్పుగా after()తిరిగి వస్తాయి. కానీ ఈ సందర్భంలో, equals()పద్ధతి నిజమైన తిరిగి వస్తుంది! అన్నింటికంటే, ఇది ప్రతి తేదీకి జనవరి 1, 1970న 00:00 నుండి మిల్లీసెకన్ల సంఖ్యను పోలుస్తుంది . వస్తువులు మిల్లీసెకన్‌కు సరిపోలితే మాత్రమే సమానంగా పరిగణించబడతాయి :

public static void main(String[] args) {

   Date date1 = new Date();
   Date date2 = new Date();

   System.out.println(date1.getTime());
   System.out.println(date2.getTime());

   System.out.println(date1.equals(date2));
}

ఇక్కడ మీరు శ్రద్ధ వహించాల్సిన మరో విషయం ఉంది. మీరు ఒరాకిల్Date వెబ్‌సైట్‌లో తరగతికి సంబంధించిన డాక్యుమెంటేషన్‌ను తెరిస్తే , దానిలోని అనేక పద్ధతులు మరియు కన్‌స్ట్రక్టర్‌లు నిలిపివేయబడినవిగా (అంటే ఉపయోగం కోసం సిఫార్సు చేయబడలేదు) గుర్తు పెట్టబడిందని మీరు చూస్తారు . విస్మరించబడిన తరగతుల భాగాల గురించి జావా సృష్టికర్తలు చెప్పేది ఇక్కడ ఉంది: ఈ పద్ధతులను అస్సలు ఉపయోగించలేమని దీని అర్థం కాదు. మీరు IDEలో నిలిపివేయబడిన పద్ధతులను ఉపయోగించి కోడ్‌ని అమలు చేయడానికి ప్రయత్నిస్తే, అది ఎక్కువగా పని చేస్తుంది ఉదాహరణకు, Date.getHours()ఆబ్జెక్ట్‌తో అనుబంధించబడిన గంటల సంఖ్యను అందించే నిలిపివేయబడిన పద్ధతిని పరిగణించండి Date.

public static void main(String[] args) {

   Date date1 = new Date();

   System.out.println(date1.getHours());
}

మీరు కోడ్‌ను 14:21 (2:21 PM)కి ప్రారంభిస్తే, అది 14 సంఖ్యను ప్రదర్శిస్తుంది. మీరు చూడగలిగినట్లుగా, నిలిపివేయబడిన పద్ధతి దాటవేయబడింది, కానీ అది ఇప్పటికీ పని చేస్తుంది. ఈ పద్ధతులు వాటిని ఉపయోగించే ఇప్పటికే ఉన్న భారీ కోడ్‌ను విచ్ఛిన్నం చేయకుండా తొలగించబడవు. మరో మాటలో చెప్పాలంటే, ఈ పద్ధతులు "విరిగినవి" లేదా "తొలగించబడవు". మరింత అనుకూలమైన ప్రత్యామ్నాయం అందుబాటులో ఉన్నందున అవి ఉపయోగించడానికి సిఫారసు చేయబడలేదు. యాదృచ్ఛికంగా, డాక్యుమెంటేషన్ ప్రత్యేకంగా ఈ ప్రత్యామ్నాయాన్ని ప్రస్తావిస్తుంది: తరగతి యొక్క చాలా Dateపద్ధతులు మెరుగుపరచబడిన మరియు విస్తరించిన తరగతికి తరలించబడ్డాయి Calendar. ఆ క్లాస్‌తో మనం తర్వాత పరిచయం చేసుకుందాం. :)

క్యాలెండర్ తరగతి

JDK 1.1 కొత్త తరగతిని ప్రవేశపెట్టింది: Calendar. ఇది మునుపటి కంటే జావాలో తేదీలతో పని చేయడం కొంత సులభం చేసింది. Calendarమేము పని చేసే తరగతి యొక్క ఏకైక అమలు GregorianCalendarతరగతి. ఇది ప్రపంచంలోని చాలా దేశాలు పాటించే గ్రెగోరియన్ క్యాలెండర్‌ను అమలు చేస్తుంది. దీని ప్రధాన ప్రయోజనం ఏమిటంటే ఇది మరింత అనుకూలమైన ఆకృతిలో తేదీలతో పని చేయగలదు. ఉదాహరణకు, ఇది చేయవచ్చు:

• ప్రస్తుత తేదీకి ఒక నెల లేదా రోజుని జోడించండి
• సంవత్సరం లీప్ ఇయర్ కాదా అని తనిఖీ చేయండి;
• తేదీ యొక్క వ్యక్తిగత భాగాలను తిరిగి ఇవ్వండి (ఉదాహరణకు, మొత్తం తేదీ నుండి నెల సంఖ్యను సంగ్రహించండి)
• ఇది స్థిరాంకాల యొక్క చాలా అనుకూలమైన వ్యవస్థను కూడా కలిగి ఉంటుంది (వీటిలో చాలా వరకు మనం క్రింద చూస్తాము).

తరగతి యొక్క మరొక ముఖ్యమైన మెరుగుదల Calendarదాని Calendar.ERA స్థిరాంకం: మీరు సాధారణ యుగానికి ముందు (BC - క్రీస్తుకు ముందు) లేదా సాధారణ యుగంలో (AD - అన్నో డొమిని) తేదీని సూచించవచ్చు. ఇవన్నీ ఉదాహరణలతో చూద్దాం. calendarజనవరి 25, 2017 తేదీతో వస్తువును సృష్టిద్దాం :

public static void main(String[] args) {

  Calendar calendar = new GregorianCalendar(2017, 0 , 25);
}

తరగతిలో Calendar(అలాగే Dateఆ విషయానికి సంబంధించిన తరగతి), నెలలు సున్నా నుండి మొదలవుతాయి , కాబట్టి మేము రెండవ ఆర్గ్యుమెంట్‌గా సంఖ్య 0ని పాస్ చేస్తాము. తరగతితో పని చేస్తున్నప్పుడు , ఇది కేవలం క్యాలెండర్Calendar అని అర్థం చేసుకోవడం ముఖ్యం, వ్యక్తిగత తేదీ కాదు. తేదీ అనేది నిర్దిష్ట సమయ విరామాన్ని సూచించే కొన్ని సంఖ్యలు. క్యాలెండర్ అనేది తేదీలతో చాలా పనులు చేయడానికి మిమ్మల్ని అనుమతించే మొత్తం వ్యవస్థ. :) మీరు ఆబ్జెక్ట్‌ను ప్రదర్శించడానికి ప్రయత్నిస్తే ఇది చాలా స్పష్టంగా కనిపిస్తుంది : అవుట్‌పుట్: Calendarjava.util.GregorianCalendar[time=?,areFieldsSet=false,areAllFieldsSet=false, lenient=true,zone=sun.util.calendar.ZoneInfo[id="Europe/London",offset=0,dstSavings=0,useDaylight తప్పు,పరివర్తనాలు=79,lastRule=null],firstDayOfWeek=2,minimalDaysInFirstWeek=1,ERA=?,YEAR=2017,MONTH=0,WEEK_OF_YEAR=?,WEEK_OF_MONTH=?,DAY_YDAY_5DAY_5 ? ,DAY_OF_WEEK_IN_MONTH=?,AM_PM=0,HOUR=0,HOUR_OF_DAY=0,MINUTE=0,SECOND=0,MILLISECOND=?,ZONE_OFFSET=?,DST_OFFSET=?] మీకు ఎంత సమాచారం లభిస్తుందో చూడండి ! క్యాలెండర్‌లో సాధారణ తేదీలో లేని అనేక లక్షణాలు ఉన్నాయి మరియు అవన్నీ ప్రదర్శించబడతాయి (toString()తరగతిలో పద్ధతి ఈ విధంగా పనిచేస్తుందిCalendar). మీరు క్యాలెండర్ నుండి ఒక సాధారణ తేదీని పొందాలంటే, అంటేDateవస్తువు, ఉపయోగించండిCalendar.getTime()పద్ధతి (పేరు చాలా లాజికల్ కాదు, కానీ మీరు ఏమి చేయవచ్చు?):

public static void main(String[] args) {

   Calendar calendar = new GregorianCalendar(2017, 0 , 25);
   Date date = calendar.getTime();
   System.out.println(date);
}

అవుట్‌పుట్: బుధ జనవరి 25 00:00:00 GMT 2017 ఇప్పుడు మేము క్యాలెండర్‌ని తీసుకొని సాధారణ తేదీకి "తగ్గించాము". ఇంకా ముందుకు వెళ్దాం. వారి సంఖ్య ద్వారా నెలలను పేర్కొనడంతో పాటు, మీరు Calendarతరగతి స్థిరమైన ఫీల్డ్ విలువలను ఉపయోగించవచ్చు . Calendarఈ స్థిరాంకాలు మార్చలేని ప్రీసెట్ విలువతో తరగతి యొక్క స్టాటిక్ ఫీల్డ్‌లు . వాస్తవానికి ఇది మరింత మెరుగైన ఎంపిక, ఎందుకంటే వాటిని ఉపయోగించడం వల్ల మీ కోడ్ చదవగలిగే సామర్థ్యం మెరుగుపడుతుంది.

public static void main(String[] args) {
   GregorianCalendar calendar = new GregorianCalendar(2017, Calendar.JANUARY , 25);
}

Calendar.JANUARY అనేది సంవత్సరంలోని నెలలను సూచించే స్థిరాంకాలలో ఒకటి. ఈ పేరున్న స్థిరాంకాలను ఉపయోగించి, ఎవరూ మర్చిపోరు, ఉదాహరణకు, సంఖ్య 3 అంటే ఏప్రిల్ అని అర్థం, మరియు మేము మార్చి అని పిలవాలనుకుంటున్న మూడవ నెల కాదు. Calendar.APRIL అని వ్రాయండిమరియు మీరు పూర్తి చేసారు. :) అన్ని క్యాలెండర్ ఫీల్డ్‌లు (సంఖ్య, నెల, నిమిషాలు, సెకన్లు మొదలైనవి) పద్ధతిని ఉపయోగించి విడిగా పేర్కొనవచ్చుset(). ఈ పద్ధతి చాలా సౌకర్యవంతంగా ఉంటుంది, ఎందుకంటేCalendarతరగతి ప్రతి ఫీల్డ్‌కు స్థిరంగా ఉంటుంది మరియు ఫలితంగా కోడ్ చదవడం చాలా సులభం. చివరి ఉదాహరణలో, మేము తేదీని సృష్టించాము, కానీ దాని కోసం సమయాన్ని సెట్ చేయలేదు. సమయం 19:42:12 సెట్ చేద్దాం

public static void main(String[] args) {
   Calendar calendar = new GregorianCalendar();
   calendar.set(Calendar.YEAR, 2017);
   calendar.set(Calendar.MONTH, 0);
   calendar.set(Calendar.DAY_OF_MONTH, 25);
   calendar.set(Calendar.HOUR_OF_DAY, 19);
   calendar.set(Calendar.MINUTE, 42);
   calendar.set(Calendar.SECOND, 12);

   System.out.println(calendar.getTime());
}

అవుట్‌పుట్: జనవరి 25 19:42:12 GMT 2017 మేము పద్ధతిని పిలుస్తాము set(), స్థిరంగా (మనం మార్చాలనుకుంటున్న ఫీల్డ్‌ని బట్టి) మరియు ఫీల్డ్‌కు కొత్త విలువను పాస్ చేస్తాము. set()ఈ పద్ధతి ఒక రకమైన "సూపర్-సెట్టర్" అని తేలింది , ఇది ఒక ఫీల్డ్‌కు మాత్రమే కాకుండా అనేక ఫీల్డ్‌లకు విలువను ఎలా సెట్ చేయాలో తెలుసు. :) విలువలను జోడించడానికి మరియు తీసివేయడానికి Calendarతరగతి పద్ధతిని ఉపయోగిస్తుంది . add()మీరు మార్చాలనుకుంటున్న ఫీల్డ్‌లో ఉత్తీర్ణులయ్యారు మరియు ఒక సంఖ్య (ప్రస్తుత విలువ నుండి మీరు ఖచ్చితంగా ఎంత జోడించాలనుకుంటున్నారు/తీసివేయాలనుకుంటున్నారు). ఉదాహరణకు, మనం సృష్టించిన తేదీకి 2 నెలల ముందు ఉన్న తేదీని పొందండి:

public static void main(String[] args) {
   Calendar calendar = new GregorianCalendar(2017, Calendar.JANUARY , 25);
   calendar.set(Calendar.HOUR, 19);
   calendar.set(Calendar.MINUTE, 42);
   calendar.set(Calendar.SECOND, 12);

   calendar.add(Calendar.MONTH, -2); // To subtract, pass a negative number
   System.out.println(calendar.getTime());
}

అవుట్‌పుట్: శుక్ర నవంబర్ 25 19:42:12 GMT 2016 చాలా బాగుంది! మాకు 2 నెలల క్రితం తేదీ వచ్చింది. ఇది నెల మాత్రమే మారడానికి కారణం కాదు: సంవత్సరం కూడా 2017 నుండి 2016కి మార్చబడింది. వాస్తవానికి, తేదీలను మార్చేటప్పుడు, ప్రస్తుత సంవత్సరాన్ని మీరు మాన్యువల్‌గా ట్రాక్ చేయాల్సిన అవసరం లేకుండా స్వయంచాలకంగా లెక్కించబడుతుంది. కానీ కొన్ని కారణాల వల్ల మీరు ఈ ప్రవర్తనను నిలిపివేయవలసి వస్తే, మీరు అలా చేయవచ్చు. పద్ధతి మిగిలిన విలువలను ప్రభావితం చేయకుండాroll() విలువలను జోడించవచ్చు మరియు తీసివేయవచ్చు . ఉదాహరణకు, ఇలా:

public static void main(String[] args) {
   Calendar calendar = new GregorianCalendar(2017, Calendar.JANUARY , 25);
   calendar.set(Calendar.HOUR, 10);
   calendar.set(Calendar.MINUTE, 42);
   calendar.set(Calendar.SECOND, 12);

   calendar.roll(Calendar.MONTH, -2);
   System.out.println(calendar.getTime());
}

మేము మునుపటి ఉదాహరణలో సరిగ్గా అదే పని చేసాము: మేము ప్రస్తుత తేదీ నుండి 2 నెలలు తీసుకున్నాము. కానీ ఇప్పుడు కోడ్ భిన్నంగా ఉంది: నెల జనవరి నుండి నవంబర్‌కు మార్చబడింది, కానీ సంవత్సరం మారదు—2017! అవుట్‌పుట్: శని నవంబర్ 25 10:42:12 GMT 2017 కదులుతోంది. మేము పైన చెప్పినట్లుగా, మేము అన్ని ఫీల్డ్‌లను విడిగా పొందవచ్చు Calendar. మేము దీన్ని ఈ పద్ధతిలో చేస్తాము get():

public static void main(String[] args) {
   GregorianCalendar calendar = new GregorianCalendar(2017, Calendar.JANUARY , 25);
   calendar.set(Calendar.HOUR, 10);
   calendar.set(Calendar.MINUTE, 42);
   calendar.set(Calendar.SECOND, 12);

   System.out.println("Year: " + calendar.get(Calendar.YEAR));
   System.out.println("Month: " + calendar.get(Calendar.MONTH));
   System.out.println("Week in the month: " + calendar.get(Calendar.WEEK_OF_MONTH));// Week in this month?

   System.out.println("Day: " + calendar.get(Calendar.DAY_OF_MONTH));

   System.out.println("Hours: " + calendar.get(Calendar.HOUR));
   System.out.println("Minutes: " + calendar.get(Calendar.MINUTE));
   System.out.println("Seconds: " + calendar.get(Calendar.SECOND));
   System.out.println("Milliseconds: " + calendar.get(Calendar.MILLISECOND));

}

అవుట్‌పుట్: సంవత్సరం: 2017 నెల: 0 నెలలో వారం: 5 రోజు: 25 గంటలు: 10 నిమిషాలు: 42 సెకన్లు: 12 మిల్లీసెకన్లు: 0 కాబట్టి, తరగతి యొక్క "సూపర్-సెట్టర్" తో పాటు Calendar, "సూపర్-గెటర్" కూడా ఉంది ". :) వాస్తవానికి, ఈ తరగతి యొక్క మరొక ఆసక్తికరమైన అంశం యుగాలతో పని చేయడం. "BC" తేదీని సృష్టించడానికి, మీరు Calendar.ERA ఫీల్డ్‌ని ఉపయోగించాలి ఉదాహరణకు, హన్నిబాల్ రోమన్ సైన్యాన్ని ఓడించిన కానే యుద్ధం కోసం తేదీని క్రియేట్ చేద్దాం. ఇది ఆగష్టు 2, 216 BC న జరిగింది:

public static void main(String[] args) {
   GregorianCalendar cannae = new GregorianCalendar(216, Calendar.AUGUST, 2);
   cannae.set(Calendar.ERA, GregorianCalendar.BC);

   DateFormat df = new SimpleDateFormat("MMM dd, yyy GG");
   System.out.println(df.format(cannae.getTime()));
}

ఇక్కడ మేము SimpleDateFormatతేదీని సులభంగా అర్థం చేసుకునే ఫార్మాట్‌లో ప్రింట్ చేయడానికి తరగతిని ఉపయోగించాము ("GG" అక్షరాలు మేము యుగాన్ని ప్రదర్శించాలనుకుంటున్నాము). అవుట్‌పుట్: ఆగస్ట్ 02, 216 BC. తరగతికి Calendarఅనేక పద్ధతులు మరియు స్థిరాంకాలు ఉన్నాయి. మీరు వాటి గురించి డాక్యుమెంటేషన్‌లో చదువుకోవచ్చు . ఈ తేదీ ఫార్మాట్ శని నవంబర్ 25 10:42:12 GMT 2017 ఇష్టం లేకుంటే, మీరు SimpleDateFormatదీన్ని సులభంగా మీరు కోరుకున్నట్లు చేయడానికి ఉపయోగించవచ్చు .

public static void main(String[] args) {

   SimpleDateFormat dateFormat = new SimpleDateFormat("EEEE, MMMM d, yyyy");
   Calendar calendar = new GregorianCalendar(2017, Calendar.JANUARY , 25);
   calendar.set(Calendar.HOUR, 10);
   calendar.set(Calendar.MINUTE, 42);
   calendar.set(Calendar.SECOND, 12);

   calendar.roll(Calendar.MONTH, -2);
   System.out.println(dateFormat.format(calendar.getTime()));
}

అవుట్‌పుట్: శనివారం, నవంబర్ 25, 2017 ఇది చాలా మంచిది, కాదా? :)