java8|Optional 和四个重要的函数式接口—— 简单的

通过最近一段时间对 Optional<T> 的学习和应用，作出本文的总结。

愿景

Optional就如同一个画中美女，能不能让她从画中走出来，就看各位程序员的态度了，只有等她真正走出来，我们才能评判它是否符合设计者的初衷—— 将null 对象化，应用得当我们将不再需要从巨量代码中排查空指针异常。

问题

诚如所有java程序员经历的一样，我们日常总投入大量的精力在 NullPointerException 排查上。

源码

下面是optional 的源码，还是很简洁的，理解并不难，难的是克服过去的习惯应用于生产环境中。

package java.util;

import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

public final class Optional<T> 
    private static final Optional<?> EMPTY = new Optional();
    private final T value;

    private Optional() {
        this.value = null;
    }

    public static <T> Optional<T> empty() {
        Optional var0 = EMPTY;
        return var0;
    }

    private Optional(T var1) {
        this.value = Objects.requireNonNull(var1);
    }

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

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

    public T get() {
        if (this.value == null) {
            throw new NoSuchElementException("No value present");
        } else {
            return this.value;
        }
    }

    public boolean isPresent() {
        return this.value != null;
    }

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

    }

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

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

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

    public T orElse(T var1) {
        return this.value != null ? this.value : var1;
    }

    public T orElseGet(Supplier<? extends T> var1) {
        return this.value != null ? this.value : var1.get();
    }

    public <X extends Throwable> T orElseThrow(Supplier<? extends X> var1) throws X {
        if (this.value != null) {
            return this.value;
        } else {
            throw (Throwable)var1.get();
        }
    }

    public boolean equals(Object var1) {
        if (this == var1) {
            return true;
        } else if (!(var1 instanceof Optional)) {
            return false;
        } else {
            Optional var2 = (Optional)var1;
            return Objects.equals(this.value, var2.value);
        }
    }

    public int hashCode() {
        return Objects.hashCode(this.value);
    }

    public String toString() {
        return this.value != null ? String.format("Optional[%s]", this.value) : "Optional.empty";
    }
}

简单分析

其实这个源码不需要分析，很浅显的代码。难在应用。
真正重要，理解有难度的是头部引入的四个接口

• Consumer
• Function
• Predicate
• Supplier

Consumer 接口

java8中给出一个重要接口，其实掌握命令设计模式的人，对这个接口并不陌生，这就是官方给出的一个命令模式的命令接口，用于传递方法。在java8中，方法已经和对象成为同一级别的概念。
如果不懂什么是命令接口，可以这么理解，一般的参数，是被处理的对象，
而定义一个命令接口，可以让我们通过该接口传入接口的匿名实现，相当于传入的是一段逻辑，而非数据。

@FunctionalInterface
public interface Consumer<T> {

    void accept(T t);

    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

Function 接口

映射接口

@FunctionalInterface
public interface Function<T, R> {

    R apply(T t);

    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }
    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

这段源码需要读者理解java 8接口的默认方法，这是java 8 的一个重要特性，简单说就是接口里是允许有默认的实现的。本文不展开讨论（我也不懂行了吧）。
这个函数式接口，主要的作用是类型转换，在Optional 和 Stream 编程中，大量的map 方法以此为切入。可以理解这个一个模具，由输入类型T的对象得到 输出类型R的对象。

Predicate 接口

有翻译管这个接口叫谓词接口，我猜翻译的人应该是语文没学好，正确的理解应该是，某种程度上这是一个具象的Function接口，它的返回类型以类定义的形式固定成Boolean, 可以将所有判非的场景抽象到函数层面，以更加可读优美的形式来实现我们的业务代码，
为什么描述这么抽象，因为我也不会用！！！

@FunctionalInterface
public interface Predicate<T> {


    boolean test(T t);

    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

    default Predicate<T> negate() {
        return (t) -> !test(t);
    }

  
    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

   
    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

Supplier 接口

符合我们以前的经验，字越少的阅读理解最难理解，看看这个的应用场景，再看看这个接口定义，尼玛！！！

简单来说他还是一个Function 接口特殊具象， 零入参，T出参。所以其实如果我们有心，在应用中Function 接口从理解层面是可以替换掉Supplier、Predicate两个接口。但是根据语义，结合java 8 的方法引用，我们可以利用Supplier完成所有工厂类的定义。

@FunctionalInterface
public interface Supplier<T> {

    T get();
}

API

下面把Optional 几个重要的接口列出来：

• empty : 创建一个空壳的Optional
• ofNullable ：根据入参创建一个Optional ,如果入参为null ,创建一个空壳的Optional
• get ：拿到包装类中原始对象。如果原始对象为null ,则报NoSuchElementException异常，不推荐使用这个方法
• isPresent ：判断是否包装对象为null
• ifPresent: 根据情况，对包装对象进行处理，避免了空指针异常，注意此方法没有返回值
• filter ： 一个更重要的方法，常见于java8 的Stream编程，用于过滤容器中的对象，留下符合条件的
• map： 用于对象映射处理
• flatMap： 与map 作用相同，区别在于减少容器本身的叠加
• orElseGet ： 有一个入参，可以传入一个Supplier， 容器有值的情况下返回值，空的情况根据工厂返回一个默认值
• orElseThrow ： 有一个入参，可以传入一个Supplier，容器有值的情况下返回值，空的情况根据工厂创建并抛出一个异常

尾声

直接学习Stream 编程是有门槛的，但是如果我们能很好的掌握比较简单的Optional ，理解复杂的Stream 就会容易很多。