jdk8新特性Optional

前言

Java世界中最为常见的异常就是npe了，所以使用对象前对对象判空是保证代码鲁棒性的重要保证，因此在jdk7之前我们经常写出这样的代码:

        if (someObject != null) {
            if (someObject.someField != null) {
                if (someObject.someField.someField != null) {
                    Systemout.println(someObject.someField.someField)
                }
            }
        }

代码逻辑虽然不复杂但是过于繁复，于是在jdk8提供了一个新的特性Optional，结合lambda表达式可以极大地简化我们的判空操作，先来看看使用Optional如何重构上面那一段代码

Optional.ofNullable(someObject).map(SomeObject::getSomeField).map(SomeField::getSomeField).ifPresent(System.out::println);

可以看到借助于lambda表达式，之前的多重嵌套的判空操作只需要一行代码就可以完成。

再来看看通过Optional规避集合越界的代码

List list = new ArrayList();

Optional.ofNullable(list).filter(e -> e.size() > 0).map(e -> e.get(1)).ifPresent(System.out::println);

这里是有了Optional中的filter操作符，只有符合lambda表达式条件的元素才不会被过滤进入下一个操作符map，因此长度不符合要求的数组根本不会被取值。

除了上述的map，filter和isPresent操作符，Optional还提供了一系列其他的常用操作符。

Optional操作符

1 ofNullable

传入的对象可以为null

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

2 of

传入的对象不可以为null，否则抛出NullPointerException

    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }

例子

public static void main(String[] args) {

    User user = new User();
    User user1 = null;

    // 传递进去的对象不可以为null，如果为null则抛出异常
    Optional<User> op1 = Optional.of(user1);

    // 传递进去的对象可以为null，如果为null则返回一个没有装载对象的Optional容器
    Optional<User> op2 = Optional.ofNullable(user);
}

3 ifPresent

首先来看看ifPresent(Consumer<? super T> consumer)方法

public void ifPresent(Consumer<? super T> consumer) {
    if (value != null)
        consumer.accept(value);
}

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
}

复制代码如果容器中的对象存在，则调用accept方法，比如说：

public static void main(String[] args) {

    User user = new User();
    user.setName("Java3y");
    test(user);
}

public static void test(User user) {

    Optional<User> optional = Optional.ofNullable(user);

    // 如果存在user，则打印user的name
    optional.ifPresent((value) -> System.out.println(value.getName()));

    // 旧写法
    if (user != null) {
        System.out.println(user.getName());
    }
}

4 orElseGet和orElseThrow

直接看源码：

// 如果对象存在，则直接返回，否则返回由Supplier接口的实现用来生成默认值
public T orElseGet(Supplier<? extends T> other) {
    return value != null ? value : other.get();
}


@FunctionalInterface
public interface Supplier<T> {
    T get();
}


// 如果存在，则返回。否则抛出supplier接口创建的异常
public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
    if (value != null) {
        return value;
    } else {
        throw exceptionSupplier.get();
    }
}

例子：

public static void main(String[] args) {

    User user = new User();
    user.setName("Java3y");
    test(user);
}

public static void test(User user) {

    Optional<User> optional = Optional.ofNullable(user);

    // 如果存在user，则直接返回，否则创建出一个新的User对象
    User user1 = optional.orElseGet(() -> new User());
    
    // 旧写法
    if (user != null) {
        user = new User();
    }
}

总的来说跟我们上面所讲的orElse()差不多，只不过它可以通过Supplier接口的实现来生成默认值。

5 filter

// 如果容器中的对象存在，并且符合过滤条件，返回装载对象的Optional容器，否则返回一个空的Optional容器
public Optional<T> filter(Predicate<? super T> predicate) {
    Objects.requireNonNull(predicate);
    if (!isPresent())
        return this;
    else
        return predicate.test(value) ? this : empty();
}


// 接口
@FunctionalInterface
public interface Predicate<T> {

    boolean test(T t);
}

由于返回的是Optional对象，我们就可以实现链式调用了！
例子：

public static void test(User user) {

    Optional<User> optional = Optional.ofNullable(user);

    // 如果容器中的对象存在，并且符合过滤条件，返回装载对象的Optional容器，否则返回一个空的Optional容器
    optional.filter((value) -> "Java3y".equals(value.getName()));
}

6 map