Java利用Optional解决空指针异常

当我们在编写Java代码时，常常会遇到空指针异常（NullPointerException）的情况，这会给我们的程序带来很大的不稳定性和安全性问题。而Java 8中新增的Optional类可以有效地解决这一问题。本文将详细讲解如何利用Optional解决空指针异常。

Optional的介绍

Optional类是Java 8中新增的一个类，可以用来解决空指针异常的问题。它是一个包装类，可以将任何类型的对象包装成一个Optional对象，从而避免因对象为空而产生空指针异常。

Optional类的本质是一个容器，它可能包含一个非空的值，也可能是空的。当Optional对象的值为空时，调用其方法不会出现空指针异常，而是会返回一个空的Optional对象。

Optional类的使用需要引入java.util包。

Optional的基本用法

Optional类有以下几个常用的方法：

• Optional.of(T value): 创建一个非空的Optional对象。
• Optional.ofNullable(T value): 创建一个允许为空的Optional对象。如果值为null，则返回一个空的Optional对象。
• Optional.empty(): 创建一个空的Optional对象。
• T get(): 如果Optional对象的值不为空，则返回该值，否则抛出NoSuchElementException异常。
• boolean isPresent(): 如果Optional对象的值不为空，则返回true，否则返回false。
• void ifPresent(Consumer<? super T> consumer): 如果Optional对象的值不为空，则执行该Consumer对象，否则不执行。
• T orElse(T other): 如果Optional对象的值不为空，则返回该值，否则返回other参数指定的值。
• T orElseGet(Supplier<? extends T> other): 如果Optional对象的值不为空，则返回该值，否则返回由Supplier对象生成的值。
• Optional<T> filter(Predicate<? super T> predicate): 如果Optional对象的值不为空且满足predicate指定的条件，则返回该Optional对象，否则返回一个空的Optional对象。
• <U> Optional<U> map(Function<? super T, ? extends U> mapper): 如果Optional对象的值不为空，则执行mapper指定的函数，并返回一个包含该函数返回值的Optional对象，否则返回一个空的Optional对象。
• <U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper): 如果Optional对象的值不为空，则执行mapper指定的函数，并返回该函数返回的Optional对象，否则返回一个空的Optional对象。

使用Optional解决空指针异常

下面我们将结合两个实例进行讲解，如何使用Optional类来避免空指针异常。

示例1：避免空指针异常

public class Person {
    private String name;
    private Integer age;

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

public class Demo {
    public static void main(String[] args) {
        Person person = null;
        String name = person.getName(); // 抛出空指针异常
    }
}

上述示例中，我们未对person变量进行初始化，直接调用其方法getNmae()会出现空指针异常。这时我们可以使用Optional来避免空指针异常。

public class Demo {
    public static void main(String[] args) {
        Person person = null;
        Optional<Person> optionalPerson = Optional.ofNullable(person);
        String name = optionalPerson.map(Person::getName).orElse("unknown");
        System.out.println(name); // 输出unknown
    }
}

在上述示例中，我们使用Optional.ofNullable()方法将person对象转化为Optional对象，然后使用map()方法将Optional对象中包含的Person对象转化为其name属性值，最后使用orElse()方法设置一个默认值unknown，以避免空指针异常。

示例2：链式调用方法，避免多重空指针校验

public class Car {
    private String brand;
    private String color;

    public Car(String brand, String color) {
        this.brand = brand;
        this.color = color;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

public class Person {
    private String name;
    private Car car;

    public Person(String name, Car car) {
        this.name = name;
        this.car = car;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Car getCar() {
        return car;
    }

    public void setCar(Car car) {
        this.car = car;
    }
}

public class Demo {
    public static void main(String[] args) {
        Person person = new Person("Jack", null);
        String carBrand = Optional.ofNullable(person)
                .flatMap(p -> Optional.ofNullable(p.getCar()))
                .flatMap(c -> Optional.ofNullable(c.getBrand()))
                .orElse("unknown");
        System.out.println(carBrand); // 输出unknown
    }
}

上述示例中，我们使用了链式调用，避免了多重空指针校验的问题。在第一个flatMap中，我们使用Optional.ofNullable()方法将person对象转化为Optional对象；在第二个flatMap中，我们使用Optional.ofNullable()方法将car对象转化为Optional对象；在第三个flatMap中，我们使用Optional.ofNullable()方法将car对象的brand属性值转化为Optional对象。如果以上任何一步出现null值，则会自动返回一个空的Optional对象，并终止链式调用。

通过上述两个实例，我们简单介绍了Optional类的基本用法，并讲解了如何利用Optional解决空指针异常。在编写代码时，我们应当尽可能地避免出现空指针异常，从而提高程序的稳定性和安全性。