jdk8中Optional类的用法

optional

从字面意思理解它的意思是可选择的。optional是JDK8中出现的，对于判断null有非常好的用法，它是一个容器类，代表一个值是存在还是不存在，之前我们用null来表示一个值是否存在，现在我们可以用它来更清楚的表示。
我们首先看下它有哪些常用的方法。

public final class Optional<T> {

    public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }
    private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }
    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }
    public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }
    public T get() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }
    public boolean isPresent() {
        return value != null;
    }
    public void ifPresent(Consumer<? super T> consumer) {
        if (value != null)
            consumer.accept(value);
    }
    public Optional<T> filter(Predicate<? super T> predicate) {
        Objects.requireNonNull(predicate);
        if (!isPresent())
            return this;
        else
            return predicate.test(value) ? this : empty();
    }
    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));
        }
    }


    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));
        }
    }
    public T orElse(T other) {
        return value != null ? value : other;
    }


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

这是它的方法，我们讲几个比较常用的

 public static void main(String[] args) {
        //既然它是一个容器，那么我们首先创建这样一个对象

        /**Optional.of()：用来创建一个Optional的对象实例
         * Optional.get()可以去获取这样的一个对象
         * Optional.empty ：创建一个空的optional对象
         *  Optional.ofNullable(T t):主要用来判断对象是否为null 如果是null的话则创建空实例，否则返回该值
         *  get()获取值
         *  isPresent();判断是否有值存在
         *  orElse(T other):主要用于接收值的时候，如果不存在我们可以赋给一个默认值；
         *  orElseGet(Supplier<? extends T> other) 如果对象有值，则返回该值，否则就获取一个值，注意这个Supperlier是一个供给型接口
         */

        //Optional.of()：用来创建一个Optional的对象实例
        Optional<Person> optional=Optional.of(new Person());
        //使用Optional.get()可以去获取这样的一个对象
        optional.get();
        System.out.println("我是optional对象实例"+optional.get());
        // Optional.empty ：创建一个空的optional对象
        Optional<Person> optional2=Optional.empty();
        System.out.println("我是一个空optional实例"+optional2);
        //Optional.ofNullable(T t):主要用来判断对象是否为null 如果是null的话则创建空实例，否则返回该值
        //
        Optional<Person> optional3=  Optional.ofNullable(new Person());
        System.out.println("我不为null"+"+++++++++++++"+optional3);
        Optional<Person> optional4=  Optional.ofNullable(null);
        System.out.println("我为null所以创建一个空实例"+"+++++++++++++"+optional4);
        //所以我们再判断的时候可以用Optional.empty和去比较从而判断我们要校验的值是否为null
        System.out.println(Optional.empty().equals(optional4));
         //通过get()方法我们可以去获取这个值
        System.out.println(optional.get());
        //用isPresent()方法判断值是否存在
        System.out.println(optional3.isPresent());
        System.out.println(optional4.isPresent());
        //orElse(T other)判断值是否存在如果存在则取出，否则赋予一个默认值
        Optional<Person> optional5=Optional.of(new Person("张三",23,25));

        Person person=optional5.orElse(new Person("李四",25,28));

        Person person2=optional4.orElse(new Person("李四",25,28));
        //因为optional5有值，所以打印的是原值
        System.out.println(person+"我是原始值"+"我的名字为"+person.getName());
        //因为optional4没有值，所以打印的是我创建的新值
        System.out.println(person2+"我是新创建的默认值"+"我的名字为"+person2.getName());

        Person person3= optional5.orElseGet(()->new Person("王五",28,185));
        Person person4= optional4.orElseGet(()->new Person("王五",28,185));
        //因为optional5有值，所以打印的是原值
        System.out.println(person3.getName());
        //因为optional4没有值，所以打印的是我创建的新值
        System.out.println(person4.getName());
    }

打印结果

我是optional对象实例yipeng.shen.TestService.lambda.Person@2fc14f68
我是一个空optional实例Optional.empty
我不为null+++++++++++++Optional[yipeng.shen.TestService.lambda.Person@19dfb72a]
我为null所以创建一个空实例+++++++++++++Optional.empty
true
yipeng.shen.TestService.lambda.Person@2fc14f68
true
false
yipeng.shen.TestService.lambda.Person@17c68925我是原始值我的名字为张三
yipeng.shen.TestService.lambda.Person@7e0ea639我是新创建的默认值我的名字为李四
张三
王五