java基础：Optional学习整理

Optional相等于一个容器类，类中封装了一个对象，即为属性 value，value可能是null也可能有值。主要用来解决NullPointerException问题；

1，构造

构造函数都是私有方法，有两个一个有参一个无参数；

//无参构造器
private Optional() {
        this.value = null;
    }
//有参构造器，参数如果为null会抛出NullPointerException异常
private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }

2，创建对象

类在加载的时候默认创建一个空对象EMPTY,是一个静态对象

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

创建含有值的对象

创建value不为null的对象：of(T value)

创建一个可能为null的对象：ofNullable(T 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);
    }

//使用
 EmailBean email=new EmailBean();
        email.setTitle("optional");
        email.setContent("测试内容");
        email.setTypeId(5);

Optional optional1= Optional.of(email);
Optional optional= Optional.ofNullable(email);

3，取值

get()，如果value为null，会抛出异常

// 如果value为null，会抛出异常 
public T get() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }

//使用
optional.get()

4，判断是否有值

isPresent()，判断value是否为null 不为null返回true

ifPresent(Consumer<? super T> consumer)，判断是否有值，有值的话执行传递的语句

optional.ifPresent(u->u.setId(5));

5，返回默认值

orElse(T other); //如果有值则返回，如果没有值则返回other  可用于返回默认值

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

Optional.ofNullable(dto).orElse(new  Dto());//如果value为null，返回传递过来的对象

orElseGet(Supplier<? extends T> other)  也可用于返回默认值

 //如果value为null，则返回函数接口的对象
public T orElseGet(Supplier<? extends T> other) {
        return value != null ? value : other.get();
    }

 Optional.ofNullable(email).orElseGet(()->new  EmailBean());

6，值为null时，抛出指定异常

optional.orElseThrow(); 当有值时，返回value；当没有值时，抛出函数接口提供的异常对象；

可用于当没有取到某个对象时，抛出指定类型的异常；spring jpa中的getOne()方法，返回的就是optional对象，当从数据库中无法查找指定对象时便可抛出指定的异常。

//当没有值时，抛出回函数接口提供的异常对象 
 public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
        if (value != null) {
            return value;
        } else {
            throw exceptionSupplier.get();
        }
    }


 EmailBean email=optional.orElseThrow( () -> new BeanException("该内容不存在"));

7，设置值或者与value对象的相关操作

map() 传递函数，并将value作为函数的参数执行函数，然后将返回的值包装在 Optional 中。

flatMap()也是传递函数，并将value作为函数的参数执行函数，直接返回执行的结果，这个结果必须是一个Optional对象。

//mapper返回一个U类的对象或子对象   
 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));//function运算的结果转为一个Optional
        }
    }

//mapper函数参数中的U，是一个optional对象，即mapper函数返回一个optional对象；执行这个方法之后直接返回函数结果，结果不能为null
 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));
        }
    }

 String title= Optional.ofNullable(email).map(d->d.getTitle()).orElse("默认名称");
 String title1=Optional.ofNullable(email).flatMap(d-> Optional.ofNullable(d.getTitle())).orElse("默认名称");

8，过滤

  //接受一个函数接口，用来判断是否满足指定条件，满足的返回当前对象，不满足返回空对象
 public Optional<T> filter(Predicate<? super T> predicate) {
        Objects.requireNonNull(predicate);
        if (!isPresent())
            return this;
        else
            return predicate.test(value) ? this : empty();
    }


//返回的是Optional对象本身
  boolean is=Optional.ofNullable(email).filter(d->d.getTypeId()==3).isPresent();

public final class Optional<T>

是一个不可变的类，没有父类；不是 Serializable，所以最好不要用在类的成员变量中。

Optional 主要用来返回对象。在获取到这个类型的实例后，如果它有值，可以取到所需实例，否则可以进行一些替代行为如设置默认值或是抛出异常。