Java中Optional的一些用法总结(结合源码分析)

结合Optional源码对使用方法做一些总结

1. of方法，创建一个Optional对象，传入value可为null

    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }

2. empty方法，创建一个空的Optional对象

	private static final Optional<?> EMPTY = new Optional<>();

    public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }

3. ofNullable方法，传入对象为空则创建一个空的Optional对象，负责调用of方法创建对象

    public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }

4. isPresent方法，判断传入是否为空，返回布尔值；

    public boolean isPresent() {
        return value != null;
    }

5. ifPresent方法，传入不为空的话，进行消费；(常用)

    public void ifPresent(Consumer<? super T> consumer) {
        if (value != null)
            consumer.accept(value);
    }

	//举例
	List<Students> list = null;
    Optional.ofNullable(list).ifPresent(i -> {
        i.forEach(o -> log.info(o.getAge().toString()));
    });
    //传入list可以为null，可以size为0，不会执行而已，不过对于forEach方法，传入不能为null，可以size为0

	@Test
    public void test3() {
        Student student = null;
		Optional.ofNullable(student).ifPresent(i -> System.out.println(i.getName()));
    }
    //不会报错

6. get方法，返回传入的value对象，value对象不能为空，否则会抛异常

    public T get() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }

7. map方法，传入不能为空，进行对象转换，对返回的结果做了封装

    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));
        }
    }
    
	//举例
	Students students = new Students(5);
    Integer age = Optional.ofNullable(students).map(Students::getAge).get();
	//输出age为5

	@Test
    public void test3() {
        Student student = new Student();
        student.setName("aa");
        student.setAddress(new Address());
        Optional.ofNullable(student)
                .map(Student::getAddress)
                .map(Address::getAddress)
                .orElseThrow(() -> new RuntimeException("is null"));
    }

@Data
class Student {
    private String name;
    private Address address;
}
@Data
class Address {
    private Student address;
}

8. flatMap方法，如果传入的是Optional类型，就不能用map，需要用flatMap

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

9. filter方法，传入不能为空，Optional对象为空直接返回对象，进行对象过滤，成功则返回，失败返回空的Optional对象；(个人理解这个其实用的比较少，集合的话直接用集合类Stream流过滤就好了)

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

10. orElse方法，如果Optional对象不为null，则返回这个对象，负责返回other对象

    public T orElse(T other) {
        return value != null ? value : other;
    }

	//举例
	Students students = new Students(5);
    Students students1 = new Students(55);
	Students students2 = Optional.ofNullable(students).filter(o -> o.getAge() > 10).orElse(students1);
	//输出返回students1(age=55)

	//特别的为null的情况
    Students students = null;
    Integer age = Optional.ofNullable(students).map(Students::getAge).orElse(33);
    //输出返回age=33

11. orElseGet方法，如果Optional对象不为null，则返回这个对象，负责返回一个Suppler接口提供的other对象

    public T orElseGet(Supplier<? extends T> other) {
        return value != null ? value : other.get();
    }

    @Test
    public void test3() {
        Student student = new Student();
        student.setName("aa");
        student.setAddress(new Address());
        Student student2 = Optional.ofNullable(student)
                .filter(i -> Objects.equals("aaa", i.getName()))
                .orElseGet(() -> {
                    Student student1 = new Student();
                    student1.setName("aaa");
                    return student1;
                });
        System.out.println(student2);
    }

12. orElseThrow方法，如果Optional对象不为空则返回value，否则抛出指定异常

    public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
        if (value != null) {
            return value;
        } else {
            throw exceptionSupplier.get();
        }
    }

	//举例，可作为常用的判断是否为null的写法
    Students students = null;
    Optional.ofNullable(students).orElseThrow(() -> new RuntimeException("参数为空"));
    Integer age = Optional.ofNullable(students).map(Students::getAge).orElseThrow(() -> new RuntimeException("参数为空"));

    //输出 java.lang.RuntimeException: 参数为空