Paano hindi mawawala sa oras - DateTime at Calendar

Kamusta! Ngayon ay magsisimula kaming magtrabaho gamit ang isang bagong uri ng data na hindi pa namin nakatagpo noon, katulad ng mga petsa. Sa tingin ko hindi na kailangang ipaliwanag kung ano ang petsa :) Sa prinsipyo, posible na isulat ang kasalukuyang petsa at oras sa Java sa isang regular na string.

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

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

Ngunit ang pamamaraang ito ay may maraming mga kawalan. Ang klase Stringay nilikha upang gumana sa teksto, at mayroon itong naaangkop na mga pamamaraan. Kung kailangan nating pamahalaan ang petsa (halimbawa, magdagdag ng 2 oras dito), Stringhindi ito gagana dito. O, halimbawa, ipakita ang kasalukuyang petsa at oras sa oras na pinagsama-sama ang program sa console. Hindi rin ito makakatulong dito String: habang isinusulat mo ang code at pinapatakbo ito, magbabago ang oras at ang hindi nauugnay ay ipapakita sa console. Samakatuwid, sa Java, ang mga tagalikha nito ay nagbigay ng ilang mga klase para sa pagtatrabaho sa mga petsa at oras. Ang una ay klasejava.util.Date

Klase ng Petsa ng Java

Ibinigay namin ang buong pangalan nito dahil mayroon ding klase sa isa pang pakete sa Java java.sql.Date. Huwag malito! Ang unang bagay na kailangan mong malaman tungkol dito ay ang pag-iimbak nito ng petsa sa mga millisecond na lumipas mula noong Enero 1, 1970. Mayroong kahit isang hiwalay na pangalan para sa petsang ito - "Oras ng Unix". Medyo isang kawili-wiling paraan, hindi ka ba sumasang-ayon? :) Ang pangalawang bagay na dapat tandaan: kung lumikha ka ng isang bagay Datena may walang laman na constructor, ang resulta ay ang kasalukuyang petsa at oras sa oras na nilikha ang bagay . StringNaaalala mo ba kung paano namin isinulat na ang ganoong gawain ay magiging problema para sa isang format ng petsa ? DateMadali itong nalutas ng klase .

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

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

Patakbuhin ang code na ito nang maraming beses at makikita mo kung paano magbabago ang oras sa bawat oras :) Posible ito nang eksakto dahil nakaimbak ito sa mga millisecond: sila ang pinakamaliit na yunit ng oras, kaya naman tumpak ang mga resulta. May isa pang constructor para sa Date: maaari mong tukuyin ang eksaktong bilang ng mga millisecond na lumipas mula 00:00 Enero 1, 1970 hanggang sa kinakailangang petsa, at ito ay malilikha:

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

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

Output ng console:

Fri May 30 08:20:12 MSD 2008

Nakuha namin ito noong Mayo 30, 2008. Ang ibig sabihin ng "Biyer" ay ang araw ng linggo - "Biyernes" (Biyernes), at MSD - "Moscow Daylight Saving" (panahon ng tag-araw sa Moscow). Ang mga millisecond ay ipinapadala sa format long, dahil ang kanilang numero ay madalas na hindi magkasya sa int. Kaya, anong uri ng mga pagpapatakbo ng petsa ang maaaring kailanganin natin sa ating trabaho? Well, ang pinaka-halatang bagay, siyempre, ay paghahambing . Tukuyin kung ang isang petsa ay mas huli o mas maaga kaysa sa isa pa. Ito ay maaaring gawin sa iba't ibang paraan. Halimbawa, maaari mong tawagan ang . method Date.getTime(), na magbabalik ng bilang ng mga millisecond na lumipas mula hatinggabi noong Enero 1, 1970. Tawagan lang natin ito sa dalawang Date object at ihambing ang mga ito sa isa't isa:

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");
   }
}

Konklusyon:

date1 раньше date2

Ngunit mayroong isang mas maginhawang paraan, ibig sabihin, ang paggamit ng mga espesyal na pamamaraan ng klase Date: before(), after()at equals(). Ibinalik nilang lahat ang resulta sa boolean. Sinusuri ng pamamaraan before()kung ang aming petsa ay mas maaga kaysa sa ipinasa namin bilang argumento:

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

       Date date1 = new Date();

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

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

Output ng console:

true

Gumagana ang pamamaraan sa katulad na paraan after(); sinusuri nito kung ang aming petsa ay mas huli kaysa sa ipinasa namin bilang argumento:

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

       Date date1 = new Date();

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

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

