Français

Tutoriel Java

Instructions de contrôle Java

Programmation orientée objet

Classes intégrées Java

Gestion des fichiers Java

Erreurs et exceptions Java

Java Multithreading

Synchronisation de Java

Réseau Java

Collections Java

Interfaces Java

Structures de données Java

Algorithmes de Collections Java

Java avancé

Divers Java

Références de classes Java

Java 8 - Nouvelle API Date-Time

Bonjour là-bas, futurs magiciens Java ! ? Aujourd'hui, nous allons entreprendre un voyage passionnant à travers le royaume magique de l'API Date-Time de Java. Ne vous inquiétez pas si vous n'avez jamais écrit une ligne de code auparavant - nous allons commencer du tout début et progresser ensemble. D'ici la fin de cette leçon, vous serez capable de jongler avec les dates et les heures comme un pro ! Alors, plongeons dedans !

Java - Datetime Api

Introduction à l'API Date-Time de Java

Imaginez que vous construisez une machine à temps (cool, non ?). Pour qu'elle fonctionne, vous devriez gérer les dates et les heures avec précision. C'est exactement ce que l'API Date-Time de Java nous aide à faire dans nos programmes. C'est comme avoir une horloge et un calendrier super-précis en un seul !

Pourquoi une nouvelle API ?

Avant de rentrer dans les détails, vous vous demandez peut-être : "Pourquoi Java a-t-il créé une nouvelle API Date-Time ?" Eh bien, laissez-moi vous raconter une petite histoire.

Il fut un temps (avant Java 8), où les développeurs devaient utiliser les vieilles classes java.util.Date et java.util.Calendar. Ces classes étaient comme utiliser une vieille horloge rouillée - elles fonctionnaient, mais elles avaient beaucoup de problèmes. Elles étaient difficiles à utiliser, pas thread-safe (ce qui signifie qu'elles pouvaient causer des problèmes dans des programmes complexes), et ne géraient pas bien les fuseaux horaires.

Ainsi, l'équipe Java a décidé de créer une nouvelle API brillante qui résoudrait tous ces problèmes. Et c'est ainsi que le paquet java.time est né avec Java 8 !

API Date-Time Locale de Java

Commençons par les bases. L'API Date-Time Locale nous aide à travailler avec des dates et des heures sans se soucier des fuseaux horaires. C'est comme avoir une simple horloge et un calendrier sur votre bureau.

LocalDate

LocalDate représente une date sans fuseau horaire. Voici comment l'utiliser :

import java.time.LocalDate;

public class DateExample {
public static void main(String[] args) {
LocalDate aujourd'hui = LocalDate.now();
System.out.println("La date d'aujourd'hui est : " + aujourd'hui);

LocalDate dateSpecifique = LocalDate.of(2023, 6, 15);
System.out.println("Une date spécifique : " + dateSpecifique);
}
}

Dans cet exemple, nous faisons deux choses :

  1. Nous obtenons la date d'aujourd'hui en utilisant LocalDate.now().
  2. Nous créons une date spécifique (15 juin 2023) en utilisant LocalDate.of().

Lorsque vous exécutez ce code, vous verrez la date d'aujourd'hui et la date spécifique que nous avons créée affichées.

LocalTime

LocalTime représente une heure sans date ou fuseau horaire. Voici comment l'utiliser :

import java.time.LocalTime;

public class TimeExample {
public static void main(String[] args) {
LocalTime maintenant = LocalTime.now();
System.out.println("L'heure actuelle est : " + maintenant);

LocalTime heureSpecifique = LocalTime.of(14, 30, 45);
System.out.println("Une heure spécifique : " + heureSpecifique);
}
}

Dans cet exemple :

  1. Nous obtenons l'heure actuelle en utilisant LocalTime.now().
  2. Nous créons une heure spécifique (14h30m45s) en utilisant LocalTime.of().

LocalDateTime

LocalDateTime combine à la fois la date et l'heure, mais toujours sans fuseau horaire. C'est comme avoir une horloge qui montre également la date. Voici comment l'utiliser :

import java.time.LocalDateTime;

public class DateTimeExample {
public static void main(String[] args) {
LocalDateTime maintenant = LocalDateTime.now();
System.out.println("Date et heure actuelles : " + maintenant);

LocalDateTime dateTimeSpecifique = LocalDateTime.of(2023, 6, 15, 14, 30, 45);
System.out.println("Une date et heure spécifiques : " + dateTimeSpecifique);
}
}

Dans cet exemple :

  1. Nous obtenons la date et l'heure actuelles en utilisant LocalDateTime.now().
  2. Nous créons une date et une heure spécifiques (15 juin 2023 à 14h30m45s) en utilisant LocalDateTime.of().

API Date-Time Zonée de Java

Maintenant, ajoutons un peu d'épice à notre machine à temps - les fuseaux horaires ! L'API Date-Time Zonée nous aide à travailler avec des dates et des heures en tenant compte des différents fuseaux horaires.

ZonedDateTime

ZonedDateTime représente une date et une heure avec un fuseau horaire. C'est comme avoir une horloge mondiale qui montre différentes heures pour différentes parties du monde.

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

public class ZonedDateTimeExample {
public static void main(String[] args) {
ZonedDateTime maintenantDansSystemTZ = ZonedDateTime.now();
System.out.println("Date et heure actuelles dans le fuseau horaire du système : " + maintenantDansSystemTZ);

ZonedDateTime maintenantAParis = ZonedDateTime.now(ZoneId.of("Europe/Paris"));
System.out.println("Date et heure actuelles à Paris : " + maintenantAParis);
}
}

Dans cet exemple :

  1. Nous obtenons la date et l'heure actuelles dans le fuseau horaire du système en utilisant ZonedDateTime.now().
  2. Nous obtenons la date et l'heure actuelles à Paris en utilisant ZonedDateTime.now(ZoneId.of("Europe/Paris")).

Énumération ChronoUnit de Java

L'énumération ChronoUnit fournit un ensemble de périodes standard de date et d'unités de temps. C'est comme avoir différents outils de mesure pour le temps - secondes, minutes, heures, jours, semaines, mois, années, etc.

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

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

long joursEntre = ChronoUnit.DAYS.between(maintenant, dateTimeFutur);
System.out.println("Jours entre maintenant et une semaine à partir de maintenant : " + joursEntre);
}
}

