java中Optional的使用

桃扇骨 2023-09-26 22:00 103阅读 0赞

文章目录  
Optional的概念  
Optional的由来  
Optional的使用  
Optional入门教程  
创建Optional对象  
从Optional对象中提取和转换值  
使用map从Optional对象中提取和转换值  
使用flatMap链接Optional对象  
Optional默认行为  
get（）  
orElse（）  
orElseGet（）  
orElseThrow（）  
ifPresent（）  
Optional的概念  
java.util.Optional 是java8中引进的一个新的类，它可以对可能缺失的值进行建模，而不是直接将null赋值给变量。  
它是用来规范我们开发的API，使其语义更加的明确，使用Optional修饰的对象，表示该对象可能为null。在一定程度上避免了空指针的问题。

Optional的由来  
身为java程序员，空指针是最常见的问题了，它是在1965年被一位英国的计算机科学家 Tony Hoare开放的，他设计的初衷是因为采用null的这种引用方式，实现起来非常的容易。但是后来让众多开发人员痛苦不已，这也让他十分的后悔，自称为“价值百万的重大失误”。  
每当我们对对象的格式进行检查，判断它的值是否是期望的格式时，却发现我们看到的并不是一个对象，而是一个空指针（java中没有指针，其实就是引用），这时就会抛出NullPointerExceptione的异常。  
下面举个列子来验证该问题。

public class Person \{  
private Car car;  
  
public Car getCar()\{  
return car;  
\}

\}  
class Car\{

private Insurance insurance;

public Insurance getInsurance() \{  
return insurance;  
\}  
\}

class Insurance\{

private String name;  
  
public String getName() \{  
return name;  
\}  
\}

以上是要测试的三个类，现在要写一个方法，通过人员来获取保险

public String getCarInsuranceName(Person person)\{  
return person.getCar().getInsurance().getName();  
\}  
  
上面的代码就会造成空指针的问题，因为有的人没有车，并且有的车没有保险。为了解决空指针的问题，我们常用的方法是防御式编程，可以进行如下的操作：

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 "Unknown";  
\}  
  
以上方法每次引用一个变量都会做一次null的检查，这样看似可以避免了空指针，却十分的冗余，因为当不确定一个变量是否为null时，都需要进行if的检查，这不仅增加了代码的可读性，还容易漏掉，并且维护起来也比较困难。  
java引入空指针的危害：  
1、它是很多问题的错误之源，它是目前开发中最典型的异常。  
2、它会使代码膨胀，它会使我们的代码充满了深度嵌套的null检查，代码的可读性下降。  
3、它自身是毫无意义的，null自身没有任何的语义，它表示以一种错误的方式对缺失变量的值建模。  
4、它破坏了java的哲学，java一直避免引入指针的存在，而唯一的例外就是null指针。  
5、它破坏了java的类型，null不属于任何类型，这也意味着它可以被赋值给任意引用类型的变量，我们将无法获取这个null值最初的类型是什么。  
而Optional的出现可以让我们最大程度上规避上述问题。

Optional的使用  
Optional入门教程  
拿最上面的例子来讲，如果我们知道有的人没有车，那就不应该在Personal类内部声明Car的变量，因为Car类型存在，就说明一定会有Car类型的变量，而事实上并不是这样，所以使用Car类型不是一个明智的选择。我们可以使用Optional类对其进行包裹，当存在Car类型变量的时候就返回，当不存在的时候就返回一个空的Optional对象，它就像一个盒子，修饰的对象被放了进去。  
除此之外，最重要的是，这就变的非常的明确，用Optional修饰，说明这里是允许变量缺失的。

public class Person \{  
//有的人有车，也可能没有车，所以这里用Optional来修饰  
private Optional<Car> car;  
public Optional<Car> getCar()\{  
return car;  
\}

public void setCar(Optional<Car> car) \{  
this.car = car;  
\}  
\}  
class Car\{

//有的车上了保险，也有可能没有上，所以这里使用Optional修饰  
private Optional<Insurance> insurance;

public Optional<Insurance> getInsurance() \{  
return insurance;  
\}

public void setInsurance(Optional<Insurance> insurance) \{  
this.insurance = insurance;  
\}  
\}

class Insurance\{

private String name;

public String getName() \{  
return name;  
\}

public void setName(String name) \{  
this.name = name;  
\}  
\}  
  
当我们再次声明方法的时候，可以按如下方式操作：

public class OptionalTest \{

public static void main(String\[\] args) \{  
Person person = new Person();  
Car car = new Car();  
Insurance insurance = new Insurance();  
  
//Optional.of()表示对象不能为null  
insurance.setName("insurance");  
car.setInsurance(Optional.of(insurance));  
person.setCar(Optional.of(car));

String carInsuranceName = getCarInsuranceName(person);  
\}

public static String getCarInsuranceName(Person person) \{  
//可以通过get方法从Optional中取出值  
return person.getCar().get().getInsurance().get().getName();  
\}

\}  
  
这样我们就不需要进行null的判断、检查，因为发生异常的时候，会直接在赋值为null的地方进行报错，而不会在调用方法的时候出现空指针。

需要注意的是:  
Optional只是消除了进行null检查的逻辑，并快速定位问题，而不是消除每一个null的引用，相反，它的目标是帮助我们设置更优秀的API，让开发人员看到签名就知道这个变量的含义。  
看到这里，有的同学觉得Optional只是形式上声明吗？不能规避空指针吗？答案是可以的，

