0Pricing
Java Academy · Leçon

Créer et inspecter des Optional

Utilisez Optional.of, ofNullable, empty, isPresent, isEmpty et get en toute sécurité.

Créer et inspecter des Optional est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

Créer et inspecter des Optional

Cette leçon présente les méthodes permettant de créer des instances d’Optional et d’inspecter leur contenu : isPresent, isEmpty, get et les alternatives sûres.

Trois façons de créer un Optional

Créez un Optional avec Optional.of(), Optional.ofNullable() ou Optional.empty().

import java.util.Optional;

// 1. of: must be non-null
Optional<String> a = Optional.of("hello");

// 2. ofNullable: safely wraps null
String maybeNull = null;
Optional<String> b = Optional.ofNullable(maybeNull); // empty
Optional<String> c = Optional.ofNullable("world");   // present

// 3. empty: explicitly empty
Optional<Integer> empty = Optional.empty();

System.out.println(a.isPresent()); // true
System.out.println(b.isPresent()); // false
System.out.println(c.isEmpty());   // false

isPresent et isEmpty

isPresent() renvoie true si une valeur est présente. isEmpty() (Java 11 ou version ultérieure) est son inverse logique.

import java.util.Optional;

Optional<String> opt = Optional.of("Java");

System.out.println(opt.isPresent()); // true
System.out.println(opt.isEmpty());   // false

Optional<String> empty = Optional.empty();
System.out.println(empty.isPresent()); // false
System.out.println(empty.isEmpty());   // true

// Prefer ifPresent() over if (isPresent()) get() — more readable
opt.ifPresent(v -> System.out.println(v.toUpperCase())); // JAVA

get() : à utiliser avec prudence

get() renvoie la valeur ou lève NoSuchElementException. Ne l’appelez jamais sans effectuer d’abord une vérification.

import java.util.Optional;

Optional<String> opt = Optional.of("present");
System.out.println(opt.get()); // present

Optional<String> empty = Optional.empty();
try {
    empty.get(); // NoSuchElementException!
} catch (java.util.NoSuchElementException e) {
    System.out.println("No value!");
}

// Better pattern: always use orElse/orElseGet/orElseThrow
// instead of isPresent() + get()

orElse et orElseGet

orElse(default) renvoie la valeur par défaut si l’Optional est vide. orElseGet(supplier) appelle le fournisseur de manière différée, ce qui est préférable pour les valeurs par défaut coûteuses à calculer.

import java.util.Optional;

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

// orElse: default value always evaluated
String basic = plan.orElse("FREE");
System.out.println(basic); // FREE

// orElseGet: supplier only called when empty (lazy)
String lazy = plan.orElseGet(() -> {
    System.out.println("Computing default...");
    return "FREE";
});
System.out.println(lazy); // Computing default... FREE

// When present, orElseGet supplier is NOT called
Optional.of("PRO").orElseGet(() -> {
    System.out.println("Not called!");
    return "FREE";
}); // silent — present, no computation needed

orElseThrow

orElseThrow() lève NoSuchElementException ou une exception personnalisée si l’Optional est vide. Utilisez-le lorsque l’absence constitue véritablement une erreur.

import java.util.Optional;

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

// Default: throws NoSuchElementException
try {
    userId.orElseThrow();
} catch (java.util.NoSuchElementException e) {
    System.out.println("Empty!");
}

// Custom exception
try {
    userId.orElseThrow(() -> new IllegalStateException("User ID required"));
} catch (IllegalStateException e) {
    System.out.println(e.getMessage()); // User ID required
}

ifPresent et ifPresentOrElse

Ces méthodes vous permettent d’agir sur la valeur sans l’extraire. Elles sont pratiques pour les effets de bord.

import java.util.Optional;

Optional<String> username = Optional.of("alice");

// ifPresent: callback only when present
username.ifPresent(u -> System.out.println("Welcome, " + u));
// Welcome, alice

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

// ifPresentOrElse (Java 9+): callback or else action
missing.ifPresentOrElse(
    u -> System.out.println("Hello " + u),
    () -> System.out.println("Anonymous user")
);
// Anonymous user