Dans cet exemple :

  1. Nous ajoutons une semaine à la date et l'heure actuelles en utilisant plus(1, ChronoUnit.WEEKS).
  2. Nous calculons le nombre de jours entre maintenant et une semaine à partir de maintenant en utilisant ChronoUnit.DAYS.between().

Période et Durée de Java

Period et Duration sont utilisés pour représenter des quantités de temps. Pensez à Period comme la différence entre deux dates sur un calendrier, et à Duration comme le temps affiché sur un chronomètre.

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 periode = Period.between(date1, date2);
System.out.println("Période entre " + date1 + " et " + date2 + " : " + periode);

LocalTime heure1 = LocalTime.of(9, 0);
LocalTime heure2 = LocalTime.of(17, 30);
Duration duree = Duration.between(heure1, heure2);
System.out.println("Durée entre " + heure1 + " et " + heure2 + " : " + duree);
}
}

Dans cet exemple :

  1. Nous calculons la période entre deux dates en utilisant Period.between().
  2. Nous calculons la durée entre deux heures en utilisant Duration.between().

Ajusteurs Temporaux de Java

Les ajusteurs temporels sont comme des baguettes magiques pour les dates. Ils vous permettent d'ajuster les dates de manière utile, comme trouver lundi prochain ou le dernier jour du mois.

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

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

LocalDate dernierJourDuMois = date.with(TemporalAdjusters.lastDayOfMonth());
System.out.println("Dernier jour de ce mois : " + dernierJourDuMois);
}
}

Dans cet exemple :

  1. Nous trouvons la date de lundi prochain en utilisant TemporalAdjusters.next(DayOfWeek.MONDAY).
  2. Nous trouvons le dernier jour du mois en cours en utilisant TemporalAdjusters.lastDayOfMonth().

Compatibilité Régressive

Maintenant, vous vous demandez peut-être : "Et tout le vieux code qui utilise les vieilles classes de date et d'heure ?" Ne vous inquiétez pas ! Java a pensé à cela aussi. La nouvelle API fournit des méthodes pour convertir entre les vieilles et les nouvelles classes de date et d'heure.

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

public class BackwardCompatibilityExample {
public static void main(String[] args) {
// Conversion de l'ancien Date en nouveau LocalDateTime
Date ancienDate = new Date();
LocalDateTime nouveauDateTime = LocalDateTime.ofInstant(ancienDate.toInstant(), ZoneId.systemDefault());
System.out.println("Ancien Date : " + ancienDate);
System.out.println("Nouveau LocalDateTime : " + nouveauDateTime);

// Conversion du nouveau LocalDateTime en ancien Date
LocalDateTime localDateTime = LocalDateTime.now();
Date date = Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
System.out.println("Nouveau LocalDateTime : " + localDateTime);
System.out.println("Ancien Date : " + date);
}
}

Dans cet exemple :

  1. Nous convertissons un objet Date ancien en un objet LocalDateTime nouveau.
  2. Nous convertissons un objet LocalDateTime nouveau en un objet Date ancien.

Cette compatibilité régressive nous assure que nous pouvons toujours travailler avec du vieux code Java tout en profitant des avantages de la nouvelle API Date-Time.

Conclusion

Félicitations ! Vous avez刚刚 taken vos premiers pas dans le monde de l'API Date-Time de Java. Nous avons couvert beaucoup de terrain, des bases de la manipulation des dates et des heures aux concepts plus avancés comme les fuseaux horaires et les ajusteurs temporels.

N'oubliez pas que, comme toute compétence, maîtriser la date et l'heure en Java nécessite de la pratique. Ne soyez pas découragé si cela semble accablant au début - même les développeurs expérimentés ont parfois besoin de chercher comment utiliser ces classes !

Continuez à expérimenter avec ces exemples, modifiez-les, et voyez ce qui se passe. Avant de savoir, vous serez capable de manipuler les dates et les heures comme un vrai voyageur temporel Java !

Bonne programmation, et peut-être que votre timing sera toujours parfait ! ⏰?

Credits: Image by storyset

Tutoriel précédent:
Java - Flux
Tutoriel suivant:
Java 8 - Nouvelles Fonctionnalités