Comment utiliser l'API Java8 Time

1. Présentation

Dans le cadre de cet article, commençons par quelques problèmes avec les API de date et de calendrier existantes et explorons comment les nouvelles API de date et d'heure Java 8 résolvent ces problèmes.

Nous examinerons également les classes principales de la bibliothèque de classes de temps Java 8, telles que LocalDate, LocalTime, LocalDateTime, ZonedDateTime, Period, Duration et leurs API.

2. Problèmes avec l'ancienne API (avant java8)

• Sécurité des threads - Les classes Date et Calendar ne sont pas thread-safe, ce qui rend difficile pour les développeurs de déboguer les problèmes de concurrence avec ces API et doivent écrire du code supplémentaire pour gérer la sécurité des fils. Les nouvelles API de date et d'heure introduites dans Java 8 sont immuables et thread-safe, permettant de résoudre ces problèmes.

• Conception d'API et facile à comprendre - L'ancienne API est très difficile à comprendre, les opérations sont très complexes, très alambiquées et ne fournissent pas de méthodes d'analyse et de conversion courantes. La nouvelle API de temps est centrée sur ISO et suit un modèle de domaine cohérent pour la date, l'heure, la durée et les périodes. Certaines méthodes très utiles sont fournies pour prendre en charge les opérations les plus courantes. Nous n’avons plus besoin d’encapsuler nous-mêmes certaines classes d’opérations temporelles.

• ZonedDate and Time - Dans l'ancienne API, les développeurs devaient écrire une logique supplémentaire pour gérer la logique de fuseau horaire de l'ancienne API, tandis qu'avec la nouvelle API, vous pouvez utiliser les API Local et ZonedDate/Time pour gérer les fuseaux horaires. Pas besoin de trop vous soucier de la conversion du fuseau horaire.

3. Utilisez LocalDate, LocalTime et LocalDateTime

Les classes les plus couramment utilisées sont LocalDate, LocalTime et LocalDateTime. Comme leur nom l'indique, ils représentent la date/heure locale combinée au contexte.

Ces classes sont principalement utilisées lorsque le fuseau horaire n'a pas besoin d'être explicitement spécifié dans le contexte. Dans le cadre de cette section, nous aborderons les API les plus couramment utilisées.

3.1. Utiliser LocalDate

LocalDate représente une date sans heure précise au format ISO (AAAA-MM-JJ).

Il est souvent utilisé pour exprimer les anniversaires ou les dates de salaire qui nous tiennent le plus à cœur.

Obtenez la date sous l'horloge système actuelle comme suit :

LocalDate localDate = LocalDate.now();

Une LocalDate représentant un jour, un mois et une année spécifiques peut être obtenue en utilisant la méthode "of" ou en utilisant la méthode "parse". Par exemple, l'extrait de code suivant représente la LocalDate du 20 février 2015 :

LocalDate.of(2015, 02, 20);
LocalDate.parse("2015-02-20");

N'est-ce pas très intuitif et pratique ! LocalDate fournit diverses méthodes utilitaires pour obtenir diverses informations sur la date. Jetons un coup d'œil rapide à ces méthodes API.

L'extrait de code suivant obtient la date locale actuelle et ajoute un jour :

LocalDate tomorrow = LocalDate.now().plusDays(1);

Cet exemple obtient la date actuelle et soustrait un mois. Notez comment il accepte une énumération comme unité de temps :

LocalDate previousMonthSameDay = LocalDate.now().minus(1, ChronoUnit.MONTHS);

Dans les deux exemples de code suivants, nous analysons la date "2016-06-12" et obtenons respectivement le jour de la semaine et le jour du mois. Faites attention à la valeur de retour. Le premier est un objet représentant DayOfWeek, et le second est un int représentant la valeur ordinale du mois :

DayOfWeek sunday = LocalDate.parse("2016-06-12").getDayOfWeek();
int twelve = LocalDate.parse("2016-06-12").getDayOfMonth();

Nous pouvons tester si une date se produit dans une année bissextile. l'ancienne méthode, nous n'allons peut-être pas au paradis :

boolean leapYear = LocalDate.now().isLeapYear();

Jugez l'ordre des dates :

boolean notBefore = LocalDate.parse("2016-06-12").isBefore(LocalDate.parse("2016-06-11"));
boolean isAfter = LocalDate.parse("2016-06-12").isAfter(LocalDate.parse("2016-06-11"));

La limite de date peut être obtenue à partir de la date donnée. Dans les deux exemples suivants, nous obtenons un LocalDateTime qui représente le début de la journée pour une date donnée (2016-06-12T00:00) et un LocalDate qui représente le début du mois (2016-06-01) :

