optional java8

• Optional是什么?

Optional 类是一个容器对象,他可以保存类型为T的值,也可以仅仅保存null。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。

Optional提供了很多方法,让我们不用显式的进行空值检查.它的引进是为了更好的解决空指针问题.

• 举个栗子

假如现在我们想获取某个用户的国籍(如果该用户没有国籍,则默认返回中国):

public String getCountryOfUser(User user){
    if(user != null){
        Address address = user.getAddress();
        if(address != null){
            String country = address.getCountry();
            if(country != null){
                return country;
            }
        }
    }
    return "China";
}

又臭又长,毫无美感,那么假如我们用Optional会是什么样子呢?

    public String getCountryOfUserForOptional(User user){
        return Optional.ofNullable(user)
                .map(u -> u.getAddress())
                .map(a  -> a.getCountry())
                .orElse("China");
    }

不说其它了,就看他代码行数少了这么多,而且少了那么多的if就很舒服.

• Optional api

创建一个Optional对象

• of

Optional<Address> address = Optional.of(new Address("China","Guangdong"));

of里面不能为null,否则会抛出NullPointException的错误

• ofNullable

Optional<Address> address = Optional.ofNullable(new Address("China","Guangdong"));

ofNullable中可以为null,当为null时,实际上调用了empty()的方法.

    public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }

• empty()
  创建一个空Optional对象

获取容器里面的对象

• get()

Optional<Address> optional = Optional.ofNullable(new Address("China", "GuangDong"));
Address address = optional.get();

optional容器调用了get()会获取容器里面的对象,如果是空的optional,当调用get()时会报NoSuchElementException

判断是否为空

• isPresent() : 判断optional容器是否为空,如果不为空,返回true
  `Optional.ofNullable(new User("huangzp", 24, null)).isPresent()

• ifPresent(Consumer<T> consumer) : 如果 optional容器不为空,则执行lambda.

Optional.ofNullable(new User("huangzp", 24, null)).ifPresent( user -> System.out.println(user.getName()));

返回默认值

• orElse(T t)
  传入一个T对象,当容器为空时返回 t
• orElseGet(Supplier<? extends T> other)
  传入一个lambda表达式,当容器为空返回 T
• orElseThrow
  传入一个lambda表达式,当容器为空返回 异常

Optional.ofNullable(new User("huangzp", 24, null)).orElseThrow(() -> new NullPointerException())

二者的异同 : orEles 不管容器是否为空都会创建t, 而 orElseGet只有当容器为空的时候才会创建t.

转换值

• map()

    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));
        }
    }

如果optional容器的值不为空,则对optional的值进行转换.

Optional.ofNullable(new User("huangzp", 24, null)).map(user -> user.getName());

• flatMap()

    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));
        }
    }

如果optional的值不为空,,则对optional的值进行转换,但是没有封装成Optional.

Optional.ofNullable(new User("huangzp", 24, null)).flatMap(user -> Optional.ofNullable(user.getName()));

过滤值

• filter

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

对满足一定条件的Optional进行过滤

         Optional.ofNullable(new User("huangzp", 24, null))
.filter(user -> user.getAge() > 27).ifPresent(user -> System.out.println(user.getName()));