Java 8 - New Date-Time API

Halo sana, para ahli Java masa depan! ? Hari ini, kita akan memulai perjalanan menarik melalui realm magis API Date-Time Java. Jangan khawatir jika Anda belum pernah menulis baris kode sebelumnya - kita akan memulai dari awal dan bekerja bersama-sama menuju atas. Pada akhir pelajaran ini, Anda akan menjadi ahli dalam mengelola tanggal dan waktu! Jadi, mari kita masuk ke dalam!

Java - Datetime Api

Pengenalan ke API Date-Time Java

Bayangkan Anda sedang membuat mesin waktu (keren, kan?). Untuk membuatnya bekerja, Anda akan perlu mengelola tanggal dan waktu dengan presisi. Itu tepat apa yang API Date-Time Java membantu kita lakukan dalam program kita. Itu seperti memiliki jam dan kalender super akurat yang digabungkan!

Mengapa API Baru?

Sebelum kita masuk ke detil, Anda mungkin bertanya-tanya, "Mengapa Java menciptakan API Date-Time baru?" Baik, mari saya ceritakan kecil kecil cerita.

Pada zaman dulu (sebelum Java 8), pengembang harus menggunakan kelas java.util.Date dan java.util.Calendar yang lama. Ini seperti menggunakan jam logam yang keras - mereka bisa bekerja, tapi mereka punya banyak masalah. Mereka sulit digunakan, tidak aman untuk thread (yang berarti mereka bisa menyebabkan masalah dalam program kompleks), dan tidak menangani zona waktu dengan baik.

Jadi, tim Java memutuskan untuk menciptakan API baru, bersinar dan memecahkan masalah ini semua. Dan begitupunlah, paket java.time lahir di Java 8!

API Date-Time Lokal Java

Ayo mulai dengan dasar. API Date-Time Lokal membantu kita bekerja dengan tanggal dan waktu tanpa khawatir tentang zona waktu. Itu seperti memiliki jam dan kalender sederhana di atas meja Anda.

LocalDate

LocalDate mewakili tanggal tanpa zona waktu. Mari lihat bagaimana menggunakannya:

import java.time.LocalDate;

public class DateExample {
public static void main(String[] args) {
LocalDate today = LocalDate.now();
System.out.println("Tanggal hari ini adalah: " + today);

LocalDate specificDate = LocalDate.of(2023, 6, 15);
System.out.println("Tanggal tertentu: " + specificDate);
}
}

Dalam contoh ini, kita melakukan dua hal:

Kita mendapatkan tanggal hari ini menggunakan LocalDate.now().
Kita membuat tanggal tertentu (15 Juni 2023) menggunakan LocalDate.of().

Ketika Anda menjalankan kode ini, Anda akan melihat tanggal hari ini dan tanggal tertentu yang Anda buat dicetak.

LocalTime

LocalTime mewakili waktu tanpa tanggal atau zona waktu. Ini adalah bagaimana kita bisa menggunakannya:

import java.time.LocalTime;

public class TimeExample {
public static void main(String[] args) {
LocalTime now = LocalTime.now();
System.out.println("Waktu saat ini adalah: " + now);

LocalTime specificTime = LocalTime.of(14, 30, 45);
System.out.println("Waktu tertentu: " + specificTime);
}
}

Dalam contoh ini:

Kita mendapatkan waktu saat ini menggunakan LocalTime.now().
Kita membuat waktu tertentu (2:30:45 PM) menggunakan LocalTime.of().

LocalDateTime

LocalDateTime menggabungkan tanggal dan waktu, tetapi masih tanpa zona waktu. Itu seperti memiliki jam yang juga menunjukkan tanggal. Ini adalah bagaimana menggunakannya:

import java.time.LocalDateTime;

public class DateTimeExample {
public static void main(String[] args) {
LocalDateTime now = LocalDateTime.now();
System.out.println("Tanggal dan waktu saat ini: " + now);

LocalDateTime specificDateTime = LocalDateTime.of(2023, 6, 15, 14, 30, 45);
System.out.println("Tanggal dan waktu tertentu: " + specificDateTime);
}
}

Dalam contoh ini:

Kita mendapatkan tanggal dan waktu saat ini menggunakan LocalDateTime.now().
Kita membuat tanggal dan waktu tertentu (15 Juni 2023, pukul 2:30:45 PM) menggunakan LocalDateTime.of().

API Date-Time Zoned Java

Sekarang, mari kita tambahkan sedikit rempah-rempah ke mesin waktu kita - zona waktu! API Date-Time Zoned membantu kita bekerja dengan tanggal dan waktu saat mempertimbangkan zona waktu berbeda.

ZonedDateTime

ZonedDateTime mewakili tanggal-waktu dengan zona waktu. Itu seperti memiliki jam dunia yang menunjukkan waktu berbeda untuk bagian dunia yang berbeda.

import java.time.ZonedDateTime;
import java.time.ZoneId;

public class ZonedDateTimeExample {
public static void main(String[] args) {
ZonedDateTime nowInSystemTZ = ZonedDateTime.now();
System.out.println("Tanggal-waktu saat ini dalam zona waktu sistem: " + nowInSystemTZ);

ZonedDateTime nowInParis = ZonedDateTime.now(ZoneId.of("Europe/Paris"));
System.out.println("Tanggal-waktu saat ini di Paris: " + nowInParis);
}
}

Dalam contoh ini:

Kita mendapatkan tanggal-waktu saat ini dalam zona waktu sistem default menggunakan ZonedDateTime.now().
Kita mendapatkan tanggal-waktu saat ini di Paris menggunakan ZonedDateTime.now(ZoneId.of("Europe/Paris")).