Output ng console:

false

Sa aming mga halimbawa, pinapatulog namin ang programa sa loob ng 2 segundo upang ang dalawang petsa ay garantisadong magkaiba. Sa mabilis na mga computer, ang oras sa pagitan ng paggawa date1at date2maaaring mas mababa sa isang millisecond, kung saan parehong at before()at after()babalik false. Ngunit ang pamamaraan equals()sa ganoong sitwasyon ay babalik true! Pagkatapos ng lahat, eksaktong inihahambing nito ang bilang ng mga millisecond na lumipas mula 00:00 Enero 1, 1970 para sa bawat petsa. Ituturing lang na pantay ang mga bagay kung tumugma ang mga ito hanggang sa millisecond:

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));
}

Narito ang isa pang bagay na kailangan mong bigyang pansin. Kung bubuksan mo ang dokumentasyon para sa klase Datesa website ng Oracle, makikita mo na marami sa mga pamamaraan at constructor nito ang itinalaga bilang Deprecated(“hindi na ginagamit”). Narito, tingnan ang: Petsa ng Klase Narito ang sinasabi mismo ng mga tagalikha ng Java tungkol sa mga bahaging iyon ng mga klase na hindi na ginagamit: “Ang isang elemento ng programa na may annotated na @Deprecated ay isang bagay na hindi hinihikayat ng mga programmer na gamitin, kadalasan dahil ito ay mapanganib, o dahil iyon may mas magandang alternatibo." Hindi ito nangangahulugan na ang mga pamamaraang ito ay hindi maaaring gamitin sa lahat. Bukod dito, kung susubukan mo mismo na patakbuhin ang code gamit ang mga ito sa IDEA, malamang na gagana ito. Kunin natin halimbawa ang hindi na ginagamit na paraan Date.getHours(), na nagbabalik ng bilang ng mga oras mula sa object Date.

public static void main(String[] args) {

   Date date1 = new Date();

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

}

Kung sa oras na patakbuhin mo ang code, halimbawa, ang oras ay 14:21, ipapakita nito ang numerong 14. Gaya ng nakikita mo, ang hindi na ginagamit na paraan ay tinatanggal, ngunit ito ay gumagana nang maayos. Ang mga pamamaraang ito ay hindi ganap na tinanggal, upang hindi masira ang isang grupo ng mga code na nakasulat na gamit ang mga ito. Iyon ay, ang mga pamamaraang ito ay hindi "nasira" o "tinanggal", hindi lamang sila inirerekomenda para sa paggamit dahil sa pagkakaroon ng isang mas maginhawang alternatibo. Sa pamamagitan ng paraan, ito ay nakasulat tungkol dito mismo sa dokumentasyon: Karamihan sa mga pamamaraan ng klase ng Petsa ay inilipat sa pinabuting, pinalawig na bersyon nito - ang klase Calendar. Mas makikilala pa natin siya :)

Java Calendar

Ipinakilala ng Java 1.1 ang isang bagong klase - Calendar. Ginawa niyang mas madali ang pagtatrabaho sa mga petsa sa Java kaysa sa dati. Ang tanging pagpapatupad ng klase Calendarkung saan kami magtatrabaho ay ang klase GregorianCalendar(ito ay nagpapatupad ng Gregorian calendar, ayon sa kung saan nakatira ang karamihan sa mga bansa sa mundo). Ang pangunahing kaginhawahan nito ay maaari itong gumana sa mga petsa sa isang mas maginhawang format. Halimbawa, maaari niyang:

• Magdagdag ng buwan o araw sa kasalukuyang petsa
• Suriin kung ang taon ay isang leap year;
• Kumuha ng mga indibidwal na bahagi ng petsa (halimbawa, kunin ang numero ng buwan mula sa isang buong petsa)
• At din, isang napaka-maginhawang sistema ng mga constants ay binuo sa loob nito (makikita natin ang marami sa kanila sa ibaba).