创建Optional对象  
创建Optional的方式有多种  
1、声明一个空的Optional

//使用Optional.empty()方法创建一个空的Car类型的Optional对象。  
Optional<Car> optionalCar = Optional.empty();  
  
2、创建一个非空值的Optional，如果car为null的话，直接抛出空指针异常（参考上面的图片）。

Car car = new Car();  
Optional<Car> car1 = Optional.of(car);  
  
3、创建一个可以为null的Optional，该方法支持car为null，但是会在用到car的地方抛出异常，但不是空指针异常。

Car car = new Car();  
Optional<Car> car2 = Optional.ofNullable(car);  
  
从Optional对象中提取和转换值  
虽然我们可以通过get方法从Optional中取出值，但是get方法在遭遇到空的Optional对象时仍然会抛出空指针异常，并没有解决我们的问题。所以我们需要按照约定的方式来使用它。

使用map从Optional对象中提取和转换值  
就像stream流一样，这里也是可以通过通过map的方式从Optional中取出元素，map方法返回的也是一个Optional类型的对象，里面的值如果为null的话，可以使用orElse方法赋上自定义的值。

Insurance insurance = new Insurance();  
insurance.setName("insurance");  
Optional<Insurance> optionalInsurance = Optional.ofNullable(insurance);  
String name = optionalInsurance.map(Insurance::getName).orElse("unKnown");  
  
使用flatMap链接Optional对象  
如果想要获取下面最终的值，我们通过map方法来尝试一下

public String getCarInsuranceName(Person person)\{  
return person.getCar().getInsurance().getName();  
\}  
  
当使用map的时候，代码如下：

public static String getCarInsuranceName(Person person) \{  
Optional<Person> optionalPerson = Optional.of(person);  
return optionalPerson.map(Person::getCar)  
.map(Car::getInsurance)  
.map(Insurance::getName)  
.orElse("unKnown");  
\}  
  
如上代码是编译不通过的，这里将person进行了Optional来修饰，才可以使用map方法，然后Person里面的Car对象也是用Optional来修饰的，所以使用map方法取出来的是一个用Optional<Optional< Car>>类型的对象,然后再对其使用map方法是行不通的，这里需要使用flatMap方法，就和之前的stream流一样，“将所有内容都放在最外面的容器里”。

public static String getCarInsuranceName(Person person) \{  
Optional<Person> optionalPerson = Optional.of(person);  
return optionalPerson.flatMap(Person::getCar)  
.flatMap(Car::getInsurance)  
.map(Insurance::getName)  
.orElse("unKnown");  
\}  
  
为了更清晰的展示map和flatMap的区别，大家可通过下面的demo来理解

Person person = new Person();  
Optional<Person> optionalPerson = Optional.of(person);  
//map方法  
Optional<Optional<Car>> car1 = optionalPerson.map(Person::getCar);  
//flatMap方法  
Optional<Car> optionalCar1 = optionalPerson.flatMap(Person::getCar);  
  
这里还需要注意的是：  
如果对象没有使用Optional来修饰，直接使用get方法就可以拿到对象里面的Optional的值  
如果对象使用Opional来修饰的话，就需要使用map方法。

Optional默认行为  
get（）  
get（）方法是最简单也是最不安全的方法，如果变量存在就返回，不存在的话则会抛出NoSuchElementException的异常。所以，get（）的使用场景一定是十分确定Optional修饰的值一定是有内容的，否则不建议使用。使用的demo：

Car car = new Car();  
Insurance insurance = new Insurance();  
car.setInsurance(Optional.of(insurance));  
//使用get来从Optional中取值。  
Insurance insurance1 = car.getInsurance().get();  
  
orElse（）  
该方法相对于get（）的好处在于当Optional对象中不存在则可以返回一个默认的值，使用的demo：

Car car = new Car();  
Insurance insurance = new Insurance();  
car.setInsurance(Optional.of(insurance));  
//使用orElse来赋予默认的值  
Insurance insurance1 = car.getInsurance().orElse(new Insurance());  
1  
2  
3  
4  
5  
orElseGet（）  
该方法是orElse（）方法的延迟调用版，当对象为空的时候才会产生默认值，它的性能相对于orElse（）来说更好一些，建议使用该方法，下面是orElseGet（）和orElse（）的源码对比：

package java.util;  
public final class Optional<T> \{  
...  
public T orElse(T other) \{  
return this.value != null ? this.value : other;  
\}  
public T orElseGet(Supplier<? extends T> supplier) \{  
return this.value != null ? this.value : supplier.get();  
\}  
\}  
  
orElseThrow（）  
该方法和get方法很类似，当Optional修饰的对象为空的时候来抛出一个自己指定的异常类型。

ifPresent（）  
该方法对Optional修饰的对象进行判断，如果存在对象，则在进行某些操作，该方法里面放的是一个Consumer函数式接口，入参为T，void的类型的方法。

public void ifPresent(Consumer<? super T> consumer) \{  
if (value != null)  
consumer.accept(value);  
\}  
1  
2  
3  
4  
使用demo：

person.getCar().ifPresent(System.out::println);  
————————————————  
版权声明：本文为CSDN博主「玉带林中挂」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。  
原文链接：https://blog.csdn.net/aaaPostcard/article/details/123596787