Java8-Optional

Optional

java8添加的容器对象，在一些场景下避免使用null检查而设定的类，尽可能避免的NullPointerException。

创建Optional实例的静态方法

Optional私有了构造函数，只能通过Optional对外提供了三个静态方法构造实例

empty

public static<T> Optional<T> empty()
返回一个空Optional实例

Optional<Object> empty = Optional.empty();
System.out.println(empty); // 输出：Optional.empty

of

public static <T> Optional<T> of(T value)
创建一个包含非null值的Optional容器，如果值为null会直接抛出NullPointerException

Optional.of("");
Optional.of(null); // 会抛空指针异常

ofNullable

public static <T> Optional<T> ofNullable(T value)
创建一个可以包含null值的Optional容器

Optional.ofNullable(null);

Optional实例方法

get

public T get()
返回Optional容器保存的非null值，如果值为null会抛出NoSuchElementException

Optional<Object> empty = Optional.empty();
System.out.println(empty.get()); // 抛NoSuchElementException
Optional<Object> nullable = Optional.ofNullable(null);
System.out.println(nullable.get()); //  抛NoSuchElementException
Optional<Object> non = Optional.ofNullable("test");
System.out.println(non.get()); // 输出：test

orElse

public T orElse(T other)
如果存在则返回值，否则返回other，是否存在的判断为null或者是一个empty

Object data1 = Optional.ofNullable(null).orElse("data");
System.out.println(data1); // 输出：data
Object data2 = Optional.ofNullable("data1").orElse("data2");
System.out.println(data2); // 输出：data1

orElseGet

public T orElseGet(Supplier<? extends T> other)
如果存在则返回值，否则调用other并返回该调用的结果。

Object data = Optional.ofNullable(null).orElseGet(() -> "data");
System.out.println(data); // 输出：data

orElse与orElseGet的区别

public static <T> T getValue(T oldValue, T newValue) {
    System.out.println(newValue);    
    return newValue;
}

Optional.ofNullable("a").orElse(getValue("test1"));
Optional.ofNullable("b").orElseGet(() -> "test2");
// 此时会看到控制台输出了test1
// orElse即使值不为空的情况下，也会调用orElse()中的函数，而orElseGet是在值为空的情况下才会调用other中的函数
// 如果有如下代码那么将是致命的
User u1 = Optional.ofNullable(user).orElse(userMapper.findUserById("1")); // 1
User u2 = Optional.ofNullable(user).orElse(new User()); // 2
// 哪怕user不为空也会去查询一次数据库，或者user不为空也会创建一个对象，加大了性能消耗，所以在使用时需要注意

orElseThrow

public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X
如果存在返回包含的值，否则抛出定义的异常。

// 当user为空的时候，抛出定义的异常
User user = Optional.ofNullable(user).orElseThrow(() -> new RuntimeException("User为空"));

isPresent

public boolean isPresent()
如果存在值则返回true，否则返回false。

boolean b1 = Optional.empty().isPresent(); // false
boolean b2 = Optional.ofNullable(null).isPresent(); // false
boolean b3 = Optional.ofNullable("").isPresent(); // ture

ifPresent

public void ifPresent(Consumer<? super T> consumer)
如果存在值，则执行指定的操作，否则不执行任何操作。

Optional.ofNullable(null).ifPresent(System.out::println); // 不会执行
Optional.ofNullable("data").ifPresent(System.out::println); // 输出data

filter

public Optional<T> filter(Predicate<? super T> predicate)
根据给定的条件过滤值，过滤后如果存在值则返回Optional包装的值，否则返回空的Optional。

Optional<String> str1 = Optional.ofNullable("123456").filter(element -> element.contains("123"));
System.out.println(str1); // 输出：Optional[123456]
Optional<String> str2 = Optional.ofNullable("123456").filter(element -> element.contains("789"));
System.out.println(str2); // 输出：Optional.empty

map

public<U> Optional<U> map(Function<? super T, ? extends U> mapper)
如果存在值，就对该值执行mapping调用，返回mapping后Optional包装的值，否则返回空的Optional。

Student student = new Student("zhangsan",10);
Optional<String> name = Optional.of(student).map(Student::getName); // 返回一个Optional包装的值

flatMap

public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper)
如果值存在，就对该值执行mapping调用，返回一个 Optional 类型的值，否则就返回一个空的 Optional 对象

Student student = new Student("zhangsan",10);
Optional<Integer> age = Optional.of(student).flatMap(s -> Optional.ofNullable(s.getAge())); // 返回一个Optional包装的值

map与flatMap的区别

map接受的入参为任意类型，flatMap接受的入参为Optional<U>类型，返回的都是Optional<U>