Ang isa pang mahalagang pagkakaiba ng klase Calendaray ang pagpapatupad nito ng isang pare-pareho Calendar.Era: maaari mong itakda ang petsa sa panahon BC (“Before Christ” - bago ang kapanganakan ni Kristo, ibig sabihin, “before our era”) o AC (“After Christ” - “ ating panahon"). Tingnan natin ang lahat ng ito na may mga halimbawa. Gumawa tayo ng kalendaryo na may petsang Enero 25, 2017:

public static void main(String[] args) {

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

Ang mga buwan sa klase Calendar(tulad ng sa Date, sa pamamagitan ng paraan) ay nagsisimula sa zero, kaya ipinasa namin ang numero 0 bilang pangalawang argumento. Ang pangunahing bagay kapag nagtatrabaho sa isang klase Calendaray upang maunawaan na ito ay isang kalendaryo , at hindi isang hiwalay na petsa. Ang petsa ay isang serye lamang ng mga numero na kumakatawan sa isang partikular na yugto ng panahon. At ang kalendaryo ay isang buong device kung saan maaari kang gumawa ng maraming bagay sa mga petsa :) Ito ay makikita nang malinaw kung susubukan mong i-output ang object ng Calendar sa console: Output:

java.util.GregorianCalendar[time=?,areFieldsSet=false,areAllFieldsSet=false,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Europe/Moscow",offset=10800000,dstSavings=0,useDaylight=false,transitions=79,lastRule=null],firstDayOfWeek=2,minimalDaysInFirstWeek=1,ERA=?,YEAR=2017,MONTH=0,WEEK_OF_YEAR=?,WEEK_OF_MONTH=?,DAY_OF_MONTH=25,DAY_OF_YEAR=?,DAY_OF_WEEK=?,DAY_OF_WEEK_IN_MONTH=?,AM_PM=0,HOUR=0,HOUR_OF_DAY=0,MINUTE=0,SECOND=0,MILLISECOND=?,ZONE_OFFSET=?,DST_OFFSET=?]

Tingnan kung gaano karaming impormasyon ang mayroon! Ang kalendaryo ay may isang bungkos ng mga katangian na ang isang regular na petsa ay wala, at lahat ng mga ito ay output sa console (ito ay kung paano gumagana ang pamamaraan toString()sa klase Calendar). Kung, kapag nagtatrabaho, kailangan mo lamang makakuha ng isang simpleng petsa mula sa kalendaryo, i.e. object Date- ito ay ginagawa gamit ang isang pamamaraan Calendar.getTime()(ang pangalan ay hindi ang pinaka-lohikal, ngunit walang magagawa):

public static void main(String[] args) {

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

Konklusyon:

Wed Jan 25 00:00:00 MSK 2017

Ngayon ay "pinasimple" na namin ang kalendaryo sa isang regular na petsa. Mag-move on na tayo. Bilang karagdagan sa mga numerical na simbolo para sa mga buwan, Calendarang mga constant ay maaaring gamitin sa silid-aralan. Ang mga Constant ay mga static na field ng isang klase Calendarna may nakatakdang halaga na hindi na mababago. Ang pagpipiliang ito ay talagang mas mahusay, dahil pinapabuti nito ang pagiging madaling mabasa ng code.

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

Calendar.JANUARY- isa sa mga constants para sa pagtukoy ng buwan. Sa pagpipiliang ito sa pagbibigay ng pangalan, walang makakalimutan, halimbawa, na ang bilang na "3" ay nangangahulugang Abril, at hindi ang ikatlong buwan na nakasanayan natin - Marso. Sumulat ka lang Calendar.APRIL- at iyon lang :) Ang lahat ng mga field ng kalendaryo (araw, buwan, minuto, segundo, atbp.) ay maaaring itakda nang isa-isa gamit ang pamamaraan set(). Ito ay napaka-maginhawa, dahil Calendarang bawat field ay may sariling pare-pareho sa klase, at ang panghuling code ay magiging simple hangga't maaari. Halimbawa, sa nakaraang halimbawa, gumawa kami ng petsa, ngunit hindi namin itinakda ang kasalukuyang oras para dito. Itakda natin ang oras sa 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());
}

Konklusyon:

Wed Jan 25 19:42:12 MSK 2017

Tinatawag namin ang pamamaraan set(), ipasa ang isang pare-pareho dito (depende sa field na gusto naming baguhin) at isang bagong halaga para sa field na ito. Lumalabas na ang pamamaraan set()ay isang uri ng "super-setter" na maaaring magtakda ng isang halaga hindi para sa isang patlang, ngunit para sa maraming mga patlang :) Ang pagdaragdag at pagbabawas ng mga halaga sa isang klase Calendaray isinasagawa gamit ang add(). Kailangan mong ipasa dito ang field na gusto mong baguhin, at ang numero - kung magkano ang gusto mong idagdag/ibawas mula sa kasalukuyang halaga. Halimbawa, itakda natin ang petsa na ginawa natin pabalik sa 2 buwan na nakalipas:

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 a value - a negative number must be passed to the method
   System.out.println(calendar.getTime());
}