Enum ChronoUnit Java

Enum ChronoUnit menyediakan set standar periode waktu dan unit waktu. Itu seperti memiliki berbagai alat pengukur waktu - detik, menit, jam, hari, minggu, bulan, tahun, dan lainnya.

import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;

public class ChronoUnitExample {
public static void main(String[] args) {
LocalDateTime now = LocalDateTime.now();
LocalDateTime futureDateTime = now.plus(1, ChronoUnit.WEEKS);

long daysBetween = ChronoUnit.DAYS.between(now, futureDateTime);
System.out.println("Hari antara saat ini dan minggu mendatang: " + daysBetween);
}
}

Dalam contoh ini:

Kita menambahkan satu minggu ke tanggal-waktu saat ini menggunakan plus(1, ChronoUnit.WEEKS).
Kita menghitung jumlah hari antara saat ini dan minggu mendatang menggunakan ChronoUnit.DAYS.between().

Period dan Duration Java

Period dan Duration digunakan untuk mewakili jumlah waktu. PERTIKAHAN Period sebagai perbedaan antara dua tanggal di kalender, dan Duration seperti waktu ditunjukkan pada stopwatch.

import java.time.LocalDate;
import java.time.Period;
import java.time.Duration;
import java.time.LocalTime;

public class PeriodDurationExample {
public static void main(String[] args) {
LocalDate date1 = LocalDate.of(2023, 1, 1);
LocalDate date2 = LocalDate.of(2023, 12, 31);
Period period = Period.between(date1, date2);
System.out.println("Periode antara " + date1 + " dan " + date2 + ": " + period);

LocalTime time1 = LocalTime.of(9, 0);
LocalTime time2 = LocalTime.of(17, 30);
Duration duration = Duration.between(time1, time2);
System.out.println("Durasi antara " + time1 + " dan " + time2 + ": " + duration);
}
}

Dalam contoh ini:

Kita menghitung period antara dua tanggal menggunakan Period.between().
Kita menghitung durasi antara dua waktu menggunakan Duration.between().

Temporal Adjusters Java

Temporal Adjusters seperti tongkat sihir untuk tanggal. Mereka memungkinkan Anda menyesuaikan tanggal dalam cara yang berguna, seperti menemukan hari Senin berikutnya atau hari terakhir bulan.

import java.time.LocalDate;
import java.time.temporal.TemporalAdjusters;

public class TemporalAdjustersExample {
public static void main(String[] args) {
LocalDate date = LocalDate.now();
LocalDate nextMonday = date.with(TemporalAdjusters.next(DayOfWeek.MONDAY));
System.out.println("Hari Senin berikutnya: " + nextMonday);

LocalDate lastDayOfMonth = date.with(TemporalAdjusters.lastDayOfMonth());
System.out.println("Hari terakhir bulan ini: " + lastDayOfMonth);
}
}

Dalam contoh ini:

Kita menemukan tanggal hari Senin berikutnya menggunakan TemporalAdjusters.next(DayOfWeek.MONDAY).
Kita menemukan hari terakhir bulan ini menggunakan TemporalAdjusters.lastDayOfMonth().

Kesesuaian Mundur

Sekarang, Anda mungkin bertanya-tanya, "Apa yang terjadi dengan semua kode lama yang menggunakan kelas tanggal dan waktu lama?" Jangan khawatir! Java telah memikirkan hal ini. API baru menyediakan metode untuk mengkonversi antara kelas tanggal-waktu lama dan baru.

import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Date;

public class BackwardCompatibilityExample {
public static void main(String[] args) {
// Mengkonversi Date lama ke LocalDateTime baru
Date oldDate = new Date();
LocalDateTime newDateTime = LocalDateTime.ofInstant(oldDate.toInstant(), ZoneId.systemDefault());
System.out.println("Date lama: " + oldDate);
System.out.println("LocalDateTime baru: " + newDateTime);

// Mengkonversi LocalDateTime baru ke Date lama
LocalDateTime localDateTime = LocalDateTime.now();
Date date = Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
System.out.println("LocalDateTime baru: " + localDateTime);
System.out.println("Date lama: " + date);
}
}

Dalam contoh ini:

Kita mengkonversi objek Date lama ke LocalDateTime baru.
Kita mengkonversi LocalDateTime baru ke objek Date lama.

Kesesuaian mundur ini memastikan bahwa Anda masih dapat bekerja dengan kode Java lama saat menikmati keuntungan API Date-Time baru.

Kesimpulan

Selamat! Anda telah mengambil langkah pertama ke dunia API Date-Time Java. Kita telah menempuh jarak yang cukup, dari penggunaan dasar tanggal dan waktu hingga konsep yang lebih maju seperti zona waktu dan penyesuaian temporal.

Ingat, seperti setiap keterampilan, memahami tanggal dan waktu di Java memerlukan latihan. Jangan frustasi jika Anda merasa terlalu banyak pada awalnya - bahkan pengembang berpengalaman kadang-kadang perlu mencari referensi!

Tetap mencoba contoh ini, ubah mereka, dan lihat apa yang terjadi. Sebelum Anda tahu, Anda akan menjadi ahli dalam mengelola tanggal dan waktu! Selamat coding, dan semoga waktu Anda selalu sempurna! ⏰?

Credits: Image by storyset

Tutorial Sebelumnya:

Java - Streams

Tutorial Selanjutnya:

Java 8 - Fitur Baru