用Optional取代null

创建Optional对象

Optional.empty()：声明一个空Optional

Optional<Car> optCar = Optional.empty();

Optional.of()：依据一个非空值创建Optional

Optional<Car> optCar = Optional.of(car);

Optional.ofNullable：可接受null的Optional

Optional<Car> optCar = Optional.ofNullable(car);

读取Optional对象

orElse()：Optional对象不包含值时提供一个默认值

Optional.of("Hello").orElse("World");  // Hello
Optional.ofNullable(null).orElse("World");  // World

orElseGet()：Optional对象不包含值时执行get调用，延迟加载

Optional.of("Hello").orElseGet(() -> new String("World"));  // Hello
Optional.ofNullable(null).orElseGet(() -> new String("World"));  // World

orElseThrow()：Optional对象为空时抛出一个异常

Optional.ofNullable("Hello").orElseThrow(() -> new RuntimeException());  // Hello
Optional.ofNullable(null).orElseThrow(() -> new RuntimeException());  // RuntimeException

ifPresent()：Optional对象值存在时，执行后续；否则不进行任何操作。ifPresent()方法用来代替null空值判断

Optional.ofNullable("Hello").ifPresent(x -> System.out.println(x));  //Hello
Optional.ofNullable(null).ifPresent(x -> System.out.println(x));  // 无

转换Optional对象

map()：map操作会将提供的函数应用于流的每个元素。你可以把Optional对象看成一种特殊的集合数据，它至多包含一个元素。如果Optional包含一个值，那函数就将该值作为参数传递给map，对该值进行转换。如果Optional为空，就什么也不做

map入参是Function，用于 T->U ，最后的返回值用Optional.ofNullable()包装

public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
    Objects.requireNonNull(mapper);
    if (!isPresent())
        return empty();
    else {
        return Optional.ofNullable(mapper.apply(value));
    }
}

示例。先返回user，map转换成name，最后map转换成小写，返回name的小写String

Optional<String> username = Optional
                .ofNullable(getUserById(id))
                .map(user -> user.getUsername())
                .map(name -> name.toLowerCase());

flatMap()：和map()功能类似。区别是map()方法的Function形式是 T->U；flatMap()方法的Function形式是 T->Optional<U>

public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {
    Objects.requireNonNull(mapper);
    if (!isPresent())
        return empty();
    else {
        return Objects.requireNonNull(mapper.apply(value));
    }
}

示例。区别于上面的map示例：Optional.of

Optional<String> username = Optional
                .ofNullable(getUserById(id))
                .flatMap(user -> Optional.of(user.getUsername()))
                .flatMap(name -> Optional.of(name.toLowerCase()));

filter()：接受一个Predicate来对Optional中包含的值进行过滤。如果包含的值满足条件，那么还是返回这个Optional；否则返回Optional.empty()

public Optional<T> filter(Predicate<? super T> predicate) {
    Objects.requireNonNull(predicate);
    if (!isPresent())
        return this;
    else
        return predicate.test(value) ? this : empty();
}

示例。当user.getId()<10时，进行后续的map操作，否则返回Optional.empty()

Optional<String> username = Optional
                .ofNullable(getUserById(id))
                .filter(user -> user.getId() < 10)
                .map(user -> user.getUsername());