Konklusyon:

Fri Nov 25 19:42:12 MSK 2016

Malaki! Itinakda namin ang petsa pabalik sa 2 buwan na nakalipas. Bilang isang resulta, hindi lamang ang buwan, kundi pati na rin ang taon ay nagbago, mula 2017 hanggang 2016. Ang pagkalkula ng kasalukuyang taon kapag ang paglipat ng mga petsa, siyempre, ay awtomatikong isinasagawa at hindi kailangang kontrolin nang manu-mano. Ngunit kung para sa ilang layunin kailangan mong huwag paganahin ang pag-uugaling ito, magagawa mo iyon. Ang isang espesyal na paraan roll()ay maaaring magdagdag at magbawas ng mga halaga nang hindi naaapektuhan ang iba pang mga halaga. Halimbawa, tulad nito:

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());
}

Pareho lang ang ginawa namin tulad ng sa nakaraang halimbawa - nagbawas kami ng 2 buwan mula sa kasalukuyang petsa. Ngunit ngayon ang code ay gumana nang iba: ang buwan ay nagbago mula Enero hanggang Nobyembre, ngunit ang taon ay nanatiling pareho sa 2017! Konklusyon:

Sat Nov 25 10:42:12 MSK 2017

Dagdag pa. Tulad ng sinabi namin sa itaas, ang lahat ng mga patlang ng isang bagay Calendaray maaaring makuha nang hiwalay. Ang pamamaraan ay responsable para dito 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("Number of the week in the month: " + calendar.get(Calendar.WEEK_OF_MONTH));// serial number of the week in the month

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

   System.out.println("Watch: " + 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));

}

Konklusyon:

Год: 2017 
Месяц: 0 
Порядковый номер недели в месяце: 4 
Число: 25 
Часы: 10 
Минуты: 42 
Секунды: 12 
Миллисекунды: 0

Iyon ay, bilang karagdagan sa "super-setter" sa klase Calendarmayroon ding "super-getter" :) Ang isa pang kawili-wiling punto ay, siyempre, nagtatrabaho sa mga panahon. Upang lumikha ng petsang "BC" kailangan mong gamitin ang field Calendar.Era Halimbawa, gumawa tayo ng petsa na nagpapahiwatig ng Labanan sa Cannae, kung saan natalo ni Hannibal ang hukbo ng Roma. Nangyari ito noong Agosto 2, 216 BC. e.:

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

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

Dito ginamit namin ang klase SimpleDateFormatupang ipakita ang petsa sa isang format na mas naiintindihan namin (ang mga titik na "GG" ay responsable para sa pagpapakita ng panahon). Konklusyon:

02 авг 216 до н.э.

CalendarMarami pang pamamaraan at constant sa klase , basahin ang tungkol sa mga ito sa dokumentasyon:

• Kalendaryo ng Klase

Kino-convert ang string sa Petsa

Upang i-convert ang String sa Petsa, maaari mong gamitin ang Java helper class - SimpleDateFormat . Ito ang klase na kailangan mong i-convert ang isang petsa sa isang format na iyong tinukoy. Sa turn, ito ay halos kapareho sa DateFormat . Ang tanging kapansin-pansing pagkakaiba sa pagitan ng dalawa ay ang SimpleDateFormat ay maaaring gamitin para sa pag-format (pag-convert ng petsa sa isang string) at pag-parse ng string sa isang locale-aware na petsa, samantalang ang DateFormat ay hindi sumusuporta sa isang locale. Bilang karagdagan, ang DateFormat ay isang abstract na klase na nagbibigay ng pangunahing suporta para sa pag-format at pag-parse ng mga petsa, habang ang SimpleDateFormat ay isang kongkretong klase na nagpapalawak sa klase ng DateFormat. Ito ang hitsura ng isang halimbawa ng paglikha ng isang SimpleDateFormat object at pag-format ng Petsa:

SimpleDateFormat formater = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = new Date(1212121212121L);

System.out.println(formatter.format(date));

Sa halimbawa sa itaas ginamit namin ang pattern na "yyyy-MM-dd HH:mm:ss" na nangangahulugang:

