Consultez les notes de la classe java.util.Optional

Aperçu

Ceci est une note de révision de la classe java.util.Optional introduite dans Java 1.8.

environnement

• Windows 10 Professional
• Oracle JDK 9.0.4
• Oracle JDK 10.0.1

référence

• Documentation Oracle JDK 9
• Documentation Oracle JDK 10

Optional<T> - Java 1.8

empty / of / ofNullable

Les deux sont des méthodes statiques. Facultatif n'a pas de constructeur public, utilisez donc ces méthodes pour créer un objet Facultatif.

empty

Renvoie un objet facultatif avec une valeur nulle.

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

empty.isPresent();
// false

empty.orElse("other");
// other

empty.get();
// java.util.NoSuchElementException: No value present

of

Renvoie un objet facultatif avec une valeur non nulle.

String str = "nonNull";
Optional<String> nonNullString = Optional.of(str);

nonNullString.isPresent();
// true

nonNullString.get();
// result : nonNull

La transmission d'un objet nul à of lève une exception.

String str = null;
Optional.of(str);
//  java.lang.NullPointerException

ofNullable

Renvoie un objet facultatif avec une valeur qui peut être nulle (nullable).

String str = null;
Optional<String> nullableString = Optional.ofNullable(str);

nullableString.isPresent();
// false

nullableString.orElse("other");
// other

get / isPresent

get

Renvoie la valeur détenue par l'objet facultatif. Si la valeur à conserver est null, une NoSuchElementException sera levée.

String str = "apple";
Optional<String> nullableString = Optional.ofNullable(str);

nullableString.get();
// apple

String str = null;
Optional<String> nullableString = Optional.ofNullable(str);

nullableString.get();
// java.util.NoSuchElementException: No value present

isPresent

Renvoie true si la valeur détenue par l'objet facultatif est non nulle, false si elle est nulle.

String str = "apple";
Optional<String> nullableString = Optional.ofNullable(str);

nullableString.isPresent();
// true

String str = null;
Optional<String> nullableString = Optional.ofNullable(str);

nullableString.isPresent();
// false

orElse / orElseGet / orElseThrow

orElse

Renvoie la valeur détenue par l'objet facultatif. Si la valeur à conserver est nulle, la valeur spécifiée est renvoyée. (Null est également possible)

String str = "nonNull";
Optional<String> nullableString = Optional.ofNullable(str);

nullableString.orElse("other");
// nonNull

String str = null;
Optional<String> nullableString = Optional.ofNullable(str);

nullableString.orElse("other");
// other

nullableString.orElse(null);
// null

orElseGet

Renvoie la valeur détenue par l'objet facultatif. Si la valeur à conserver est nulle, le résultat du fournisseur spécifié est renvoyé. Si le fournisseur renvoie null, il renverra null.

String str = "nonNull";
Optional<String> nullableString = Optional.ofNullable(str);

nullableString.orElseGet(() -> "other");
// nonNull

String str = null;
Optional<String> nullableString = Optional.ofNullable(str);

nullableString.orElseGet(() -> "other");
// other

nullableString.orElseGet(() -> null);
// null

orElseThrow

Renvoie la valeur détenue par l'objet facultatif. Si la valeur à conserver est nulle, l'exception spécifiée sera levée.

String str = null;
Optional<String> nullableString = Optional.ofNullable(str);

nullableString.orElseThrow(RuntimeException::new);
// java.lang.RuntimeException

ifPresent

Si la valeur détenue par l'objet facultatif n'est pas nulle, le bloc de traitement consommateur spécifié dans l'argument est exécuté avec cette valeur. Si la valeur détenue par l'objet facultatif est nulle, aucune exception n'est levée et rien n'est exécuté.

Optional<Employee> employee = Optional.ofNullable(new Employee(1L, "john"));
employee.ifPresent((e) -> {
    e.setName(e.getName().toUpperCase());
    System.out.println(e);
    // Employee{id=1, name='JOHN'}
});

