Le guide complet de la classe Java `` Facultatif '

Facultatif est une classe de conteneurs introduite par Java 8 pour une manipulation plus sécurisée de valeurs potentiellement nulles, dont le but central est de "manquer la valeur" explicitement et de réduire le risque de nullpointerexception. 1. Créez une instance vide en utilisant Facultational.Empty (), Facultatif.Of (valeur) Enveloppe les valeurs non nulles, et facultative.OfNullable (valeur) Enveloppe la valeur qui peut être nul. 2. Évitez de combiner ispresent () et get () directement. Vous devez donner la priorité à l'utilisation d'Orelse () pour fournir la valeur par défaut. Orelseget () implémente le calcul des retards. Cette méthode est recommandée lorsque la valeur par défaut est sur la tête. OrelSethRow () lance une exception lorsque la valeur est manquante. 3. Utilisez MAP () pour convertir les valeurs, FlatMap () évite les valeurs facultatives facultatives et filtres () en fonction des conditions. 4. Il est interdit d'utiliser facultatif comme paramètre de méthode, champ de classe ou élément de collecte, et il est interdit de retourner null au lieu de facultational.empty (). 5. Vous pouvez filtrer, cartographier et FlatMap calculé à la chaîne pour créer un processus de traitement des données sécurisé, et utiliser Facultatif :: Stream pour filtrer les valeurs vides et extraire les résultats avec le flux. L'utilisation correcte de facultatif peut améliorer la sécurité et la lisibilité du code, ce qui en fait le type de retour préféré pour exprimer des "résultats facultatifs".

La classe Optional de Java, introduite dans Java 8, est un objet de conteneur qui peut ou non contenir une valeur non nulle. Il a été conçu pour aider les développeurs à gérer les valeurs null plus gracieusement et à réduire le risque de NullPointerException (NPE). Bien que Optional ne soit pas une solution pour chaque problème, lorsqu'il est utilisé correctement, il peut rendre le code plus propre, plus sûr et plus expressif.

Voici un guide complet pour utiliser efficacement Optional dans vos applications Java.

Qu'est-ce qui est Optional et pourquoi l'utiliser?

Optional<t></t> est un wrapper pour une valeur qui pourrait être absente. Au lieu de retourner null à partir d'une méthode, vous pouvez renvoyer un Optional<t></t> , ce qui rend explicite que le résultat peut être vide.

Pourquoi l'utiliser?

• Évite NullPointerException par conception.
• Rend les API plus claires - les appelants savent qu'une valeur pourrait ne pas être présente.
• Encourage une meilleure gestion des valeurs manquantes au lieu de les ignorer.
• Promoue la programmation de style fonctionnel avec des méthodes telles que map , filter et flatMap .

 public facultatif <string> findNameById (int id) {
    // renvoie en option.empty () si cela n&#39;est pas trouvé
    return Repository.FindByid (ID)
                    .map (utilisateur :: getName);
}

Création d'instances Optional

Il existe trois façons principales de créer un Optional :

1. Optional.empty() - pour des valeurs absentes

Utilisez lorsque vous savez qu'il n'y a pas de valeur.

 Facultatif <string> vide = facultatif.empty (); // aucune valeur

2. Optional.of(value) - pour les valeurs non nulles

Utilisez lorsque vous êtes certain que la valeur n'est pas nul. Lance NullPointerException si la valeur est nul.

 String name = "Alice";
Facultatif <string> optName = facultatif.of (name); // D&#39;ACCORD

3. Optional.ofNullable(value) - pour les valeurs qui pourraient être nuls

Enveloppez en toute sécurité une valeur qui pourrait être nul.

 String name = getNameFromDatabase (); // pourrait retourner null
Facultatif <string> optName = facultatif.ofNullable (name); // ok même si le nom est nul

✅ Meilleures pratiques: utilisation ofNullable() lorsqu'il s'agit de valeurs potentiellement nulles.

Vérification et récupération des valeurs

Une fois que vous avez Optional , vous devez extraire la valeur en toute sécurité.

isPresent() et isEmpty() - Vérifiez la présence

 Facultatif <string> opt = optional.of ("bob");

if (opt.ispresent ()) {
    System.out.println ("Name:" opt.get ());
}

Ou mieux (depuis Java 11):

 if (opt.isempty ()) {
    System.out.println ("Aucun nom trouvé");
}

❌ Ne pas utiliser isPresent() get() - il bat le but de Optional .

get() - Obtenez la valeur (dangereuse!)

Appelez uniquement get() si vous êtes sûr que la valeur existe. Sinon, il lance NoSuchElementException .

 String Value = Opt.get (); // risqué!