• 4 na digit para sa taon (yyyy);
• 2 digit para sa buwan (MM);
• 2 digit para sa araw (dd);
• 2 digit para sa mga oras sa 24 na oras na format (HH);
• 2 digit para sa mga minuto (mm);
• 2 digit para sa mga segundo (ss).

Ang mga marka ng paghihiwalay at ang pagkakasunud-sunod ng mga simbolo ng pattern ay napanatili. Output ng console:

2008-05-30 08:20:12

Mayroong napakaraming template na mga titik para sa klase ng SimpleDateFormat . Upang hindi ka malito, nakolekta namin ang mga ito sa isang talahanayan: Mga halimbawa ng mga kumbinasyon ng character na pattern: Kung nakagawa ka ng kaunting pagkakamali sa format, maaari kang maging may-ari ng isang java.text.ParseException, at hindi ito isang partikular na kaaya-ayang tagumpay. Well, ang maikling iskursiyon sa SimpleDateFormat ay tapos na - bumalik tayo sa pagsasalin ng java string hanggang sa kasalukuyan . Binibigyan kami ng SimpleDateFormat ng mga ganoong kakayahan, at tatalakayin namin ang prosesong ito nang hakbang-hakbang.

1. Lumikha ng isang linya kung saan kailangan mong itakda ang petsa:

   String strDate = "Sat, April 4, 2020";

2. Lumilikha kami ng bagong SimpleDateFormat object na may template na tumutugma sa kung ano ang mayroon kami sa string (kung hindi, hindi namin ito ma-parse):

   SimpleDateFormat formatter = new SimpleDateFormat("EEE, MMMM d, yyyy", Locale.ENGLISH);

   Tulad ng nakikita mo, mayroon kaming argumentong Lokal dito. Kung aalisin namin ito, gagamitin nito ang default na Locale, na hindi palaging Ingles.

   Kung hindi tumutugma ang locale sa input string, hindi makikilala ang string data na nakatali sa wika, tulad ng sa amin Mon o April , at maglalagay ng java.text.ParseException, kahit na tumutugma ang pattern.

   Gayunpaman, hindi namin kailangang tukuyin ang format kung gumagamit kami ng template na hindi partikular sa wika. Bilang halimbawa - yyyy-MM-dd HH:mm:ss

3. Lumilikha kami ng petsa gamit ang isang formatter, na kung saan ay na-parse ito mula sa input string:

   try {
     Date date = formatter.parse(strDate);
     System.out.println(date);
   }
   catch (ParseException e) {
     e.printStackTrace();
   }

   Output ng console:

   
   Sat Apr 04 00:00:00 EEST 2020

   Hmmm... Pero hindi na pareho ang format!

   Upang gawin ang parehong format, muli naming ginagamit ang formatter:

   System.out.println(formatter.format(date));

   Output ng console:

   
   Sat, April 4, 2020

SimpleDateFormat at Kalendaryo

Binibigyang-daan ka ng SimpleDateFormat na i-format ang lahat ng mga bagay sa Petsa at Kalendaryo na gagawin mo para magamit sa ibang pagkakataon. Isaalang-alang natin ang isang kawili-wiling punto tulad ng pagtatrabaho sa mga panahon. Upang lumikha ng petsa ng "BC", kailangan mong gamitin ang field na Calendar.Era. Halimbawa, gumawa tayo ng petsa na nagsasaad ng Labanan sa Cannae, kung saan natalo ni Hannibal ang hukbo ng Roma. Nangyari ito noong Agosto 2, 216 BC. e.:

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

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

Dito ginamit namin ang klase ng SimpleDateFormat upang ipakita ang petsa sa isang format na mas naiintindihan namin (tulad ng ipinahiwatig sa itaas, ang mga titik na "GG" ay responsable para sa pagpapakita ng panahon). Konklusyon:

02 авг 216 до н.э.

Format ng Petsa ng Java

Narito ang isa pang kaso. Ipagpalagay natin na ang format ng petsa na ito ay hindi angkop sa amin:

Sat Nov 25 10:42:12 MSK 2017

Kaya eto na. Gamit ang aming mga kakayahan sa java date format, maaari mo itong baguhin sa iyong sarili nang hindi nahihirapan:

public static void main(String[] args) {

   SimpleDateFormat dateFormat = new SimpleDateFormat("EEEE, d MMMM 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()));
}

Konklusyon:

суббота, 25 Ноябрь 2017

Much better, right? :)