LocalDateTime beginningOfDay = LocalDate.parse("2016-06-12").atStartOfDay();
LocalDate firstDayOfMonth = LocalDate.parse("2016-06-12")
.with(TemporalAdjusters.firstDayOfMonth());

Voyons maintenant comment nous utilisons l'heure locale.

3.2. Utilisez LocalTime

pour représenter l'heure sans date en heure locale.

Semblable à LocalDate, les instances LocalTime peuvent être créées à partir de l'horloge système ou en utilisant les méthodes "parse" et "of". Jetez un coup d’œil rapide à quelques API couramment utilisées ci-dessous.

Une instance de LocalTime actuelle peut être créée à partir de l'horloge système comme suit :

LocalTime now = LocalTime.now();

Dans l'exemple de code suivant, nous créons une LocalTime représentant 06h30 en analysant la représentation sous forme de chaîne :

LocalTime sixThirty = LocalTime.parse("06:30");

Méthode "de " Peut être utilisé pour créer LocalTime. Par exemple, le code ci-dessous utilise la méthode "of" pour créer un LocalTime représentant 06h30 :

LocalTime sixThirty = LocalTime.of(6, 30);

L'exemple ci-dessous crée un LocalTime en analysant une chaîne et y ajoute une heure à l'aide de l'API "plus". Le résultat sera un LocalTime représentant 07h30 :

LocalTime sevenThirty = LocalTime.parse("06:30").plus(1, ChronoUnit.HOURS);

Diverses méthodes de lecture peuvent être utilisées pour obtenir des unités de temps spécifiques telles que les heures, les minutes et les secondes. Obtenez l'heure comme suit :

int six = LocalTime.parse("06:30").getHour();

Identique à LocalDate pour vérifier si un une heure spécifique est avant ou après une autre heure spécifique. L'exemple de code suivant compare deux LocalTimes qui donnent la valeur true :

boolean isbefore = LocalTime.parse("06:30").isBefore(LocalTime.parse("07:30"));

Les heures maximale, minimale et midi de la journée peuvent être obtenues grâce aux constantes de la classe LocalTime. Ceci est utile lors de l'exécution de requêtes de base de données pour rechercher des enregistrements dans une plage de temps donnée. Par exemple, le code ci-dessous représente 23:59:59.99 :

LocalTime maxTime = LocalTime.MAX

Examinons maintenant de plus près LocalDateTime.

3.3. Utilisation de LocalDateTime

Le LocalDateTime est utilisé pour représenter une combinaison de date et d'heure.

C'est la classe la plus couramment utilisée lorsque nous devons combiner la date et l'heure. Cette classe fournit diverses API et nous présenterons certaines des API les plus couramment utilisées.

Similaire à LocalDate et LocalTime Obtenez une instance de LocalDateTime à partir de l'horloge système :

LocalDateTime.now();

下面的代码示例解释了如何使用工厂“of”和“parse”方法创建实例。结果将是代表2015年2月20日06:30 AM 的LocalDateTime实例：

LocalDateTime.of(2015, Month.FEBRUARY, 20, 06, 30);
LocalDateTime.parse("2015-02-20T06:30:00");

有一些实用的API可以支持特定时间单位的时间运算，例如天，月，年和分钟。以下代码示例演示了“加”和“减”方法的用法。这些API的行为与LocalDate和LocalTime中的 API完全相同：

localDateTime.plusDays(1);
localDateTime.minusHours(2);

Getter方法可用于提取类似于日期和时间类的特定单位。鉴于上面的LocalDateTime实例，下面的代码示例将返回2月份的月份：

localDateTime.getMonth();

4.使用ZonedDateTime API

当我们需要处理时区特定的日期和时间时，Java 8提供了ZonedDateTime 类。ZoneID是用于表示不同区域的标识符。大约有40个不同的时区，使用ZoneID表示它们，如下所示

下面的代码我们来获取下“亚洲/上海”时区:

ZoneId zoneId = ZoneId.of("Aisa/Shanghai");

获取所有的时区：

Set<String> allZoneIds = ZoneId.getAvailableZoneIds();

LocalDateTime转化为特定的时区中的时间：

ZonedDateTime zonedDateTime = ZonedDateTime.of(localDateTime, zoneId);

ZonedDateTime提供解析方法来获取时区的特定日期时间：

ZonedDateTime.parse("2015-05-03T10:15:30+01:00[Aisa/Shanghai]");

使用时区的另一种方法是使用OffsetDateTime。OffsetDateTime是具有偏移量的日期时间的不可变表示形式。此类存储所有日期和时间字段，精确到纳秒，以及从UTC/格林威治的偏移量。可以使用ZoneOffset创建OffsetDateTime实例。这里我们创建一个LocalDateTime来表示2015年2月20日上午6:30：