❌ Évitez get() sauf si vous avez déjà vérifié avec isPresent() .

orElse(default) - Fournissez un secours

Renvoie la valeur si elle est présente, sinon renvoie la valeur par défaut.

 String name = opt.orelse ("inconnu");

orElseGet(Supplier) - Fallback paresseux

Utiliser lors du calcul de la valeur par défaut coûte cher.

 String name = opt.orelSeget (() -> CompudeFaultName ());

✅ Préférez orElseGet() sur orElse() lorsque la valeur par défaut implique le calcul.

orElseThrow() - Jetez l'exception en cas de manque

Idéal pour appliquer la présence.

 String name = opt.orelSethrow (() -> new illégalArgumentException ("le nom est requis"));

Depuis Java 10, vous pouvez également utiliser:

 String name = opt.orelSethRow (); // lève la conception de NosuchementElement

Transformer et filtrer les valeurs

Soutien Optional des opérations fonctionnelles pour travailler avec la valeur enveloppée sans l'extraire.

map() - transformer la valeur

Applique une fonction si la valeur est présente et renvoie un nouveau Optional .

 Facultatif <string> nameOpt = getuser (). Map (user :: getName);

Si getUser() renvoie Optional<User> , map en toute sécurité les extrait et le transforme.

flatMap() - éviter les imbriquées Optional

Utilisez lorsque la transformation renvoie un autre Optional .

 Facultatif <string> e-mail = getUser ()
    .flatMap (user -> user.getEmail ()); // Le courrier électronique peut être facultatif <string>

Sans flatMap , vous obtiendrez Optional<Optional<String>> .

filter() - Gardez conditionnellement la valeur

Ne conserve la valeur que si elle correspond à une prévision.

 Facultatif <string> adultename = getPerson ()
    .filter (p -> p.getage ()> = 18)
    .map (personne :: getName);

Si la personne a moins de 18 ans, le résultat devient Optional.empty() .

Des mauvais usus communs de Optional

Même si Optional est puissant, il est souvent mal utilisé. Voici les pièges courants:

• N'utilisez pas Optional comme paramètre de méthode

   // ❌ mauvais
  public void setName (nom <string> facultatif) {...}

  Au lieu de cela, surchargez la méthode ou utilisez null .

• Ne stockez pas les champs Optional en classe

   // ❌ éviter
  classe de classe {
      <string facultatif privé> middlename;
  }

  Cela complique la sérialisation et ajoute des frais généraux inutiles. Utilisez null et documentez-le.

• N'appelez pas isPresent() et get() vous comme un chèque nul

   // ❌ anti-motif
  if (opt.ispresent ()) {
      use (opt.get ());
  }

  Préférer ifPresent() :

   opt.ifpresent (this :: use);

• Ne retournez pas null des méthodes qui renvoient Optional

   // ❌ ne fais jamais ça
  retourner null; // au lieu de Facultatif.Empty ()

Conseils avancés

Opérations de chaînage

Vous pouvez enchaîner map , filter et flatMap pour construire des pipelines sûrs.

 Chaîne e-mail = userRepo.FindByid (123)
    .filter (utilisateur :: isactive)
    .map (utilisateur :: getContactinfo)
    .flatMap (ContactInfo :: Getemail)
    .filter (email -> email.endswith ("@ company.com"))
    .orelse ("default@company.com");

Utiliser avec les flux

Fonctionne en Optional avec Stream .

 List <optional <string>> list = ...;
List <string> résultats = list.stream ()
    .flatMap (Facultatif :: Stream)
    .Collect (collectionners.tolist ());

Cela filtre les options vides et extrait les valeurs.

Résumé

Optional est un outil pour écrire du code plus sûr et plus expressif - pas un remplacement pour toutes les vérifications nulles. Utilisez-le principalement comme type de retour pour indiquer des résultats facultatifs.

Récapitulation des meilleures pratiques:

• ✅ Utilisez Optional comme type de retour lorsqu'une valeur peut être absente.
• ✅ Utilisez orElseGet() au lieu de orElse() pour des défauts coûteux.
• ✅ map de chaîne, flatMap et filter pour les transformations propres.
• ✅ Évitez Optional dans les champs, les paramètres ou les collections.
• ✅ Ne retournez jamais null au lieu de Optional.empty() .

Lorsqu'elle est utilisée correctement, Optional aide à éliminer NullPointerException et rend l'intention de votre code plus claire.

Fondamentalement, il ne s'agit pas d'éviter complètement null - il s'agit de faire de l'absence un concept de première classe dans votre conception d'API.

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!