全面探索Optional类型

最近，出版社邀请我作为分享导师为Bruce Eckel的大作OnJava录制部分视频，视频内容主要面向Java初学者。录制到14.4章节，书中详细介绍了Java 8引入的Optional类型，我忽然想起很早以前写的一篇文章《并非Null Object这么简单》。

或许是《OnJava》更倾向于对Java语法的介绍，又或者对于这样一部鸿篇巨制，如果对Java的每一个语法都要深入探讨，可能篇幅就实在太长了，因此该书并未详细介绍Optional的“前世今生”，自然也不会去对比其他语言的类似语法。想到这一点，就觉得我写的这篇文章对于广大读者而言，应该有一定参考价值，那就不如将它分享给大家。

1

在大多数程序语言中，我们都需要与Null打交道，并且纠缠于对它的检查中。一不小心让它给溜出来，就可能像打开潘多拉的盒子一般，给程序世界带来灾难。

说起来，在我们人类世界中，Null到底算什么“东西”呢？语义上讲，它就是一场空，即所谓“虚无”。然而，这个世界并没有任何物质可以代表“虚无”，因而它仅存于我们的精神层面。说虚无存在其实是一种悖论，因为存在其实是虚无的反面。若从程序本质上讲，Null代表一种状态，指一个对象（或变量），虽获声明却未真正诞生，甚至可能永远不会诞生。而一旦诞生，Null就被抹去了，回归了正确的状态。

站在OO的角度来讲，既然Everything is object，自然可以将Null同样视为Object——这近似于前面提到的悖论，既然是Null，为何又是Object呢？换言之，在对象世界里，其实没有什么不存在，所谓“不存在”仍然是一种“存在”。这么说容易让人变糊涂，就好像我们搞不清楚“我是谁”。所以，我宁肯采用Martin Fowler的说法，将Null Object视为一种Special Case，即Null其实是一种特例。

视Null为一种特例，即可用OO的特化来表达。当某个对象可能存在Null这种状态时，都可以将这种状态表示为一种特化的类，它不再代表Null，而是代表“什么都不做”。凡是返回Null的地方，都替换为这个Null Object，用以表达这种Null其实仅仅是一种特列。于是乎，我们像抹杀异教徒一般抹去了“虚无”的存在。（当虚无被抹去，是什么样的存在？）

然而，若在Java程序语言中实现自己的Null Object，固然可以在一定程度上消除对Null的检查，却存在一些约束：

• 对于String之类的类型，无法定义NullString子类；
• 每次都需要自己去定义子类来表示Null；
• 必须约束团队不能返回Null。

这些约束未免给我们使用该模式带了诸多不便。

2

Google的Guava框架为了解决这一问题，引入了Optional（那是在还未诞生Java 8的时代）：

public abstract class Optional<T> implements Serializable {
  public static <T> Optional<T> absent() {
    return (Optional<T>) Absent.INSTANCE;
  }
  public static <T> Optional<T> of(T reference) {
    return new Present<T>(checkNotNull(reference));
  }
  public static <T> Optional<T> fromNullable(@Nullable T nullableReference) {
    return (nullableReference == null)
        ? Optional.<T>absent()
        : new Present<T>(nullableReference);
  }
  public abstract boolean isPresent();
  public abstract T get();
  public abstract T or(T defaultValue);
  public abstract <V> Optional<V> transform(Function<? super T, V> function);
}

我们可以这样来使用Optional:

  public final Optional<E> first() {
    Iterator<E> iterator = iterable.iterator();
    return iterator.hasNext()
        ? Optional.of(iterator.next())
        : Optional.<E>absent();
  }

first()方法返回的是一个Optional类型。这是Guava中操作集合的一个方法。当我们要获得第一个元素时，可以调用该方法：

List<Person> persons = newArrayList();
String name = from(persons).first().transform(new Function<Person, String>() {
        @Override
        public String apply(Person input) {
            return input.getName();
        }
    }).or("not found");
