Utilisations pour facultatif

Après avoir utilisé Java 8 depuis plus de 6 mois environ, je suis assez satisfait des nouvelles modifications de l'API. Un domaine auquel je ne suis toujours pas confiant est le moment de l'utiliser Optional. Je semble osciller entre vouloir l'utiliser partout où quelque chose peut être null, et nulle part du tout.

Il semble y avoir beaucoup de situations où je pourrais l'utiliser, et je ne suis jamais sûr s'il ajoute des avantages (lisibilité / sécurité nulle) ou s'il provoque simplement des frais supplémentaires.

Donc, j'ai quelques exemples, et je serais intéressé par les réflexions de la communauté pour savoir si Optionalc'est bénéfique.

1 - En tant que type de retour de méthode publique lorsque la méthode peut retourner null:

public Optional<Foo> findFoo(String id);

2 - Comme paramètre de méthode lorsque le paramètre peut être null:

public Foo doSomething(String id, Optional<Bar> barOptional);

3 - En tant que membre facultatif d'un bean:

public class Book {

  private List<Pages> pages;
  private Optional<Index> index;

}

4 - Dans Collections:

En général, je ne pense pas:

List<Optional<Foo>>

ajoute quoi que ce soit - d'autant plus que l'on peut utiliser filter()pour supprimer des nullvaleurs, etc., mais y a-t-il de bonnes utilisations Optionaldans les collections?

Des cas que j'ai ratés?

Le point principal de Optionalest de fournir un moyen pour une fonction renvoyant une valeur pour indiquer l'absence d'une valeur de retour. Voir cette discussion . Cela permet à l'appelant de continuer une chaîne d'appels de méthode fluide.

Cela correspond le plus étroitement au cas d'utilisation n ° 1 de la question du PO. Cependant, l' absence de valeur est une formulation plus précise que null car quelque chose comme IntStream.findFirstcela ne pourrait jamais retourner null.

Pour le cas d'utilisation # 2 , en passant un argument facultatif à une méthode, cela pourrait fonctionner, mais c'est plutôt maladroit. Supposons que vous ayez une méthode qui accepte une chaîne suivie d'une deuxième chaîne facultative. Accepter un Optionalcomme deuxième argument entraînerait un code comme celui-ci:

foo("bar", Optional.of("baz"));
foo("bar", Optional.empty());

Même accepter null est plus agréable:

foo("bar", "baz");
foo("bar", null);

Le mieux est probablement d'avoir une méthode surchargée qui accepte un seul argument de chaîne et fournit une valeur par défaut pour le second:

foo("bar", "baz");
foo("bar");

Cela a des limites, mais c'est beaucoup plus agréable que ce qui précède.

Les cas d'utilisation # 3 et # 4 , ayant un Optionaldans un champ de classe ou dans une structure de données, sont considérés comme une mauvaise utilisation de l'API. Tout d'abord, cela va à l'encontre de l'objectif principal de conception, Optionalcomme indiqué en haut. Deuxièmement, cela n'ajoute aucune valeur.

Il existe trois façons de gérer l'absence d'une valeur dans un Optional: pour fournir une valeur de remplacement, pour appeler une fonction pour fournir une valeur de remplacement ou pour lever une exception. Si vous stockez dans un champ, vous le feriez au moment de l'initialisation ou de l'affectation. Si vous ajoutez des valeurs dans une liste, comme l'OP l'a mentionné, vous avez le choix supplémentaire de simplement ne pas ajouter la valeur, "aplatissant" ainsi les valeurs absentes.

Je suis sûr que quelqu'un pourrait trouver des cas artificiels où il veut vraiment stocker un Optionaldans un champ ou une collection, mais en général, il vaut mieux éviter de le faire.

Je suis en retard dans le jeu mais pour ce que ça vaut, je veux ajouter mes 2 cents. Ils vont à l'encontre de l' objectif de conception deOptional , qui est bien résumé par la réponse de Stuart Marks , mais je suis toujours convaincu de leur validité (évidemment).

