关于Java8引入Optional类的使用

1、Optional类的作用

• 解决空指针异常，通过一些方法来检查空值防止代码污染
• 引入函数式接口方便空值情况或非空情况进行下一步业务处理
• 可以接收泛型，包括空值

2、创建Optional类的方法

1. Optional.empty()   创建一个空的optional实列
2. Optional.of(T t)   创建一个optional实列，t必须非空
3. Optional.ofNullable(T t)   创建一个optional实列，t可以为空

    public static void main(String[] args) {

        //创建一个空的Optional实列
        Optional<Object> empty = Optional.empty();

        //创建一个Optional实列,t必须非空
        SJYEntity demo = new SJYEntity();
        Optional<SJYEntity> optional = Optional.of(demo);

        //创建一个Optional实列,t可以为空，也可以不为空
        SJYEntity demo1 = null;
        Optional<SJYEntity> optional1 = Optional.ofNullable(demo1);

    }

3、Optional类的方法

    1：判断Optional容器中是否包含对象（4种方法）

//判断对象是否为空，如果为空返回true,否则返回false    
public boolean isEmpty() {
        return value == null;
    }
//判断对象是否存在，如果存在返回true，否则返回false
    public boolean isPresent() {
        return value != null;
    }
//判断对象是否存在，如果存在执行函数式接口，否则不执行，不能返回值，如果需要返回需要定义额外的变量来进行控制
   public void ifPresent(Consumer<? super T> action) {
        if (value != null) {
            action.accept(value);
        }
    }
//java9新引进的方法，判断对象是否存在，如果存在执行函数式接口，否则执行另外的逻辑
    public void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction) {
        if (value != null) {
            action.accept(value);
        } else {
            emptyAction.run();
        }
    }
//示列
Optional<String> optionalValue = Optional.of("Hello, World!");

// Case 1: Optional 包含值
optionalValue.ifPresentOrElse(
    value -> System.out.println("Value is present: " + value),
    () -> System.out.println("Value is not present")
);

2：获取容器中的对象

//获取对象，如果为空抛异常
    public T get() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }



//如果有值则将其返回，否则返回传入的值
    public T orElse(T other) {
        return value != null ? value : other;
    }
//如果有值则将其返回，否则返回由Supplier接口实现提供的对象
    public T orElseGet(Supplier<? extends T> supplier) {
        return value != null ? value : supplier.get();
    }
///如果有值则将其返回，否则抛异常
    public T orElseThrow() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }


//orElse和orElseGet一般在Optional时的收尾工作，orElse在任何情况都会执行，则可能产生空指针异常问题
//而orElseGet只有条件为空的时候才会执行
//使用Supplier能够做到懒计算，即使用orElseGet时。它的好处是，只有在需要的时候才会计算结果。
//示列
    public static void main(String[] args) {

        List<Integer> list =  new ArrayList<Integer>();
        list.add(1);
        Optional<List<Integer>> optional = Optional.of(list);
        optional.filter(a->a.get(0)==1).stream().findFirst().orElse(get("a"));
        optional.filter(a->a.get(0)==1).stream().findFirst().orElseGet(()->get("b"));
        optional.filter(a->a.get(0)==2).stream().findFirst().orElse(get("a"));
        optional.filter(a->a.get(0)==2).stream().findFirst().orElseGet(()->get("b"));
    }

    public static List get(String args) {
        System.out.println(args+"执行");
        return null;
    }

//打印
a执行
a执行
b执行

Process finished with exit code 0

3：过滤

//如果值存在，并且这个值匹配给定的 predicate，返回一个Optional用以描述这个值，否则返回一个空的Optional。
    public Optional<T> filter(Predicate<? super T> predicate) {
        Objects.requireNonNull(predicate);
        if (!isPresent()) {
            return this;
        } else {
            return predicate.test(value) ? this : empty();
        }
    }

4：映射

//如果有值，则对其执行调用映射函数得到返回值。如果返回值不为 null，则创建包含映射返回值的Optional作为map方法返回值，否则返回空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));
        }
    }




//flatMap和map差不多，只是最后返回的是Optional对象

    public <U> Optional<U> flatMap(Function<? super T, ? extends Optional<? extends U>> mapper) {
        Objects.requireNonNull(mapper);
        if (!isPresent()) {
            return empty();
        } else {
            @SuppressWarnings("unchecked")
            Optional<U> r = (Optional<U>) mapper.apply(value);
            return Objects.requireNonNull(r);
        }
    }


//示例
public static String getChampionName(Competition comp) throws IllegalArgumentException {
    if (comp != null) {
        CompResult result = comp.getResult();
        if (result != null) {
            User champion = result.getChampion();
            if (champion != null) {
                return champion.getName();
            }
        }
    }
    throw new IllegalArgumentException("The value of param comp isn't available.");
}
//用map进行改写,最后返回的是User::getName

 public static String getChampionName(Competition comp) throws IllegalArgumentException {
    return Optional.ofNullable(comp)
            .map(Competition::getResult)  // 相当于c -> c.getResult()，下同
            .map(CompResult::getChampion)
            .map(User::getName)
            .orElseThrow(()->new IllegalArgumentException("The value of param comp isn't available."));
}