சரியான நேரத்தில் தொலைந்து போகாமல் இருப்பது எப்படி: தேதிநேரம் மற்றும் நாட்காட்டி

வணக்கம்! இன்று நாம் இதுவரை சந்திக்காத புதிய தரவு வகையுடன் வேலை செய்யத் தொடங்குவோம், அதாவது தேதிகள். தேதி என்றால் என்ன என்பதை நான் விளக்க வேண்டியதில்லை என்று நினைக்கிறேன். :) கொள்கையளவில், தற்போதைய தேதி மற்றும் நேரத்தை ஒரு சாதாரண ஜாவா சரத்தில் சேமிக்க முடியும்.

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 ஐப் பெறுகிறோம். "வெள்ளி" என்பது வாரத்தின் நாளைக் குறிக்கிறது (வெள்ளிக்கிழமை, duh), மற்றும் 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 என்பது date2 ஐ விட முந்தையது , ஆனால் மிகவும் வசதியான வழியும் உள்ளது, அதாவது தேதி வகுப்பு: 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 மாறிலி: நீங்கள் பொதுவான சகாப்தத்திற்கு முன் (கி.மு - கிறிஸ்துவுக்கு முன்) அல்லது பொது சகாப்தத்தில் (AD - Anno Domini) தேதியைக் குறிப்பிடலாம். இதையெல்லாம் உதாரணங்களுடன் பார்க்கலாம். 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=?,DAYK_OF_MONTH=?,DAY_YDAY_5DAY_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 2017set() மாறிலி (நாம் மாற்ற விரும்பும் புலத்தைப் பொறுத்து) மற்றும் புலத்திற்கான புதிய மதிப்பைக் கடந்து, முறையை அழைக்கிறோம் . இந்த முறை ஒரு வகையான "சூப்பர்-செட்டர்" என்று மாறிவிடும், 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 கிமு அன்று நடந்தது:

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 கி.மு. வகுப்பில் Calendarஇன்னும் பல முறைகள் மற்றும் மாறிலிகள் உள்ளன. அவற்றைப் பற்றி நீங்கள் ஆவணத்தில் படிக்கலாம் . இந்த தேதி வடிவம் Sat Nov 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 அது மிகவும் சிறந்தது, இல்லையா? :)