Utiliser partout en option

En général

J'ai écrit un article de blogOptional complet sur l'utilisation, mais cela se résume à ceci:

• concevez vos classes pour éviter le caractère optionnel dans la mesure du possible
• dans tous les cas restants, la valeur par défaut devrait être d'utiliser Optionalau lieu denull
• faire éventuellement des exceptions pour:
  • variables locales
  • renvoyer des valeurs et des arguments aux méthodes privées
  • blocs de code critiques pour les performances (pas de suppositions, utilisez un profileur)

Les deux premières exceptions peuvent réduire le surcoût perçu des références d'emballage et de déballage dans Optional. Ils sont choisis de telle sorte qu'un nul ne puisse jamais légalement passer une frontière d'une instance à une autre.

Notez que cela n'autorisera presque jamais Optionals dans les collections, ce qui est presque aussi mauvais que nulls. Ne le fais pas. ;)

Concernant vos questions

1. Oui.
2. Si la surcharge n'est pas une option, oui.
3. Si d'autres approches (sous-classement, décoration, ...) ne sont pas envisageables, oui.
4. Je t'en prie, non!

Les avantages

Cela réduit la présence de nulls dans votre base de code, mais ne les supprime pas. Mais ce n'est même pas le point principal. Il existe d'autres avantages importants:

Clarifie l'intention

L'utilisation Optionalexprime clairement que la variable est, eh bien, facultative. Tout lecteur de votre code ou consommateur de votre API sera battu au-dessus de la tête par le fait qu'il pourrait ne rien y avoir et qu'un contrôle est nécessaire avant d'accéder à la valeur.

Supprime l'incertitude

Sans Optionalle sens d'un nullévénement n'est pas clair. Il peut s'agir d'une représentation légale d'un état (voir Map.get) ou d'une erreur d'implémentation comme une initialisation manquante ou échouée.

Cela change radicalement avec l'utilisation persistante de Optional. Ici, déjà l'occurrence de nullsignifie la présence d'un bug. (Parce que si la valeur avait été manquante, un Optionalaurait été utilisé.) Cela rend le débogage d'une exception de pointeur nul beaucoup plus facile car la question de la signification de cela nullest déjà résolue.

Plus de contrôles nuls

Maintenant que rien ne peut nullplus être , cela peut être appliqué partout. Que ce soit avec des annotations, des assertions ou des vérifications simples, vous n'avez jamais à vous demander si cet argument ou ce type de retour peut être nul. Ça ne peut pas!

Désavantages

Bien sûr, il n'y a pas de solution miracle ...

Performance

L'encapsulation de valeurs (en particulier les primitives) dans une instance supplémentaire peut dégrader les performances. Dans les boucles serrées, cela peut devenir perceptible, voire pire.

Notez que le compilateur peut être en mesure de contourner la référence supplémentaire pour les durées de vie de courte durée de Optionals. En Java 10 , les types de valeurs peuvent réduire ou supprimer davantage la pénalité.

Sérialisation

Optionaln'est pas sérialisable mais une solution de contournement n'est pas trop compliquée.

Invariance

En raison de l'invariance des types génériques en Java, certaines opérations deviennent lourdes lorsque le type de valeur réel est poussé dans un argument de type générique. Un exemple est donné ici (voir "Polymorphisme paramétrique") .