Vérifier la présence d’un String

Cas d’utilisation courant : renvoyer une valeur par défaut lorsqu’une chaîne de configuration est absente ou vide.

import java.util.Optional;

static Optional<String> getConfig(String key) {
    // Simulate config lookup
    return Optional.ofNullable(System.getenv(key));
}

String port = getConfig("PORT").orElse("8080");
String host = getConfig("HOST").orElse("localhost");

System.out.println("Server: " + host + ":" + port);
// Server: localhost:8080 (when env vars not set)

Optional.or() pour les Optional de remplacement

or() (Java 9 ou version ultérieure) renvoie l’Optional lui-même s’il est présent, ou un autre Optional fourni par un fournisseur.

import java.util.Optional;

static Optional<String> findInCache(String key)   { return Optional.empty(); }
static Optional<String> findInDatabase(String key) { return Optional.of("Alice"); }

Optional<String> result = findInCache("user:1")
    .or(() -> findInDatabase("user:1"));

System.out.println(result.get()); // Alice

// Useful for fallback chains:
Optional<String> value = Optional.empty()
    .or(() -> Optional.empty())
    .or(() -> Optional.of("final fallback"));
System.out.println(value.get()); // final fallback

filter pour une présence conditionnelle

filter(predicate) conserve la valeur uniquement si elle satisfait le prédicat ; sinon, il renvoie un Optional vide.

import java.util.Optional;

Optional<Integer> age = Optional.of(17);

Optional<Integer> adult = age.filter(a -> a >= 18);
System.out.println(adult.isPresent()); // false (17 is not >= 18)

Optional<Integer> age2 = Optional.of(25);
Optional<Integer> adult2 = age2.filter(a -> a >= 18);
System.out.println(adult2.get()); // 25

// Chain: find active premium user
Optional<User> premiumActive = findUser(id)
    .filter(u -> "PRO".equals(u.plan()))
    .filter(u -> u.isActive());

En pratique : recherche d’utilisateur avec fallback

Combinaison de isPresent, orElse et ifPresentOrElse dans un scénario réaliste de recherche d’utilisateur.

import java.util.Optional;

record User(long id, String name, String email) {}

static Optional<User> findById(long id) {
    return id == 1 ? Optional.of(new User(1, "Alice", "alice@co.com"))
                   : Optional.empty();
}

static void displayUser(long id) {
    findById(id).ifPresentOrElse(
        u -> System.out.println("Found: " + u.name() + " <" + u.email() + ">"),
        () -> System.out.println("User " + id + " not found")
    );
}

displayUser(1);  // Found: Alice <alice@co.com>
displayUser(99); // User 99 not found

Vérification rapide

Que fait orElseGet() différemment de orElse() ?

Récapitulatif : créer et inspecter des Optional

Points essentiels :

  • Optional.of() exige une valeur non absente ; Optional.ofNullable() accepte une valeur absente
  • isPresent() / isEmpty() vérifient la présence ; évitez d’appeler get() sans effectuer de vérification
  • orElse() convient aux valeurs par défaut peu coûteuses ; orElseGet() aux valeurs par défaut calculées coûteuses
  • orElseThrow() s’utilise lorsque l’absence constitue une erreur
  • ifPresent() et ifPresentOrElse() permettent de gérer les effets de bord sans extraire la valeur
  • filter() conserve la valeur uniquement si le prédicat est satisfait ; or() enchaîne des Optional de remplacement

Questions Fréquemment Posées

La leçon « Créer et inspecter des Optional » est-elle gratuite ?

Oui — le texte complet de « Créer et inspecter des Optional » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Créer et inspecter des Optional » ?

Utilisez Optional.of, ofNullable, empty, isPresent, isEmpty et get en toute sécurité. Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Créer et inspecter des Optional » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Pourquoi Optional existe
  2. Créer et inspecter des Optional
  3. Transformer des Optional : map et flatMap
  4. Bonnes pratiques avec Optional
← Retour à Java Academy