TOC

Ajouts d’API facultatifs Java 9

Ajouts facultatifs à l'API Java 9

1. Vue d'ensemble

Dans cet article, nous examinerons les ajouts de Java 9 à l'APIOptional.

Au-delà de la modularité, Java 9 ajoute également trois méthodes très utiles pour la classeOptional.

2. La méthodeor()

Parfois, lorsque notreOptional est vide, nous voulons exécuter une autre action qui renvoie également un Optional.

Avant Java 9, la classeOptional n'avait que les méthodesorElse() etorElseGet(), mais les deux doivent renvoyer des valeurs non emballées.

Java 9 introduit la méthodeor() qui renvoie un autreOptional paresseusement si notreOptional est vide. Si notre premierOptional a une valeur définie, le lambda passé à la méthodeor() ne sera pas appelé, et la valeur ne sera pas calculée et retournée: 

@Test
public void givenOptional_whenPresent_thenShouldTakeAValueFromIt() {
    //given
    String expected = "properValue";
    Optional value = Optional.of(expected);
    Optional defaultValue = Optional.of("default");

    //when
    Optional result = value.or(() -> defaultValue);

    //then
    assertThat(result.get()).isEqualTo(expected);
}

Dans le cas deOptional being vide, lesresult renvoyés seront les mêmes que lesdefaultValue: 

@Test
public void givenOptional_whenEmpty_thenShouldTakeAValueFromOr() {
    // given
    String defaultString = "default";
    Optional value = Optional.empty();
    Optional defaultValue = Optional.of(defaultString);

    // when
    Optional result = value.or(() -> defaultValue);

    // then
    assertThat(result.get()).isEqualTo(defaultString);
}

3. La méthodeifPresentOrElse()

Lorsque nous avons une instanceOptional, nous voulons souvent exécuter une action spécifique sur la valeur sous-jacente de celle-ci. D'un autre côté, si leOptional estempty, nous voulons le consigner ou suivre ce fait en incrémentant une métrique.

La méthodeifPresentOrElse() est créée exactement pour de tels scénarios. On peut passer unConsumer qui sera invoqué si leOptional est défini, etRunnable qui sera exécuté si leOptional est vide.

Disons que nous avons unOptional défini et que nous voulons incrémenter un compteur spécifique si la valeur est présente: 

@Test
public void givenOptional_whenPresent_thenShouldExecuteProperCallback() {
    // given
    Optional value = Optional.of("properValue");
    AtomicInteger successCounter = new AtomicInteger(0);
    AtomicInteger onEmptyOptionalCounter = new AtomicInteger(0);

    // when
    value.ifPresentOrElse(
      v -> successCounter.incrementAndGet(),
      onEmptyOptionalCounter::incrementAndGet);

    // then
    assertThat(successCounter.get()).isEqualTo(1);
    assertThat(onEmptyOptionalCounter.get()).isEqualTo(0);
}

Notez que le rappel transmis en tant que deuxième argument n'a pas été exécuté.

Dans le cas d'unOptional, vide, le second callback est exécuté: 

@Test
public void givenOptional_whenNotPresent_thenShouldExecuteProperCallback() {
    // given
    Optional value = Optional.empty();
    AtomicInteger successCounter = new AtomicInteger(0);
    AtomicInteger onEmptyOptionalCounter = new AtomicInteger(0);

    // when
    value.ifPresentOrElse(
      v -> successCounter.incrementAndGet(),
      onEmptyOptionalCounter::incrementAndGet);

    // then
    assertThat(successCounter.get()).isEqualTo(0);
    assertThat(onEmptyOptionalCounter.get()).isEqualTo(1);
}

4. La méthodestream()

La dernière méthode, qui est ajoutée à la classeOptional dans Java 9, est la méthodestream().

Java a une APIStream très fluide et élégante qui peut fonctionner sur les collections et utilise de nombreux concepts de programmation fonctionnelle. La dernière version de Java introduit la méthodestream() sur la classeOptional queallows us to treat the Optional instance as a Stream.

Disons que nous avons unOptional défini et que nous appelons la méthodestream() dessus. Cela créera unStream d'un élément sur lequel nous pouvons utiliser toutes les méthodes disponibles dans l'APIStream: 

@Test
public void givenOptionalOfSome_whenToStream_thenShouldTreatItAsOneElementStream() {
    // given
    Optional value = Optional.of("a");

    // when
    List collect = value.stream().map(String::toUpperCase).collect(Collectors.toList());

    // then
    assertThat(collect).hasSameElementsAs(List.of("A"));
}

D'un autre côté, siOptional n'est pas présent, l'appel de la méthodestream() dessus créera unStream: vide 

@Test
public void givenOptionalOfNone_whenToStream_thenShouldTreatItAsZeroElementStream() {
    // given
    Optional value = Optional.empty();

    // when
    List collect = value.stream()
      .map(String::toUpperCase)
      .collect(Collectors.toList());

    // then
    assertThat(collect).isEmpty();
}

Nous pouvons maintenant filtrer rapidementStreams of Optionals.

Opérer sur lesStream vides n'aura aucun effet, mais grâce à la méthodestream(), nous pouvons désormais chaîner l'APIOptional avec l'APIStream. Cela nous permet de créer un code plus élégant et plus fluide.

5. Conclusion

Dans cet article rapide, nous avons examiné les ajouts à l'API Java 9Optional.

Nous avons vu comment utiliser la méthodeor() pour renvoyer un optionnel dans le cas où la sourceOptional est vide. Nous avons utilisé lesifPresentOrElse() pour exécuter lesConsumer si la valeur est présente et sinon, exécuter un autre rappel.

Enfin, nous avons vu comment enchaîner lesOptional avec l'APIStream en utilisant la méthodestream().

L'implémentation de tous ces exemples et extraits de code peut être trouvée dans leGitHub project - il s'agit d'un projet Maven, il devrait donc être facile à importer et à exécuter tel quel.

Related