《Guava之Optional》

《Guava之Optional》

对于null的随意使用会一系列难以预料的问题。通过对大量代码的研究和分析，我们发现大概95%以上的集合类默认并不接受null值，如果有null值将被放入集合中，代码会立刻中断并报错而不是默认存储null值，对于开发来说，这样能够更加容易的定位程序出错的地方。

　　另外，null值是一种令人不满的模糊含义。有的时候会产生二义性，这时候我们就很难搞清楚具体的意思，如果程序返回一个null值，其代表的含义到底是什么，例如：Map.get(key)若返回value值为null，其代表的含义可能是该键指向的value值是null，亦或者该键在map中并不存在。null值可以表示失败，可以表示成功，几乎可以表示任何情况。用其它一些值(而不是null值)可以让你的代码表述的含义更清晰。

　　反过来说，使用null值在有些情况下是一种正确的选择，因为从内存消耗和效率方面考虑，使用null更加廉价，而且在对象数组中出现null也是不可避免的。但是在程序代码中，比方说在函数库中，null值的使用会变成导致误解的元凶，也会导致一些莫名的，模糊的，很难修正的问题。就像上述map的例子，字典返回null可以代表的是该键指向的值存在且为空，或者也可以代表字典中没有这个键。关键在于，null值不能指明到底null代表了什么含义.

null会带来很多问题，从开始有null开始有无数程序栽在null的手里，null的含义是不清晰的，检查null在大多数情况下是不得不做的，而我们又在很多时候忘记了对null做检查，在我们的产品真正投入使用的时候，空指针异常出现了，这是一种讨厌的情况。

鉴于此google的guava库中提供了Optional接口来使null快速失败，即在可能为null的对象上做了一层封装，在使用Optional静态方法of时，如果传入的参数为null就抛出NullPointerException异常。下面来看下Guava库中的Optional类。

1、获取Optional实例的几种方法

1、Optional.of(T)：获得一个Optional对象，其内部包含了一个非null的T数据类型实例，若T=null，则在运行时抛异常。

2、Optional.absent()：获得一个Optional对象，其内部包含了null(即空值)。

3、Optional.fromNullable(T)：将一个T的实例转换为Optional对象，T的实例可以不为空，也可以为空；即Optional.fromNullable(null)和Optional.absent()是等价的。

看一个例子

    @Test
    public void testOption(){
        Optional<Integer> possible=Optional.of(10);
        Optional<Integer> absentOpt=Optional.absent();
        Optional<Integer> NullableOpt=Optional.fromNullable(null);
        Optional<Integer> NoNullableOpt=Optional.fromNullable(10);
        if(possible.isPresent()){//true
            System.out.println("possible isPresent:"+possible.isPresent());
            System.out.println("possible value:"+possible.get());
        }
        if(absentOpt.isPresent()){ //false
            System.out.println("absentOpt isPresent:"+absentOpt.isPresent()); 
        }
        if(NullableOpt.isPresent()){//false
            System.out.println("fromNullableOpt isPresent:"+NullableOpt.isPresent()); 
        }
        if(NoNullableOpt.isPresent()){//true
            System.out.println("NoNullableOpt isPresent:"+NoNullableOpt.isPresent()); 
        }
    }

运行结果

possible isPresent:true
possible value:10
NoNullableOpt isPresent:true

Optional中几个常见的方法

1>. boolean isPresent()：如果Optional包含的T实例不为null，则返回true；若T实例为null，返回false

2>. T get()：返回Optional包含的T实例，该T实例必须不为空；否则，对包含null的Optional实例调用get()会抛出一个IllegalStateException异常

3>. T or(T)：若Optional实例中包含了传入的T的相同实例，返回Optional包含的该T实例，否则返回输入的T实例作为默认值

4>. T orNull()：返回Optional实例中包含的非空T实例，如果Optional中包含的是空值，返回null，逆操作是fromNullable()

5>. Set asSet()：返回一个不可修改的Set，该Set中包含Optional实例中包含的所有非空存在的T实例，且在该Set中，每个T实例都是单态，如果Optional中没有非空存在的T实例，返回的将是一个空的不可修改的Set。

看一个例子：

    @Test
    public void testMethodReturn() {
        Optional<Long> value = method();
        if(value.isPresent()){
            System.out.println("获得返回值: " + value.get());
        }
        else{//如果Optional实例中包含的Long对象实例为null

            System.out.println("获得返回值: " + value.or(-12L));   // -12  
        }

        System.out.println("获得返回值 orNull: " + value.orNull()); // null

        Optional<Long> valueNoNull = methodNoNull();
        if(valueNoNull.isPresent()){
            Set<Long> set=valueNoNull.asSet();
            System.out.println("获得返回值 set 的 size : " + set.size()); // 1   
            System.out.println("获得返回值: " + valueNoNull.get());     //15
            System.out.println("获得返回值：" + valueNoNull.or(100L));
        }
        else{
            System.out.println("获得返回值: " + valueNoNull.or(-12L));    
        }

        System.out.println("获得返回值 orNull: " + valueNoNull.orNull());
    }

    private Optional<Long> method() {
        return Optional.fromNullable(null);
    }
    private Optional<Long> methodNoNull() {
        return Optional.fromNullable(15L);
    }

运行结果：

获得返回值: -12
获得返回值 orNull: null
获得返回值 set 的 size : 1
获得返回值: 15
获得返回值：15
获得返回值 orNull: 15

以上就是Optional的一点介绍，看一个实际例子。

例子要求：计算一组员工的总年龄。

Employee类如下：

    public class Employee {
        private String name;
        private int age;
        public Employee(String name, int age) {
            super();
            this.name = name;
            this.age = age;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }

    }

当我们利用传统的Java实现时，代码如下：

    @Test
    public void test() {
        List<Employee> employees = Lists.newArrayList(new Employee("A",21),
                new Employee("B",22),
                null,
                new Employee("C",23)
                );
        int employeeAgeSum = 0;
        for(Employee e :employees){
            if(e!=null){
                employeeAgeSum+=e.getAge();
            }
        }
        System.out.println("employee age sum:"+employeeAgeSum);

    }

传统的形式来实现时，在获取员工的年龄时首先需要判断是否为null。

而使用Guava库中的Optional实现如下：

    for(Employee e :employees){
            if(e!=null){
                employeeAgeSum+=Optional.fromNullable(e).
                        or(new Employee("default",0)).getAge();
            }
    }

对于返回的null对象则我们可以返回默认值为了0薪资的员工对象，那么我们就不需要做任何null的判断。是不是很棒。

小结

使用Optional除了赋予null语义，增加了可读性，最大的优点在于它是一种傻瓜式的防护。Optional迫使你积极思考引用缺失的情况，因为你必须显式地从Optional获取引用。直接使用null很容易让人忘掉某些情形，尽管FindBugs可以帮助查找null相关的问题，但是我们还是认为它并不能准确地定位问题根源。

如同输入参数，方法的返回值也可能是null。和其他人一样，你绝对很可能会忘记别人写的方法method(a,b)会返回一个null，就好像当你实现method(a,b)时，也很可能忘记输入参数a可以为null。将方法的返回类型指定为Optional，也可以迫使调用者思考返回的引用缺失的情形。

参考资料

1、http://www.cnblogs.com/peida/archive/2013/06/14/Guava_Optional.html

2、http://www.cnblogs.com/whitewolf/p/4231783.html