Valeur de Optional.of (« xxxx ») Programmation en Java

Question

S'il vous plaît considérer le code java suivant:

Optional.of("some.constant.value") 

Comment est d'utiliser Optional.of() de toute valeur lorsque le paramètre est une constante?

Answer 1

Facultatif est généralement utilisé comme valeur de retour d'une fonction qui peut renvoyer ou non une valeur. C'est une technique pour éviter de traiter des valeurs nulles.

E.g. en supposant que vous avez une fonction qui renvoie un Optional<Integer>, vous pouvez l'utiliser pour fournir une valeur par défaut:

int x = person.getAge().orElse(42); 

La fonction d'usine, vous faites référence est la façon dont une option est construit dans la fonction appelée:

public Optional<Integer> getAge(){ 
    if(this.age == null) 
     return Optional.empty(); 
    return Optional.of(this.age); 
} 

Answer 2

Ceci est entièrement contextuel, et sans ce contexte, il est impossible pour quiconque de le dire.

Mais ... Comme deux ou trois fois, je l'ai vu des choses comme ça être utile (vous pouvez peut-être identifier lequel est pertinente à votre situation donnée:

---

Une interface où une méthode est un Optional.

interface PotentiallyLimited { 
    OptionalInt getLimit(); 
} 

class LimitedToTen implements PotentiallyLimited { 
    private static final OptionalInt LIMIT = OptionalInt.of(10); 

    @Override 
    public final OptionalInt getLimit() { 
     return LIMIT; 
    } 
} 

Dans ce cas, la variable ayant mémorisée comme constante, il arrête d'avoir à générer une nouvelle instance à chaque fois.

---

Une classe dans laquelle une dépendance renverrait un Optional, mais peut ne pas être présente.

class Thing { 
    private static final Optional<String> DEFAULT_PREFERENCE = Optional.of("blue"); 
    private final @Nullable PreferenceProvider provider; 

    public void useDependency() { 
     final Optional<String> preference; 
     if (dependency != null) { 
      preference = provider.getPreference(); 
     } else { 
      preference = DEFAULT; 
     } 
     // Use the preference here... 
    } 
} 

Encore une fois, l'avoir comme une constante signifie que vous n'avez pas besoin de créer une nouvelle instance à chaque invocation.

---

Un dernier cas, je l'ai vu, que vous avez une interface qui a une sorte de boolean isError(); et un Optional<String> getErrorReason(); supplémentaire. Il est parfaitement raisonnable d'avoir une implémentation qui représente toujours une erreur, puis de définir explicitement l'option à partir d'une constante connue String permet d'éviter de créer beaucoup d'instances.

---

Je suis sûr qu'il y a beaucoup d'autres fois, il pourrait être utile de le faire.