assertThat(name, is("not found"));

不知是巧合，还是一种借鉴，Java 8同样定义了Optional用以处理这种情况。前面的代码在Java 8下可以改写为：

List<Person> persons = newArrayList();
String name = persons.stream()
                     .findFirst()
                     .map(p -> p.getName())
                     .orElse("not found");
assertThat(name, is("not found"));

其实Scala在很早以前就提供了Option[T]类型。前面的代码若用scala编写，就变成：

case class Person(name: String, age: Int)
val persons = List[Person]()
persons.headOption.map(p => p.name).getOrElse("not found")

3

这样的设计方式，还是Null Object模式吗？

让我们回到Null的本原状态，思考为什么会产生Null？首先，Null代表一种异常状态，即在某种未可知的情形下，可能返回Null；正常情况下，返回的则是非Null的对象。Null与非Null，代表一种未知与不确定性，在量子力学中，就是薛定谔的猫。

在程序世界里，我们似乎可以将其抽象为一个集合来表达这种非此即彼的状况，但从函数式编程的角度来讲，应将其设计为一个Monad。根据DSL in Action一书对Monad的介绍，一个Monad由以下三部分定义：

• 一个抽象M[A],其中M是类型构造函数。在Scala语言中可以写成class M[A]，或者case class M[A]，有或者trait M[A]
• 一个unit方法（unit v)。对应Scala中的函数new M(v)或者M(v)的调用。
• 一个bind方法，起到将运算排成序列的作用。在Scala中通过flatMap组合子来实现。bind f m对应的Scala语句是m flatMap f。

同时，Monad还必须满足以下三条规则。

1. 右单位元(identity)。即对于任意Monad m，有m flatMap unit => m。对于Option，unit就是Option伴生对象定义的apply()方法。若m为Some("Scala")，则m flatMap {x => Option(x)}，其结果还是m。

2. 左单位元(unit)。即对于任意Monad m，有unit(v) flatMap f => f(v)。假设我们定义一个函数f：

def f(v: String) = Option(v)

则Option("Scala") flatMap {x => f(x)}的结果就等于f("scala")。

3. 结合律。即对于任意Monad m，有m flatMap g flatMap h => m flatMap {x => g(x) flatMap h}。

4

无论是Scala中的Option[A]，还是Java 8中的Optional[T]，都是一个Monad。此时的Null不再是特例，而是抽象Option[A]对称的两个元素中的其中一个，在Scala中，即Option[T]中的Some[T]或None。它们俩面貌相同，却是一对性格迥异的双生子。

在设计为Monad后，就可以利用Monad提供的bind功能，完成多个函数的组合。组合时，并不需要考虑返回为None的情况。Monad能保证在前一个函数返回空值时，后续函数不会被调用。

让我们来看一个案例。例如，我们需要根据某个key从会话中获得对应的值，然后再将该值作为参数去查询符合条件的特定Customer。在Scala中，可以将这两个步骤定义为函数，返回结果分别为Option[String]与Option[Customer]：

def params(key: String): Option[String]
def queryCustomer(refId: String): Option[Customer]
val customer = 
    (
        for {
            r <- params("customerId")
            c <- queryCustomer(r)
        } yield c
    ) getOrElse error("Not Found")

这段代码用到了Scala的for comprehension，它实则是对flatMap的一种包装。尤其当嵌套多个flatMap时，使用for comprehension会更加直观可读。翻译为flatMap，则为：

params("customerId").flatMap{
    r => queryCustomer(r).map {
        c => c
    }
} getOrElse error("Not Found")

当我最初看到Guava设计的Optional[T]时，我以为是Null Object模式的体现。事实上，它的功能要超出Null Object的范畴。但它也并非Monad，在前面给出的定义中，我们可以看到Guava的Optional[T]仅提供了map（即定义中的transform)功能，而没有提供更基本的flatMap操作。

具有函数式编程功能的Scala与Java 8加强了这一功能，利用Monad强化了程序对Null的处理。