Java Optional : éviter null et NullPointerException

Le problème que résout Optional

Une méthode qui pourrait ne pas avoir de réponse a toujours eu un choix embarrassant en Java : renvoyer null et espérer que l'appelant pense à vérifier. En général, il n'y pense pas, et le résultat est une NullPointerException qui surgit loin de la méthode ayant renvoyé le null.

Optional<T> est une petite boîte qui contient soit une valeur, soit explicitement rien. En renvoyant Optional<User> au lieu de User, une méthode dit à l'appelant « ceci pourrait ne rien trouver » directement dans sa signature - et le compilateur l'oriente vers la gestion de ce cas.

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        Optional<String> found = Optional.of("Ada");
        Optional<String> missing = Optional.empty();

        System.out.println(found.isPresent());   // true
        System.out.println(missing.isPresent());  // false
    }
}

Créer un Optional

Il existe trois méthodes de fabrique, et choisir la bonne compte :

• Optional.of(value) - la valeur doit être non nulle, sinon elle lève NullPointerException sur-le-champ.
• Optional.ofNullable(value) - vide si la valeur est null, plein sinon. Utilise-la pour envelopper quelque chose qui pourrait être null.
• Optional.empty() - un optional vide.

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        String maybeNull = System.getenv("DOES_NOT_EXIST");  // renvoie null

        Optional<String> safe = Optional.ofNullable(maybeNull);
        System.out.println(safe.isPresent());  // false, sans exception

        // Optional.of(maybeNull) lèverait NullPointerException ici
        Optional<String> sure = Optional.of("definitely here");
        System.out.println(sure.isPresent());  // true
    }
}

Une erreur courante est de recourir à Optional.of(x) sur une valeur qui pourrait être null - cela va à l'encontre du but et lève exactement l'exception que tu essayais d'éviter. En cas de doute, utilise ofNullable.

Lire la valeur en toute sécurité

Une fois que tu as un optional, l'objectif est d'en extraire la valeur sans supposer qu'elle est là. L'outil brutal est get(), et tu ne devrais presque jamais l'utiliser :

Optional<String> name = Optional.empty();
String value = name.get();   // lève NoSuchElementException - une NPE déguisée

À la place, fournis une valeur de repli ou réagis à la présence. orElse renvoie une valeur par défaut quand c'est vide ; ifPresent exécute du code seulement quand une valeur existe :

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        Optional<String> name = Optional.of("Grace");
        Optional<String> blank = Optional.empty();

        System.out.println(name.orElse("anonymous"));   // Grace
        System.out.println(blank.orElse("anonymous"));  // anonymous

        name.ifPresent(n -> System.out.println("Hello, " + n));
        blank.ifPresent(n -> System.out.println("never prints"));
    }
}

Utilise orElseGet(supplier) plutôt que orElse quand la valeur par défaut est coûteuse à construire - le supplier ne s'exécute que si l'optional est réellement vide. L'argument d'orElse est toujours évalué, même quand il n'est pas nécessaire.

orElseThrow pour « ceci devrait exister »

Parfois, le vide est vraiment une erreur - une valeur de configuration obligatoire, un utilisateur qui devrait se trouver en base de données. orElseThrow transforme un optional vide en une exception claire de ton choix :

import java.util.Optional;

public class Main {
    static Optional<Integer> parsePort(String raw) {
        try {
            return Optional.of(Integer.parseInt(raw));
        } catch (NumberFormatException e) {
            return Optional.empty();
        }
    }

    public static void main(String[] args) {
        int port = parsePort("8080")
            .orElseThrow(() -> new IllegalStateException("port must be a number"));
        System.out.println("listening on " + port);

        try {
            parsePort("nope")
                .orElseThrow(() -> new IllegalStateException("port must be a number"));
        } catch (IllegalStateException e) {
            System.out.println("caught: " + e.getMessage());
        }
    }
}

Cela se lit bien mieux qu'un bloc if (opt.isPresent()) et rend l'échec explicite à l'endroit où il se produit.

Transformer avec map et filter

Le vrai intérêt, c'est le chaînage. map applique une fonction à la valeur seulement si elle est présente et laisse un optional vide vide - tu transformes donc sans jamais toucher un null. filter écarte la valeur si elle échoue à un test.

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        Optional<String> raw = Optional.of("  Coddy  ");

        String result = raw
            .map(String::trim)          // "Coddy"
            .filter(s -> !s.isEmpty())  // ne garder que le non vide
            .map(String::toUpperCase)   // "CODDY"
            .orElse("EMPTY");

        System.out.println(result);  // CODDY

        // Un optional vide circule intact - pas de NPE, pas de branchements
        String none = Optional.<String>empty()
            .map(String::trim)
            .orElse("EMPTY");
        System.out.println(none);    // EMPTY
    }
}

Si ta fonction de mapping renvoie elle-même un Optional, utilise flatMap plutôt que map pour éviter un encombrant Optional<Optional<T>>. Cela reflète la distinction map/flatMap que tu as vue avec les streams - un Optional se comporte beaucoup comme un stream de zéro ou un élément.

Où Optional a sa place (et où non)

Optional est conçu comme un type de retour pour les méthodes qui peuvent légitimement ne produire aucun résultat - les exemples canoniques sont Stream.findFirst(), les recherches de type Map et l'analyse syntaxique. Utilise-le là et ton API documente ses propres absences.

Il n'est pas destiné aux :

• Champs. Il n'est pas sérialisable et ajoute un objet par champ. Utilise des références simples et valide dans le constructeur.
• Paramètres de méthode. L'appelant doit alors envelopper les arguments dans Optional.of(...), ce qui est plus bruyant qu'une surcharge ou un paramètre acceptant null.
• Collections. Renvoie une List vide, pas un Optional<List>. Une collection vide signifie déjà « rien ».

Traité comme un type de retour, Optional transforme les bugs de null silencieux en invites à la compilation pour gérer le cas manquant.

Suite : les exceptions

Optional gère proprement le cas quotidien « il pourrait n'y avoir aucune valeur », mais certaines défaillances sont vraiment exceptionnelles - un fichier qui ne s'ouvre pas, un réseau qui lâche, une entrée impossible à analyser. Java modélise ces cas avec des exceptions, et c'est la page suivante.