Personnellement, je préfère utiliser l'outil d'inspection de code d'IntelliJ pour l'utiliser @NotNullet les @Nullablevérifier car ce sont en grande partie du temps de compilation (peut avoir des vérifications d'exécution). Cela a une charge inférieure en termes de lisibilité du code et de performances d'exécution. Ce n'est pas aussi rigoureux que d'utiliser facultatif, mais ce manque de rigueur devrait être soutenu par des tests unitaires décents.

public @Nullable Foo findFoo(@NotNull String id);

public @NotNull Foo doSomething(@NotNull String id, @Nullable Bar barOptional);

public class Book {

  private List<Pages> pages;
  private @Nullable Index index;

}

List<@Nullable Foo> list = ..

Cela fonctionne avec Java 5 et pas besoin d'encapsuler et de dérouler les valeurs. (ou créez des objets wrapper)

Je pense que le Guava Facultatif et leur page wiki le disent assez bien:

Outre l'augmentation de la lisibilité qui résulte du fait de donner un nom à null, le plus grand avantage d'Optional est sa résistance à l'idiot. Cela vous oblige à penser activement au cas absent si vous voulez que votre programme compile, car vous devez déballer activement l'option et traiter ce cas. Null, il est troublant facilement d'oublier simplement des choses, et bien que FindBugs aide, nous ne pensons pas qu'il résout presque aussi bien le problème.

Cela est particulièrement pertinent lorsque vous renvoyez des valeurs qui peuvent ou non être "présentes". Vous (et d'autres) sont beaucoup plus susceptibles d'oublier que other.method (a, b) pourrait renvoyer une valeur nulle que vous risquez d'oublier que a pourrait être nul lorsque vous implémentez other.method. Le retour facultatif empêche les appelants d'oublier ce cas, car ils doivent déballer l'objet eux-mêmes pour que leur code soit compilé. - (Source: Guava Wiki - Utiliser et éviter null - À quoi ça sert? )

Optionalajoute quelques frais généraux, mais je pense que son avantage clair est de rendre explicite qu'un objet pourrait être absent et il oblige les programmeurs à gérer la situation. Cela empêche que quelqu'un oublie le != nullchèque bien-aimé .

En prenant l'exemple de 2 , je pense qu'il est beaucoup plus explicite d'écrire du code:

if(soundcard.isPresent()){
  System.out.println(soundcard.get());
}

que

if(soundcard != null){
  System.out.println(soundcard);
}

Pour moi, le Optionalmeilleur capture le fait qu'il n'y a pas de carte son présente.

Mes 2 ¢ sur vos points:

1. public Optional<Foo> findFoo(String id);- Je ne suis pas certain de cela. Peut-être que je retournerais un Result<Foo>qui pourrait être vide ou contenir un Foo. C'est un concept similaire, mais pas vraiment un Optional.
2. public Foo doSomething(String id, Optional<Bar> barOptional);- Je préférerais @Nullable et une vérification des trouvailles, comme dans la réponse de Peter Lawrey - voir aussi cette discussion .
3. Votre exemple de livre - je ne sais pas si j'utiliserais le Facultatif en interne, cela pourrait dépendre de la complexité. Pour l '"API" d'un livre, j'utiliserais un Optional<Index> getIndex()pour indiquer explicitement que le livre pourrait ne pas avoir d'index.
4. Je ne l'utiliserais pas dans les collections, plutôt que de ne pas autoriser les valeurs nulles dans les collections

En général, j'essaierais de minimiser le contournement de l' nullart. (Une fois brûlé ...) Je pense qu'il vaut la peine de trouver les abstractions appropriées et d'indiquer aux autres programmeurs ce qu'une certaine valeur de retour représente réellement.

À partir du didacticiel Oracle :

Le but d'Optional n'est pas de remplacer chaque référence null unique dans votre base de code, mais plutôt d'aider à concevoir de meilleures API dans lesquelles, simplement en lisant la signature d'une méthode, les utilisateurs peuvent dire s'ils doivent s'attendre à une valeur facultative. De plus, Facultatif vous oblige à déballer activement un Facultatif pour faire face à l'absence de valeur; par conséquent, vous protégez votre code contre les exceptions de pointeur nul involontaires.

1 - En tant que type de retour de méthode publique lorsque la méthode peut retourner null:

Voici un bon article qui montre l'utilité du cas d'utilisation # 1. Là ce code

...
if (user != null) {
    Address address = user.getAddress();
    if (address != null) {
        Country country = address.getCountry();
        if (country != null) {
            String isocode = country.getIsocode();
            isocode = isocode.toUpperCase();
        }
    }
}
...

se transforme en

String result = Optional.ofNullable(user)
  .flatMap(User::getAddress)
  .flatMap(Address::getCountry)
  .map(Country::getIsocode)
  .orElse("default");

en utilisant Facultatif comme valeur de retour des méthodes getter respectives .

Voici une utilisation intéressante (je crois) pour ... les tests.

J'ai l'intention de tester fortement un de mes projets et je construis donc des assertions; il y a seulement des choses que je dois vérifier et d'autres non.

Je construis donc des choses à affirmer et j'utilise un assert pour les vérifier, comme ceci:

public final class NodeDescriptor<V>
{
    private final Optional<String> label;
    private final List<NodeDescriptor<V>> children;

    private NodeDescriptor(final Builder<V> builder)
    {
        label = Optional.fromNullable(builder.label);
        final ImmutableList.Builder<NodeDescriptor<V>> listBuilder
            = ImmutableList.builder();
        for (final Builder<V> element: builder.children)
            listBuilder.add(element.build());
        children = listBuilder.build();
    }

    public static <E> Builder<E> newBuilder()
    {
        return new Builder<E>();
    }

    public void verify(@Nonnull final Node<V> node)
    {
        final NodeAssert<V> nodeAssert = new NodeAssert<V>(node);
        nodeAssert.hasLabel(label);
    }

    public static final class Builder<V>
    {
        private String label;
        private final List<Builder<V>> children = Lists.newArrayList();

        private Builder()
        {
        }

        public Builder<V> withLabel(@Nonnull final String label)
        {
            this.label = Preconditions.checkNotNull(label);
            return this;
        }

        public Builder<V> withChildNode(@Nonnull final Builder<V> child)
        {
            Preconditions.checkNotNull(child);
            children.add(child);
            return this;
        }

        public NodeDescriptor<V> build()
        {
            return new NodeDescriptor<V>(this);
        }
    }
}

Dans la classe NodeAssert, je fais ceci:

public final class NodeAssert<V>
    extends AbstractAssert<NodeAssert<V>, Node<V>>
{
    NodeAssert(final Node<V> actual)
    {
        super(Preconditions.checkNotNull(actual), NodeAssert.class);
    }

    private NodeAssert<V> hasLabel(final String label)
    {
        final String thisLabel = actual.getLabel();
        assertThat(thisLabel).overridingErrorMessage(
            "node's label is null! I didn't expect it to be"
        ).isNotNull();
        assertThat(thisLabel).overridingErrorMessage(
            "node's label is not what was expected!\n"
            + "Expected: '%s'\nActual  : '%s'\n", label, thisLabel
        ).isEqualTo(label);
        return this;
    }

    NodeAssert<V> hasLabel(@Nonnull final Optional<String> label)
    {
        return label.isPresent() ? hasLabel(label.get()) : this;
    }
}

Ce qui signifie que l'assertion ne se déclenche vraiment que si je veux vérifier l'étiquette!

OptionalLa classe vous permet d'éviter d'utiliser nullet de fournir une meilleure alternative:

• Cela encourage le développeur à vérifier la présence afin d'éviter les captures non détectées NullPointerException.

• L'API est mieux documentée car il est possible de voir où s'attendre aux valeurs qui peuvent être absentes.

Optionalfournit une API pratique pour continuer à travailler avec l'objet isPresent():; get(); orElse(); orElseGet(); orElseThrow(); map(); filter(); flatmap().

De plus, de nombreux frameworks utilisent activement ce type de données et le renvoient de leur API.

En java, ne les utilisez pas sauf si vous êtes accro à la programmation fonctionnelle.

Ils n'ont pas leur place en tant qu'arguments de méthode (je prémesserai quelqu'un un jour vous passera une option nulle nulle, pas seulement une option vide).

Ils ont un sens pour les valeurs de retour, mais ils invitent la classe cliente à continuer d'étirer la chaîne de développement du comportement.

FP et les chaînes ont peu de place dans un langage impératif comme java car il est très difficile à déboguer, pas seulement à lire. Lorsque vous passez à la ligne, vous ne pouvez pas connaître l'état ni l'intention du programme; vous devez intervenir pour le comprendre (dans du code qui n'est souvent pas le vôtre et de nombreux cadres de pile en profondeur malgré les filtres d'étape) et vous devez ajouter de nombreux points d'arrêt pour vous assurer qu'il peut s'arrêter dans le code / lambda que vous avez ajouté, au lieu de simplement parcourir les lignes triviales if / else / call.

Si vous voulez une programmation fonctionnelle, choisissez autre chose que Java et j'espère que vous avez les outils pour le déboguer.

Je ne pense pas que Facultatif soit un substitut général aux méthodes qui retournent potentiellement des valeurs nulles.

L'idée de base est: L'absence d'une valeur ne signifie pas qu'elle est potentiellement disponible à l'avenir. C'est une différence entre findById (-1) et findById (67).

La principale information des options pour l'appelant est qu'il peut ne pas compter sur la valeur donnée, mais qu'elle peut être disponible à un moment donné. Peut-être qu'il disparaîtra à nouveau et reviendra plus tard une fois de plus. C'est comme un interrupteur marche / arrêt. Vous avez la «possibilité» d'allumer ou d'éteindre la lumière. Mais vous n'avez aucune option si vous n'avez pas de lumière à allumer.

Je trouve donc trop compliqué d'introduire des options partout où précédemment null était potentiellement retourné. J'utiliserai toujours null, mais uniquement dans des zones restreintes comme la racine d'un arbre, l'initialisation paresseuse et les méthodes de recherche explicites.

Semble Optionalest utile que si le type T en option est un type primitif comme int, long, char, etc. Pour les classes « réelles », il n'a pas de sens pour moi que vous pouvez utiliser une nullvaleur de toute façon.

Je pense qu'il a été pris d'ici (ou d'un autre concept de langage similaire).

Nullable<T>

En C #, cela a Nullable<T>été introduit il y a longtemps pour encapsuler les types de valeur.

An a une sémantique similaire à une instance non modifiable du modèle de conception Iterator :Optional

• il peut ou non faire référence à un objet (comme indiqué par isPresent())
• il peut être déréférencé (en utilisant get()) s'il fait référence à un objet
• mais il ne peut pas être avancé à la position suivante dans la séquence (il n'a pas de next()méthode).

Par conséquent, envisagez de renvoyer ou de passer un Optionaldans des contextes où vous auriez précédemment envisagé d'utiliser un Java Iterator.

Java SE 8 introduit une nouvelle classe appelée java.util.Optional,

Vous pouvez créer un Facultatif ou un Facultatif vide avec une valeur nulle.

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

Et voici un Facultatif avec une valeur non nulle:

String valueString = new String("TEST");
Optional<String> optinalValueString = Optional.of(valueString );

Faites quelque chose si une valeur est présente

Maintenant que vous disposez d'un objet Facultatif, vous pouvez accéder aux méthodes disponibles pour traiter explicitement la présence ou l'absence de valeurs. Au lieu de devoir vous rappeler de faire une vérification nulle, comme suit:

String nullString = null;
if (nullString != null) {
    System.out.println(nullString);
}

Vous pouvez utiliser la méthode ifPresent (), comme suit:

Optional<String> optinalString= null;
optinalString.ifPresent(System.out::println);

package optinalTest;

import java.util.Optional;

public class OptionalTest {
    public Optional<String> getOptionalNullString() {
        return null;
//      return Optional.of("TESt");
    }

    public static void main(String[] args) {

        OptionalTest optionalTest = new OptionalTest();

        Optional<Optional<String>> optionalNullString = Optional.ofNullable(optionalTest.getOptionalNullString());

        if (optionalNullString.isPresent()) {
            System.out.println(optionalNullString.get());
        }
    }
}