java8-用Optional取代null

Optional的主要作用：预防 Java 中著名的 NullPointerException 异常

NullPointerException 异常

示例：

public class Person {
    private Car car;
}
public class Car {
    private Insurance insurance;
}
public class Insurance {
    private String name;
}

//会出现
person.getCar().getInsurance().getName();
//采用防御式检查减少NullPointerException
public String getCarInsuranceName(Person person) {
    if (person != null) {
        Car car = person.getCar();
        if (car != null) {
            Insurance insurance = car.getInsurance();
            if (insurance != null) {
                return insurance.getName();
            }
        }
    }
    return "";
}
//减少多次嵌套,但引入过多的退出语句
public String getCarInsuranceName(Person person) {
    if (person == null) {
        return "";
    }
    Car car = person.getCar();
    if (car == null) {
        return "";
    }
    Insurance insurance = car.getInsurance();
    if (insurance == null) {
        return "";
    }
    return insurance.getName();
}

在Java程序开发中使用null会带来理论和实际操作上的种种问题:
它是错误之源。
NullPointerException是目前Java程序开发中最典型的异常。
它会使你的代码膨胀。
它让你的代码充斥着深度嵌套的null检查，代码的可读性糟糕透顶。
它自身是毫无意义的。
null自身没有任何的语义，尤其是，它代表的是在静态类型语言中以一种错误的方式对缺失变量值的建模。
它破坏了Java的哲学。
Java一直试图避免让程序员意识到指针的存在，唯一的例外是：null指针。
它在Java的类型系统上开了个口子。
null并不属于任何类型，这意味着它可以被赋值给任意引用类型的变量。这会导致问题，原因是当这个变量被传递到系统中的另一个部分后，你将无法获知这个null变量最初的赋值到底是什么类型。

解决方法：引入optinal

Groovy语言

Groovy语言通过“安全导航操作符”安全访问可能为null的变量。
def carInsuranceName = person?.car?.insurance?.name

Groovy通过Elvis运算符减少null
//三目运算符“?:”
String displayName = name != null ? name : "Unknown”;
在groovy中
String displayName = name ? name : "Unknown";
String displayName = name ?: "Unknown"

Scala语言

// Option[T] 是一个类型为 T 的可选值的容器： 如果值存在， Option[T] 就是一个 Some[T] ，如果不存在， Option[T] 就是对象 None
val myMap: Map[String, String] = Map("key1" -> "value")
val value1: Option[String] = myMap.get("key1")
val value2: Option[String] = myMap.get("key2")
 
println(value1) // Some("value1")
println(value2) // None

通过value1.getOrElse("默认值")获取具体值

optional基本用法

创建optional对象

1.声明一个空的Optional
Optional<Car> optCar = Optional.empty();
2.依据一个非空值创建Optional
Optional<Car> optCar = Optional.of(car);
3.可接受null的Optional
Optional<Car> optCar = Optional.ofNullable(car);

isPresent ()如果存在返回true，否测返回false。
get()是这些方法中最简单但又最不安全的方法。如果变量存在，它直接返回封装的变量值，否则就抛出一个NoSuchElementException异常。所以，除非你非常确定Optional变量一定包含值，否则使用这个方法是个相当糟糕的主意。此外，这种方式即便相对于嵌套式的null检查，也并未体现出多大的改进。
orElse(Tother)允许你在Optional对象不包含值时提供一个默认值。
orElseGet(Supplier<?extendsT> other)是orElse方法的延迟调用版，Supplier方法只有在Optional对象不含值时才执行调用。如果创建默认值是件耗时费力的工作，你应该考虑采用这种方式（借此提升程序的性能），或者你需要非常确定某个方法仅在Optional为空时才进行调用，也可以考虑该方式（这种情况有严格的限制条件）。
orElseThrow(Supplier<?extendsX> exceptionSupplier)和get方法非常类似，它们遭遇Optional对象为空时都会抛出一个异常，但是使用orElseThrow你可以定制希望抛出的异常类型。
ifPresent(Consumer<?superT>)让你能在变量值存在时执行一个作为参数传入的方法，否则就不进行任何操作。

       //java7
        String name = null;
        if (insurance != null) {
            name = insurance.getName();
        }

        //不建议这样写，跟java7区别不大
        Optional<Insurance> optInsurance = Optional.ofNullable(insurance);
        String name = null;
        if (optInsurance.isPresent()) {
            name = insurance.get().getName();
        }

        //建议用法
        Optional<Insurance> optInsurance = Optional.ofNullable(insurance);
        String name = optInsurance.map(Insurance::getName).orElse("");
        String name = optInsurance.map(Insurance::getName).orElseThrow(()->new RuntimeException("姓名不能为空"));

        //如果不确定空时的操作，直接返回Optional
        Optional<String> name = optInsurance.map(Insurance::getName);

map/flatmap用法

使用Optional重新定义Person/Car/Insurance的数据模型：

public class Person {
    private Optional<Car> car;
    public Optional<Car> getCar() {  return car;  }
}
public class Car {
    private Optional<Insurance> insurance;
    public Optional<Insurance> getInsurance() {  return insurance;  }
}
public class Insurance {
    private String name;
    public String getName() {  return name;  }
}

获取名称

Optional<Insurance> optInsurance = Optional.ofNullable(insurance); 
Optional<String> name = optInsurance.map(Insurance::getName); 

public String getCarInsuranceName(Optional<Person> person) {
    return person.flatMap(Person::getCar)
                 .flatMap(Car::getInsurance)
                 .map(Insurance::getName)
                 .orElse("Unknown");
}

Stream和Optional的map、flatmap对比

Stream和Optional的map对比

Stream和Optional的map对比.png

如上图：

        Optional<Insurance> optInsurance = Optional.ofNullable(insurance);
        Optional<String> name = optInsurance.map(Insurance::getName);

Stream和Optional中的map操作类似，都是取出里面的具体对象进行操作，再通过Stream或Optional包装后输出。

Stream和Optional的flatmap对比

Optional<Person> person= Optional.ofNullable(Person);
person.map(Person::getCar)//得到的是两层的Optional对象

两层的Optional对象.png

person.flatMap(Person::getCar)//一层的Optional对象

一层的Optional对象.png

Stream和Optional中的flatmap操作类似，都是取出里面的具体对象进行操作，操作的结果是Optional对象或Stream对象，
Optional的话直接输出，Stream的话就将多个Stream合并成一个Stream后输出。
简单的说：可以把Optional看成最多包含一个元素的Stream对象

filter方法

filter用于过滤想要的对象

Optional<Insurance> optInsurance = ...; 
optInsurance.filter(insurance ->
                        "CambridgeInsurance".equals(insurance.getName()))  
              .ifPresent(x -> System.out.println("ok"));