[JAVA 11] Java Optional Best practices

Introduction

Java Optional est un conteneur d’objet qui peut ou non contenir une valeur non nulle. Il offre une alternative plus sûre à null, en évitant les exceptions NullPointerException.

Problème

Avant de plonger dans l’utilisation d’Optional, comprenons quel problème il promet de résoudre. Lorsque nous créons une application Java, nous utiliserons sûrement le chaînage de méthodes pour déréférencer les propriétés des objets, ce qui peut facilement nous faire tomber dans le piège de NullPointerException.

String authorZipCode = book.getAuthor().getAddress().getZipCode();

Dans le fragment de code ci-dessus, il pourrait y avoir une NullPointerException dans n’importe quelle invocation de méthode get.
Par conséquent, la classe Optional résout ce problème en enveloppant l’objet que nous voulons et en le manipulant.

L’utilisation incorrecte de Java Optional peut entraîner des erreurs et une mauvaise performance. Par exemple, déclarer des champs d’une classe ou dans un constructeur avec Optional n’est pas recommandé. De plus, l’appel à Optional.get() sans vérifier au préalable si une valeur est présente peut entraîner une exception NoSuchElementException.

Solution

Au lieu d’utiliser une annotation Java, qui n’est pas vérifiée à la compilation, Optional vous permet d’améliorer vos méthodes et d’indiquer que votre méthode peut retourner des valeurs “vides” (et non null).

Voici quelques bonnes pratiques pour utiliser Java Optional :

1. Utilisez Optional uniquement pour les retours de méthode : Cela permet d’éviter les erreurs NullPointerException lors de l’appel à des méthodes qui peuvent retourner null.

2. Initialisez les variables Optional avec empty() au lieu de null : Depuis Java 8, vous pouvez initialiser une variable Optional avec Optional.empty(). Par exemple :

   Optional<String> refMoe = Optional.empty();
   

3. N’utilisez jamais Optional.get() sans vérifier au préalable si une valeur est présente : Utilisez toujours Optional.isPresent() avant d’appeler Optional.get(). Sinon, vous risquez de rencontrer une exception NoSuchElementException.

4. Utilisez orElse(null) pour retourner null : Cette méthode doit être utilisée uniquement pour des valeurs fixes comme Collections.empty(), etc.

Discussion sur chaque point

Utilisation de isPresent

Optional<String> optional = getOptional();
if (optional.isPresent()) {
    System.out.println(optional.get());
}

ifPresent et ifPresentOrElse

optional.ifPresent(value -> System.out.println(value));
optional.ifPresentOrElse(
    value -> System.out.println(value),
    () -> System.out.println("Value not present")
);

orElse, orElseGet, orElseThrow

String value = optional.orElse("default");
value = optional.orElseGet(() -> "default");
value = optional.orElseThrow(() -> new RuntimeException("Value not present"));

Optional et les collections

// Mauvaise pratique
Optional<List<String>> optionalList = getOptionalList();

// Bonne pratique
List<String> list = getList(); // Retourne une liste vide si aucune valeur n'est présente

Éviter l’abus d’Optionals

// Mauvaise pratique
Optional<String> optional = Optional.of("value");

// Bonne pratique
String value = "value";

Éviter l’utilisation des Optionals pour les arguments de méthode et les champs

public class MyClass {
    private Optional<String> value; // Mauvaise pratique

    public void myMethod(Optional<String> value) { // Mauvaise pratique
        // ...
    }
}

map et flatMap

Optional<String> optional = getOptional();
optional.map(value -> value.toUpperCase());
optional.flatMap(value -> getAnotherOptional(value));

Éviter l’utilisation excessive de isPresent et get

// Mauvaise pratique
if (optional.isPresent()) {
    String value = optional.get();
}

// Bonne pratique
optional.ifPresent(value -> System.out.println(value));

En suivant ces bonnes pratiques, vous pouvez utiliser Java Optional efficacement et en toute sécurité.

J’espère que ces exemples vous aideront à comprendre comment utiliser efficacement Java Optional. 
😊