1. Tinjauan Tanggal di Java <Br /> Tanggal adalah sepotong konten yang sangat kompleks di Java. Untuk tanggal di lingkungan bahasa dan negara yang berbeda, internasionalisasi tanggal, konversi antara tanggal dan waktu, penambahan dan pengurangan tanggal, dan format tampilan tanggal adalah masalah yang sangat rumit.
Di Java, tanggal operasi terutama melibatkan kelas -kelas berikut:
1. Java.util.date
Tanggal kelas mewakili momen tertentu, akurat untuk milidetik. Dimulai dengan JDK 1.1, kelas kalender harus digunakan untuk mengimplementasikan konversi antara bidang tanggal dan waktu, dan kelas DateFormat harus digunakan untuk memformat dan menganalisis string tanggal. Metode dalam tanggal untuk menafsirkan tanggal sebagai tahun, bulan, hari, jam, menit, dan nilai kedua ditinggalkan.
2. Java.text.dateFormat (kelas abstrak)
DateFormat adalah kelas abstrak subkelas format tanggal/waktu yang memformat dan menganalisis tanggal atau waktu dengan cara yang tidak tergantung bahasa. Subkelas pemformatan tanggal/waktu (seperti SimpleDateFormat) memungkinkan pemformatan (mis. Tanggal-> Teks), analisis (Teks-> Tanggal), dan standardisasi. Menunjukkan tanggal sebagai objek tanggal, atau sebagai jumlah milidetik mulai dari saat GMT (GMT) 1970, 1 Januari, 00:00:00.
3. Java.Text.SimpledateFormat (Subkelas Langsung DateFormat)
SimpleDateFormat adalah kelas spesifik yang memformat dan menganalisis tanggal dengan cara yang terkait dengan lokal. Ini memungkinkan pemformatan (tanggal-> teks), analisis (teks-> tanggal), dan normalisasi.
SimpleDateFormat memungkinkan Anda untuk memilih mode format tanggal waktu yang ditentukan pengguna. Namun, masih disarankan untuk menggunakan getTimeInstance, getDateInstance, atau getDateTimeInstance di DateFormat untuk membuat formatter-waktu baru.
4. Java.util.calendar (kelas abstrak)
Kelas Kalender adalah kelas abstrak yang menyediakan beberapa metode untuk mengubah momen tertentu menjadi satu set bidang kalender seperti tahun, bulan, day_of_month, jam, dll., Dan menyediakan beberapa metode untuk memanipulasi bidang kalender seperti mendapatkan tanggal minggu depan. Instan dapat dinyatakan sebagai nilai milidetik, yang merupakan offset dari zaman (mis., 00: 00: 00.000, GMT, 1 Januari 1970, GMT).
Seperti kelas-kelas yang peka terhadap lokal lainnya, kalender menyediakan metode kelas untuk mendapatkan objek umum jenis ini. Metode GetInstance Calendar mengembalikan objek kalender yang bidang kalendernya telah diinisialisasi dengan tanggal dan waktu saat ini.
5. java.util.gregoriancalendar (subkelas langsung kalender)
Gregoriancalendar adalah subkelas konkret dari kalender yang menyediakan sistem kalender standar yang digunakan oleh sebagian besar negara di dunia.
Gregoriancalendar adalah kalender hibrida yang mendukung sistem kalender Julian dan Gregorian dengan dukungan dari diskontinuitas tunggal, yang secara default sesuai dengan tanggal Gregorian ketika kalender Gregorian didirikan (beberapa negara didirikan pada 15 Oktober 1582, dan kemudian di negara lain). Tanggal mulai dapat diubah oleh penelepon dengan menelepon setgregorianchange ().
2. Penggunaan java.util.date
1. Pengantar API Java.util.Date
Kelas java.util.Date mewakili momen tertentu, akurat untuk milidetik. Ada banyak metode yang disediakan, tetapi banyak yang sudah ketinggalan zaman dan tidak dianjurkan. Daftar berikut hanya metode yang tidak ketinggalan zaman:
Ringkasan Metode Konstruksi
----------------------
Tanggal()
Tetapkan objek tanggal dan inisialisasi objek ini dengan waktu saat ini untuk menunjukkan waktu yang dialokasikan (akurat untuk milidetik).
Tanggal (Tanggal Panjang)
Tetapkan objek tanggal dan inisialisasi objek ini untuk mewakili jumlah milidetik yang ditentukan sejak waktu tolok ukur standar (disebut "Epoch", yaitu, 00:00:00 GMT pada 1 Januari 1970).
Ringkasan metode
----------------------
boolean setelah (tanggal kapan)
Menguji apakah tanggal ini setelah tanggal yang ditentukan.
boolean sebelumnya (tanggal kapan)
Menguji apakah tanggal ini sebelum tanggal yang ditentukan.
Objek clone ()
Mengembalikan salinan objek ini.
int compareto (tanggal lain)
Bandingkan urutan dua tanggal.
boolean sama (objek obj)
Bandingkan kesetaraan dua tanggal.
Long GetTime ()
Mengembalikan jumlah milidetik yang diwakili oleh objek tanggal ini sejak 1 Januari 1970 00:00:00 GMT.
int hashcode ()
Mengembalikan nilai kode hash dari objek ini.
void setTime (lama)
Tetapkan objek tanggal ini untuk mewakili titik waktu dalam waktu milidetik setelah 00:00:00 GMT pada 1 Januari 1970.
String tostring ()
Konversi objek tanggal ini ke string dari bentuk berikut: Dow mon dd hh: mm: ss zzz yyyy dimana:
Dow adalah satu hari dalam seminggu (Sun, Mon, Tue, Wed, Thu, Fri, Sat).
Mon adalah bulan (Jan, Feb, Mar, Apr, Mei, Jun, Jul, Agustus, Sep, Okt, Nov, Desember).
DD adalah hari di bulan Januari (01 hingga 31) ditampilkan sebagai angka desimal dua digit.
HH adalah jam dalam sehari (00 hingga 23), ditampilkan sebagai angka desimal dua digit.
Mm adalah menit (00 hingga 59) dalam satu jam dan ditampilkan sebagai angka desimal dua digit.
SS adalah jumlah detik (00 hingga 61) dalam satu menit, ditampilkan sebagai angka desimal dua digit.
ZZZ adalah zona waktu (dan mencerminkan waktu penghematan siang hari). Singkatan zona waktu standar mencakup singkatan zona waktu yang diakui oleh metode parse. Jika informasi zona waktu tidak disediakan, ZZZ kosong, yaitu tidak ada karakter yang disertakan sama sekali.
Yyyy adalah setahun, ditampilkan sebagai nomor desimal 4 digit.
Berikut adalah contoh komprehensif dari kelas tanggal:
testDate kelas publik {public static void main (string [] args) {testDate testDate = new testDate (); testDate.getSystemCurrentTime (); testDate.getCurrentDate (); } /** * Get the current system time* System.currentTimeMillis() returns the current system time, and the result starts at 0:00:00 on January 1, 1970. The number of milliseconds elapsed until the program execution and obtaining the system time* 1 second = 1000 milliseconds*/ public void getSystemCurrentTime(){ System.out.println("---get the current system waktu---"); System.out.println (System.CurrentTimeMillis ()); } public void getCurrentDate () {System.out.println ("--- Dapatkan waktu sistem saat ini ---"); // Buat dan inisialisasi tanggal (nilai awal adalah tanggal saat ini) Tanggal = Tanggal baru (); System.out.println ("Tanggal saat ini adalah =" + date.toString ()); System.out.println ("Jumlah milidetik yang dialami sejak 1 Januari 1970 =" + date.getTime ()); }} 2. Penggunaan kelas abstrak java.text.dateFormat
DateFormat adalah kelas abstrak subkelas format tanggal/waktu yang memformat dan menganalisis tanggal atau waktu dengan cara yang tidak tergantung bahasa. Subkelas pemformatan tanggal/waktu (seperti SimpleDateFormat) memungkinkan pemformatan (mis. Tanggal-> Teks), analisis (Teks-> Tanggal), dan standardisasi. Menunjukkan tanggal sebagai objek tanggal, atau sebagai jumlah milidetik mulai dari saat GMT (GMT) 1970, 1 Januari, 00:00:00.
DateFormat menyediakan sejumlah metode kelas untuk mendapatkan formatter tanggal/waktu default berdasarkan default atau gaya lokal dan beberapa gaya pemformatan. Gaya format termasuk penuh, panjang, sedang dan pendek. Rincian lebih lanjut dan contoh menggunakan gaya ini disediakan dalam deskripsi metode.
DateFormat membantu memformat dan menganalisis tanggal untuk lokal mana pun. Selama berbulan -bulan, berminggu -minggu, dan bahkan format kalender (kalender bulan dan matahari), kode ini dapat sepenuhnya tidak relevan dengan konvensi lokal.
Untuk memformat tanggal di lokasi saat ini, gunakan metode pabrik statis:
myString = dateFormat.getDateInstance (). Format (mydate);
Jika Anda memformat beberapa tanggal, lebih efisien untuk mendapatkan format dan menggunakannya beberapa kali, sehingga sistem tidak harus mendapatkan informasi tentang bahasa lingkungan dan perjanjian nasional beberapa kali.
DateFormat df = dateFormat.getDateInstance (); untuk (int i = 0; i <mydate.length; ++ i) {output.println (df.format (mydate [i]) +";"); }
Untuk memformat tanggal berbagai lokal, tentukan dalam panggilan untuk getDateInstance ().
DateFormat df = dateFormat.getDateInstance (dateFormat.long, locale.france);
DateFormat juga dapat digunakan untuk analisis.
mydate = df.parse (myString);
Gunakan GetDateInstance untuk mendapatkan format tanggal standar untuk negara itu. Beberapa metode pabrik statis lainnya juga disediakan. Gunakan GetTimeInstance untuk mendapatkan format waktu untuk negara itu. Gunakan getDateTimeInstance untuk mendapatkan format tanggal dan waktu. Opsi yang berbeda dapat diteruskan ke metode pabrik ini untuk mengontrol panjang hasil (dari pendek hingga sedang hingga panjang hingga penuh). Hasil yang tepat tergantung pada lokal, tetapi biasanya:
Short benar -benar angka, seperti 12.13.52 atau 3:30 sore
Medium lebih panjang, seperti 12 Januari 1952
Panjang lebih lama, seperti 12 Januari 1952 atau 3:30:32
Penuh sepenuhnya ditentukan, seperti Selasa, 12 April 1952 AD atau 3:30:42 PM PST.
Jika Anda suka, Anda juga dapat mengatur zona waktu pada format. Jika Anda ingin memaksakan lebih banyak kontrol pada pemformatan atau analisis (atau memberi pengguna lebih banyak kontrol), Anda dapat mencoba melemparkan Format Tanggal yang diperoleh dari metode pabrik untuk SimpledateFormat. Ini bekerja untuk sebagian besar negara; Ingatlah untuk meletakkannya di blok mencoba dalam kasus format khusus.
Anda juga dapat menggunakan metode analisis dan pemformatan dengan parsosisi dan posisi lapangan untuk menganalisis bagian -bagian string langkah demi langkah. Sejajarkan bidang tertentu, atau cari tahu di mana string dipilih di layar.
DateFormat tidak sinkron. Disarankan untuk membuat instance format independen untuk setiap utas. Jika beberapa utas mengakses format secara bersamaan, itu harus tetap disinkronkan secara eksternal.
3. Penggunaan Java.Text.SimpledateFormat (Subkelas Langsung DateFormat)
SimpleDateFormat adalah kelas spesifik yang memformat dan menganalisis tanggal dengan cara yang terkait dengan lokal. Ini memungkinkan pemformatan (tanggal-> teks), analisis (teks-> tanggal), dan normalisasi.
SimpleDateFormat memungkinkan Anda untuk memilih mode format tanggal waktu yang ditentukan pengguna. Namun, masih disarankan untuk menggunakan getTimeInstance, getDateInstance, atau getDateTimeInstance di DateFormat untuk membuat formatter-waktu baru. Setiap metode kelas tersebut dapat mengembalikan formatter tanggal/waktu yang diinisialisasi dalam mode format default. Pola format dapat dimodifikasi menggunakan metode ApplyPattern sesuai kebutuhan. Untuk informasi lebih lanjut tentang penggunaan metode ini, lihat DateFormat.
Mode tanggal dan waktu
Format tanggal dan waktu ditentukan oleh string pola tanggal dan waktu. Dalam string pola tanggal dan waktu, huruf yang tidak dikutip 'a' hingga 'z' dan 'a' hingga 'z' ditafsirkan sebagai huruf pola untuk mewakili elemen string tanggal atau waktu. Teks dapat dilampirkan dalam kutipan tunggal (') untuk menghindari penjelasan. "''" berarti satu kutipan. Semua karakter lain tidak ditafsirkan; Mereka hanya disalin ke string output saat diformat, atau dicocokkan dengan string input saat dianalisis.
Untuk informasi referensi lebih lanjut, Anda dapat melihat dokumentasi API JDK. Berikut adalah contoh yang komprehensif:
public class testDateFormat {public static void main (string [] args) melempar parseException {testDateFormat tdf = new testDateFormat (); tdf.dateFormat (); } /*** Uji kelas SimpleDateFormat* @throws ParseException* /public void DateFormat () melempar parseException {// Buat tanggal tanggal = tanggal baru (); // Buat format tanggal yang berbeda DateFormat df1 = dateFormat.getInstance (); DateFormat df2 = new SimpleDateFormat ("yyyy-mm-01 hh: mm: ss ee"); DateFormat DF3 = DateFormat.GetDateInstance (DateFormat.Full, Locale.china); // Buat format tanggal dengan panjang tertentu dari negara yang ditentukan. Panjangnya berbeda, dan integritas tanggal yang ditampilkan juga berbeda. DateFormat df4 = new SimpleDateFormat ("yyyyy tahun mm bulan dd hari hh jam mm menit ss detik ee", locale.china); DateFormat df5 = new SimpleDateFormat ("yyyy-mm-dd hh: mm: ss eeeeee", locale.us); DateFormat df6 = new SimpleDateFormat ("yyyy-mm-dd"); // tanggal output dalam format yang berbeda System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- df3.format (tanggal)); DF5.Format (Tanggal)); Date Date2 = df2.parse ("2016-01-24 02:51:07 Minggu"); Tanggal Tanggal3 = DF3.Parse ("2016-01-24"); Tanggal Tanggal4 = DF4.Parse ("2016-01-24 02:51:18 Minggu"); Tanggal Tanggal6 = df6.parse ("2016-01-24"); System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- System.out.println (Date2); 4. Java.util.calendar (kelas abstrak)
java.util.calendar adalah kelas abstrak, representasi abstrak waktu sistem. Ini menyediakan beberapa metode untuk mengubah momen tertentu ke satu set bidang kalender seperti tahun, bulan, day_of_month, jam, dll., Dan menyediakan beberapa metode untuk memanipulasi bidang kalender (seperti mendapatkan tanggal minggu depan). Instan dapat dinyatakan sebagai nilai milidetik, yang merupakan offset dari zaman (mis., 00: 00: 00.000, GMT, 1 Januari 1970, GMT).
Seperti kelas-kelas yang peka terhadap lokal lainnya, kalender menyediakan metode kelas untuk mendapatkan objek umum jenis ini. Metode GetInstance Calendar mengembalikan objek kalender yang bidang kalendernya telah diinisialisasi dengan tanggal dan waktu saat ini.
Contoh kalender adalah representasi abstrak dari waktu sistem. Dari contoh kalender, Anda dapat mengetahui informasi seperti tahun, bulan, hari, minggu, bulan, dan bulan. Ada metode statis Get (int x) di kelas kalender. Melalui metode ini, Anda bisa mendapatkan beberapa nilai (tahun, bulan, hari, minggu, bulan, dll.) Informasi dari contoh yang relevan. Parameter x adalah nilai hasil, didefinisikan dalam kalender.
Beberapa perangkap dalam kalender dapat dengan mudah jatuh:
1. Minggu kalender dimulai pada hari Minggu, dengan nilai konstan 0.
2. Bulan kalender dimulai dari Januari, dengan nilai konstan 0.
3. Hari pertama kalender setiap bulan adalah 1.
5. java.util.gregoriancalendar (subkelas langsung kalender)
Gregoriancalendar adalah subkelas konkret dari kalender yang menyediakan sistem kalender standar yang digunakan oleh sebagian besar negara di dunia. Digunakan bersama dengan kelas abstrak kalender.
Berikut adalah contoh komprehensif untuk melihat penggunaan kelas kalender:
TestCalendar kelas publik {public static void main (string [] args) melempar parseException {testCalendar testCalendar = new testCalendar (); testcalendar.testcalendar (); testcalendar.testcalendar2 (); } public void testCalendar () {// Cara membuat kalender kalender kalender sekarang1 = calendar.getInstance (); Kalender sekarang2 = gregoriancalendar baru (); Kalender sekarang3 = Gregoriancalendar baru (2016, 01, 24); Kalender sekarang4 = Gregoriancalendar baru (2016, 01, 24, 15, 55); // jejak: Bulan kalender adalah 0 ~ 11 kalender sekarang5 = Gregoriancalendar baru (2016, 01, 24, 15, 55, 44); Kalender sekarang6 = Gregoriancalendar baru (locale.us); Kalender Now7 = GregorianCalendar baru (TimeZone.GetTimezone ("GMT-8: 00")); // atur kalender sekarang2.settime (tanggal baru ()); System.out.println (Now2); Now. System.out.println (Now2); // Tentukan format output Cina dari tanggal dan output tanggal SimpleDateFormat df = new SimpleDateFormat ("yyyyy tahun mm bulan dd hari hh jam mm menit ss detik e", local.china); System.out.println ("Dapatkan output yang diformat oleh Cina dari tanggal:" + df.format (sekarang5.gettime ())); System.out.println (); System.out.println ("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- System.out.println (" Dapatkan tahun: " + Now5.get (calendar.year); out.out.ute. Now5.get (Calendar.month)); Now5.get (Calendar.Second)); System.out.println ("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- "March", "April", "Mei", "Juni", "Juli", "August", "September", "Oktober", "November", "Desember"}; System.out.println ("Bulan Now5 Object adalah:" + bulan [sekarang5.get (calendar.month)]); } public void testCalendar2 () melempar parseException {// dapatkan jumlah maksimum hari dalam kalender bulan saat ini cal = calendar.getInstance (); int maxday = cal.getActualMaximum (calendar.day_of_month); int mindday = cal.getActualMinimum (calendar.day_of_month); System.out.println (Maxday); // Ambil hari terakhir dari bulan ini formatterformat3 = new SimpleDateFormat ("yyyy-mm-"+maxday); System.out.println (format3.format (cal.getTime ())); // Ambil hari terakhir bulan ini formatterFormat4 = new SimpleDateFormat ("yyyy-mm-"+minday); System.out.println (formatter4.format (cal.getTime ())); // Temukan jumlah hari antara dua tanggal java.text.simpledateFormat format = new java.text.simpledateFormat ("yyyy-mm-dd"); java.util.date begindate = format.parse ("2007-12-24"); java.util.date enddate = format.parse ("2007-12-25"); Long Day = (EndDate.GetTime ()-Begindate.getTime ())/(24*60*60*1000); System.out.println ("Jumlah hari terpisah ="+hari); // tanggal satu tahun yang lalu java.text.format formatter5 = new java.text.simpledateFormat ("yyyy-mm-dd"); java.util.date todayDate = java.util.date baru (); long beforetime = (TodayDate.GetTime ()/1000) -60*60*24*365; TodayDate.SetTime (Beforetime*1000); String beforedate = formatter5.format (TodayDate); System.out.println (Beforedate); Kalender kalender = calendar.getInstance (); calendar.add (calendar.ear, -1); System.out.println (formatter5.format (calendar.getTime ())); // Senin dan Minggu dari minggu ini SimpleDateFormat DateFormat = new SimpleDateFormat ("yyyymmdd"); Gregoriancalendar Gregoriancalendar = Gregoriancalendar baru (); int dayinweek = gregoriancalendar.get (calendar.day_of_week); int offset = 0; if (dayinweek == 1) {// Sunday offset = 6; } else {// Senin hingga Sabtu offset = DayInweek - 2; } gregoriancalendar.add (gregoriancalendar.day_of_month, -offset); String sday = dateFormat.format (gregoriancalendar.getTime ()); gregoriancalendar.add (gregoriancalendar.day_of_month, 6); String eday = dateFormat.format (gregoriancalendar.getTime ()); System.out.println ("Senin minggu ini:" + SDay); System.out.println ("Minggu minggu ini:" + eday); }}3. Ringkasan
Sering ada lima aspek tanggal di Java:
1. Tanggal Penciptaan
2. Tampilan Format Tanggal
3. Konversi tanggal (terutama konversi timbal balik dengan string)
4. Dapatkan tanggal usia paruh baya, bulan, hari, jam, menit, kedua, minggu, bulan, dll.
5. Perbandingan ukuran tanggal dan penambahan dan pengurangan tanggal.
Di atas adalah metode penggunaan tanggal dan waktu Java yang dirangkum untuk Anda. Saya harap ini akan membantu pembelajaran Anda.