filter / map / flatMap

filter

Si la valeur détenue par l'objet facultatif est non nulle, le bloc de traitement Predicate spécifié dans l'argument avec cette valeur est exécuté.

Optional<String> nullableString = Optional.ofNullable("banana");

Optional<String> filtering = nullableString.filter(str -> str.length() > 5);
filtering.isPresent();
// true

filtering.orElse("other");
// banana

Si la valeur détenue par l'objet facultatif est nulle ou si le bloc de traitement Predicate renvoie false, un facultatif vide est renvoyé.

Optional<String> nullableString = Optional.ofNullable("apple");
// Optional<String> nullableString = Optional.ofNullable(null);

Optional<String> filtering = nullableString.filter(str -> str.length() > 5);
filtering.isPresent();
// false

filtering.orElse("other");
// other

map

Si la valeur détenue par l'objet facultatif est non nulle, le bloc de traitement de la fonction spécifié dans l'argument est exécuté avec cette valeur.

Optional<String> nullableString = Optional.ofNullable("apple");
Optional<Integer> mapping = nullableString.map(str -> str.length());

mapping.isPresent();
// true

mapping.orElse(0);
// 5

Si la valeur détenue par l'objet facultatif est nulle ou si le bloc de traitement de la fonction renvoie null, un facultatif vide est renvoyé.

Optional<String> nullableString = Optional.ofNullable(null);
Optional<Integer> mapping = nullableString.map(str -> str.length());

mapping.isPresent();
// false

mapping.orElse(0);
// 0

flatMap

Si la valeur détenue par l'objet facultatif est non nulle, le bloc de traitement de la fonction spécifié dans l'argument est exécuté avec cette valeur. La différence avec la carte est que Function renvoie un objet facultatif.

La fonction spécifiée dans la carte prend le type T et renvoie le type U.

Function<? super T,? extends U> mapper

La fonction spécifiée dans flatMap prend le type T et renvoie le type facultatif .

Function<? super T,Optional<U>> mapper

Optional<Long> optId = Optional.of(1L);
Optional<String> optName = Optional.of("john");

Optional<Employee> result = optId.flatMap(id -> optName.flatMap(name -> Optional.of(new Employee(id, name))));

result.isPresent();
// true

result.orElse(null);
// Employee{id=1, name='john'}

Optional<Long> optId = Optional.of(1L);
Optional<String> optName = Optional.ofNullable(null);

Optional<Employee> result = optId.flatMap(id -> optName.flatMap(name -> Optional.of(new Employee(id, name))));

result.isPresent();
// false

result.orElse(null);
// null

Optional<Optional<String>> nullableName = employee.map(emp -> Optional.ofNullable(emp.getName()));

Optional<Employee> employee = Optional.ofNullable(null);

employee.ifPresentOrElse((e) -> {
    e.setName(e.getName().toUpperCase());
    System.out.println(e);
},
() -> {
    System.out.println("empty action");
    // empty action
});

String str = null;
Optional<String> nonNullString = Optional.ofNullable(str).or(() -> Optional.of("nonNull"));

nonNullString.isPresent();
// true

nonNullString.get();
// nonNull

List<Optional<String>> list = List.of(
    Optional.of("a"),
    Optional.of("b"),
    Optional.of("c"),
    Optional.empty(),
    Optional.of("e"),
    Optional.empty(),
    Optional.of("g")
);

list.stream().filter(Optional::isPresent).map(Optional::get).forEach(System.out::println);
// a
// b
// c
// e
// g

//Lors de l'utilisation de stream
list.stream().flatMap(Optional::stream).forEach(System.out::println);
// a
// b
// c
// e
// g

public <X extends Throwable> T orElseThrow​(Supplier<? extends X> exceptionSupplier)
    throws X extends Throwable

public T get()

public T orElseThrow()

public boolean isEmpty()