LocalDateTime localDateTime = LocalDateTime.of(2015, Month.FEBRUARY, 20, 06, 30);

然后我们通过创建ZoneOffset并为LocalDateTime实例设置来增加两个小时：

ZoneOffset offset = ZoneOffset.of("+02:00");
OffsetDateTime offSetByTwo = OffsetDateTime.of(localDateTime, offset);

我们现在的本地日期时间为2015-02-20 06:30 +02：00。现在让我们继续讨论如何使用Period和Duration类修改日期和时间值。

5.使用Period和Duration

• Period : 用于计算两个日期（年月日）间隔。

• Duration : 用于计算两个时间（秒，纳秒）间隔。

5.1.使用Period

Period 类被广泛地用于修改给定的日期的值或者获取两个日期之间的差值：

LocalDate initialDate = LocalDate.parse("2007-05-10");
LocalDate finalDate = initialDate.plus(Period.ofDays(5));

Period 类有各种getter方法，如getYears，getMonths和getDays从获取值周期对象。下面的代码示例返回一个int值为5，是基于上面示例的逆序操作：

int five = Period.between(finalDate, initialDate).getDays();

该Period 可以在特定的单元获得两个日期之间的如天或月或数年，使用ChronoUnit.between：

int five = ChronoUnit.DAYS.between(finalDate , initialDate);

此代码示例返回五天。让我们继续看看Duration类。

5.2.使用Duration

类似Period ，该Duration类是用来处理时间。在下面的代码中，我们创建一个本地时间上午6:30，然后加30秒的持续时间，以使本地时间上午6时三十〇分30秒的：

LocalTime initialTime = LocalTime.of(6, 30, 0);
LocalTime finalTime = initialTime.plus(Duration.ofSeconds(30));

两个时刻之间的持续时间可以作为持续时间或作为特定单位获得。在第一个代码片段中，我们使用Duration类的between（）方法来查找finalTime和initialTime之间的时间差，并以秒为单位返回差异：

int thirty = Duration.between(finalTime, initialTime).getSeconds();

在第二个例子中，我们使用ChronoUnit类的between（）方法来执行相同的操作：

int thirty = ChronoUnit.SECONDS.between(finalTime, initialTime);

现在我们来看看如何将旧的Date 和Calendar 转换为新的Date和Time。

6.与日期和日历的兼容性

Java 8添加了toInstant（）方法，该方法有助于将旧API中的Date和Calendar实例转换为新的Date Time API，如下面的代码片段所示：

LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
LocalDateTime.ofInstant(calendar.toInstant(), ZoneId.systemDefault());

所述LocalDateTime可以从如下“ofEpochSecond"方法来构造。以下代码的结果将是代表2016-06-13T11：34：50 的LocalDateTime：

LocalDateTime.ofEpochSecond(1465817690, 0, ZoneOffset.UTC);

现在让我们继续进行日期和时间格式化。

7. 日期和时间格式化

Java 8提供了用于轻松格式化日期和时间的 API ：

LocalDateTime localDateTime = LocalDateTime.of(2015, Month.JANUARY, 25, 6, 30);

以下代码传递ISO日期格式以格式化本地日期。结果将是2015-01-25：

String localDateString = localDateTime.format(DateTimeFormatter.ISO_DATE);

该DateTimeFormatter提供多种标准格式选项。也可以提供自定义模式来格式化方法，如下所示，它将返回LocalDate为2015/01/25：

localDateTime.format(DateTimeFormatter.ofPattern("yyyy/MM/dd"));

我们可以将格式样式传递为SHORT，LONG或MEDIUM作为格式化选项的一部分。

下面的代码示例输出2015年1月25日06:30:00 me的输：

localDateTime
.format(DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM)
.withLocale(Locale.UK);

最后让我们看看Java 8 Core Date / Time API 可用的替代方案。

8.替代方案

8.1.使用Threeten 类库

对于从Java 7或Java 6这些老项目来说可以使用Threeten ,然后可以像在上面java 8一样使用相同的功能，一旦你迁移到java 8 只需要修改你的包路径代码而无需变更：

<dependency>
<groupId>org.threeten</groupId>
<artifactId>threetenbp</artifactId>
<version>LATEST</version>
</dependency>

8.2.Joda-Time类库

Java 8 日期和时间库的另一种替代方案是Joda-Time库。事实上，Java 8 Date Time API由Joda-Time库（Stephen Colebourne）和Oracle共同领导。该库提供了Java 8 Date Time项目中支持的几乎所有功能。通过在项目中引用以下pom依赖项就可以立即使用：

<dependency>
<groupId>joda-time</groupId>
<artifactId>joda-time</artifactId>
<version>LATEST</version>
</dependency>

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!