java中Optional的使用

2年前 (2022) 程序员胖胖胖虎阿
329 0 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的地方进行报错,而不会在调用方法的时候出现空指针。
java中Optional的使用
需要注意的是:
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);

java中Optional的使用

从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方法。
java中Optional的使用

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());

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);
    }

使用demo:

 person.getCar().ifPresent(System.out::println);

版权声明:程序员胖胖胖虎阿 发表于 2022年11月5日 下午7:40。
转载请注明:java中Optional的使用 | 胖虎的工具箱-编程导航

相关文章

暂无评论

暂无评论...