Optional

Optional类是Java8为了解决null值判断问题，使用Optional类可以避免显式的null值判断（null的防御性检查），避免null导致的NPE（NullPointerException）。

对比

    public static void main(String[] args) {
        TestDemo testDemo = new TestDemo();
        getCount(testDemo);
    }

    private static void getCount(TestDemo testDemo) {
        //if判断：判断好多层
        int count1 = 1;
        if(testDemo != null){
            if(testDemo.getCount() != null){
                count1 = testDemo.getCount();
            }
        }
        System.out.println(count1);

        //三目运算符：嵌套层数深，可读性不好
        int count2 = testDemo != null ? (testDemo.getCount() != null ? testDemo.getCount() : 1) : 1;
        System.out.println(count2);

        //Java8-Optional：优雅，可读性较好
        int count3 = Optional.ofNullable(testDemo).map(TestDemo::getCount).orElse(1);
        System.out.println(count3);
    }

    private static class TestDemo {

        private Integer count;

        public Integer getCount() {
            return count;
        }

        public void setCount(Integer count) {
            this.count = count;
        }
    }

源码

of

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


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


 public static <T> T requireNonNull(T obj) {
        if (obj == null)
            throw new NullPointerException();
        return obj;
    }

可以看到，传入的值为null时，会手动抛出空指针异常；

ofNullable

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

 public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }

// EMPTY常量是由Optional的无参构造函数创建的对象
private static final Optional<?> EMPTY = new Optional<>();

//EMPTY常量是由Optional的无参构造函数创建的对象；无参构造函数的代码
private Optional() {
        this.value = null;
    }

可以看到，无参构造函数创建了一个value为null的对象；所以，ofNullable 方法创建对象时，允许传入的值为空；为空时创建一个value=null的对象；