Optional工具类

概述

Optional工具类是Java8的其中一种新特性，或者可以理解为是Java给我们提供的用于处理空指针的工具类。

先举个例子

//创建一个User类
public class User {
    private String name;
    private Integer age;
    private List colorList;

    public User() {
    }

    public User(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 List getColorList() {
        return colorList;
    }

    public void setColorList(List colorList) {
        this.colorList = colorList;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", colorList=" + colorList +
                '}';
    }
}

//测试类
public class OptionalTest {
    public static void main(String[] args) {
        User user1 = new User("星辰",19);
        User user2 = null;
        
        Optional<User> optUser  = Optional.ofNullable(user1);
        Optional<User> optUser1  = Optional.ofNullable(user2);

        //测试 orElse 当对象为空时使用指定的对象
        //分析：这里传入的optUser1中的User对象为null，所以会使用user1的getAge()方法
        System.out.println(optUser1.orElse(user1).getAge());

        //测试 orElseThrow  当对象为null时抛出指定异常 入参为Supplier
        //分析：这里optUser1中的User对象为null,所以会抛出自定义指定的IllegalArgumentException异常
        System.out.println(optUser1.orElseThrow(()->new IllegalArgumentException("返回自定义指定异常")));

        //测试 orElseGet 当对象为null时创建指定对象使用 入参为Supplier
        //分析：和orElse差不多，区别在于它的入参是Supplier函数，可以自定义一个对象
        System.out.println(optUser1.orElseGet(()->new User("大海",134)).getAge());

        //测试 isPresent和get
        //分析：类似于iterator中的hasNext和next方法，一般不会直接这么使用，这里仅做演示
        if(optUser1.isPresent()){
            System.out.println(optUser1.get().getAge());
        }

        //测试 filter 筛选条件进行过滤，当条件不满足时，返回空的Optional 入参为Predicate  功能：过滤
        //分析：fiter的入参是一个Predicate条件函数，如果某个条件不符合，会返回一个空的Optional
        System.out.println(optUser.filter((t)->{
            return t.getAge()>18 && t.getName().contains("星");
        }).toString());

        System.out.println("=="+optUser.filter((t)->t.getColorList()!=null && t.getAge()>0));

        //测试 map 入参为Function 将T类型转为R类型 功能：加工
        //分析：map方法可以看成是一个加工方法，它的入参是Function转换型函数，将R类型转为T类型，这里是将User类型转为了Integer类型返回
        System.out.println(optUser.map(((t)->new Integer(1))).get());

        //测试 flatMap  返回Optional包装类 功能：和map方法类似，也是加工，但是加工必须返回Optional
        //分析：和map方法差不多，区别在于这个方法在加工返回时必须是Optional类型，也就是说要手动返回Optional，map方法是自动返回Optional
        optUser.flatMap((t)->Optional.of(new String("hello.world")));
        optUser.flatMap((t)->{
            Integer age = t.getAge();
            return Optional.ofNullable(new Integer(age));
        });
    }
}

进一步了解

我们来看一下Optional类中比较重要的方法

//构造函数，注意，是私有的，我们不能直接调用
private Optional() {
        this.value = null;
    }
//带参构造函数，也是私有的
private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }
//这个静态方法可以创建一个Optional方法，但是传入的value值不能为空，否则会抛出空指针异常
public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }

//和of方法对应，但是这个方法允许传入的value值为null
public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }

//获取Optional容器中的值，如果没值，则抛出空指针异常
public T get() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }    

//判断容器中是否有值
public boolean isPresent() {
        return value != null;
    }

//Optional的过滤方法
public Optional<T> filter(Predicate<? super T> predicate) {
        Objects.requireNonNull(predicate);
        if (!isPresent())
            return this;
        else
            return predicate.test(value) ? this : empty();
    }

//Optional中的加工方法，有点偏向于类型转换
public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
        Objects.requireNonNull(mapper);
        if (!isPresent())
            return empty();
        else {
            return Optional.ofNullable(mapper.apply(value));
        }
    }
    
//和map方法类似，但是这个方法中的Function返回值必须是Optional类型的
public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {
        Objects.requireNonNull(mapper);
        if (!isPresent())
            return empty();
        else {
            return Objects.requireNonNull(mapper.apply(value));
        }
    }

//类似于get方法，但是这个方法在容器中没值时会返回自定义的值，类似于map中的getOrDefault方法
public T orElse(T other) {
        return value != null ? value : other;
    }
    
//类似于orElse方法，但是这个方法是需要自己创建一个对象
public T orElseGet(Supplier<? extends T> other) {
        return value != null ? value : other.get();
    }
    
//当对象为null时，可以抛出自定义指定的异常和信息
public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
        if (value != null) {
            return value;
        } else {
            throw exceptionSupplier.get();
        }
    }

总结

1、创建Optional实例只能使用 of()或ofNullable() 方法，这两个方法的区别在于ofNullable()方法允许参数为null

2、isPresent() 方法和 get() 方法通常是一起使用，但是实际一般不使用。

3、filter() 方法可以用来过滤数据，Predicate条件函数；

4、map()方法可以用来操作、处理数据，结合Function函数，Function函数的作用是将T类型转为R类型，所以，使用map方法处理数据也更加靠近类型的转换逻辑。
flatMap()方法和map方法类似，区别在于它的Function函数出参是Optional类型，而map的Function函数出参是任意参数。

5、在编码时最好加上Optional的泛型，以防后续编码类型转换有误