通过最近一段时间对 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 就会容易很多。
