Optional学习笔记_隋小白

此为学习笔记,若有侵权请联系我,谢谢!!!
jdk1.8新特性 Optional
Optional 类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。
Optional 是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。
Optional 类的引入很好的解决空指针异常。

一、简介
Optional 是一个对象容器，具有以下两个特点：
提示用户要注意该对象有可能为null
简化if else代码
二、使用介绍

1. 创建：
   Optional.empty()： 创建一个空的 Optional 实例
   Optional.of(T t)：创建一个 Optional 实例，当 t为null时抛出异常
   Optional.ofNullable(T t)：创建一个 Optional 实例，但当 t为null时不会抛出异常，而是返回一个空的实例

2. 获取：
   get()：获取optional实例中的对象，当optional 容器为空时报错

3. 判断：
   isPresent()：判断optional是否为空，如果空则返回false，否则返回true
   ifPresent(Consumer c)：如果optional不为空，则将optional中的对象传给Comsumer函数
   orElse(T other)：如果optional不为空，则返回optional中的对象；如果为null，则返回 other 这个默认值
   orElseGet(Supplier other)：如果optional不为空，则返回optional中的对象；如果为null，则使用Supplier函数生成默认值other
   orElseThrow(Supplier exception)：如果optional不为空，则返回optional中的对象；如果为null，则抛出Supplier函数生成的异常

4. 过滤：
   filter(Predicate p)：如果optional不为空，则执行断言函数p，如果p的结果为true，则返回原本的optional，否则返回空的optional

5. 映射：
   map(Function<T, U> mapper)：如果optional不为空，则将optional中的对象 t 映射成另外一个对象 u，并将 u 存放到一个新的optional容器中。
   flatMap(Function< T,Optional< U >mapper)：跟上面一样，在optional不为空的情况下，将对象t映射成另外一个optional
   区别：map会自动将u放到optional中，而flatMap则需要手动给u创建一个optional

创建

    @Test
    public void chuangjian(){
        //1 创建一个包装对象的值为空的Optional对象
        Optional<String> empty = Optional.empty();
        System.out.println(empty);
        //2创建一个Optional实例 当为空的时候抛出空指针异常
        Optional<String> test = Optional.of("test");
        System.out.println(test);
//        Optional<Object> nu = Optional.of(null);
//        System.out.println(nu);
        //3创建一个Option实例 当t为null不会抛出一个异常 而是返回一个空的实例
        Optional<Object> nu1 = Optional.ofNullable(null);
        System.out.println(nu1);
        Optional<String> test1 = Optional.ofNullable("test1");
        System.out.println(test1);
    }

获取

@Test
    public void huoqu(){
        //获取包装对象
        OptionalEntity optionalEntity = new OptionalEntity("123","11");
        // 后set会把原来替换掉
        optionalEntity.setName("name");
        OptionalEntity optionalEntitytest = Optional.ofNullable(optionalEntity).get();
        System.out.println(optionalEntitytest);
    }

判断

    @Test
    public void panduan() throws NotFoundException {
        OptionalEntity optionalEntity = new OptionalEntity("123","11");
        //isPresent();  返回值是boolean
//        boolean present = Optional.of(null).isPresent(); //of 为空会报错
        boolean present = Optional.ofNullable(null).isPresent();
        System.out.println("isPresent"+present);

        boolean present1 = Optional.of(optionalEntity).isPresent();
        System.out.println("isPresent"+present1);


        //isPresent
        Optional.of(optionalEntity).ifPresent(optionalEntity1 -> System.out.println(optionalEntity1.getName()));
        /**
         * 区别
         * optional为空时
         * orElse 会执行，返回orElse中的结果
         * orElseGet 会执行，返回orElseGet中的结果
         * optional有值时
         * orElse 会执行，返回optional的结果
         * orElseGet 不会执行，返回optional的结果
         * orElse(T other) 不论容器是否为空,只要调用该方法, 则对象other一定存在
         * orElseGet(Supplier<? extends T> supplier) 只有当容器为空时,才调用supplier.get()方法产生对象
         */
        //orElse
        int value = OptionalInt.of(452146).orElse(123);
        System.out.println("value: " + value);
        Object jg = Optional.ofNullable(null).orElse("结果");
        System.out.println(jg);

        //orElseGet
        int valueget = OptionalInt.of(452146).orElseGet(()->getIntValue());
        System.out.println("value: " + valueget);
        Object jgget = Optional.ofNullable(null).orElseGet(()->getStringValue());
        System.out.println("value: "+jgget);


        //orElseThrow
        //如果ofNullable()不等于null，则返回值本身；
        //如果为null, 则发生指定的异常。(可以使用 :: 形式，这个冒号后面是自定义异常，还可以使用 Lambda 表达式直接引用Java类定义的异常。)
        Optional.ofNullable(null).orElseThrow(() -> new NotFoundException("为空"));
        Optional.ofNullable("123").orElseThrow(() -> new NotFoundException("不为空"));


    }
    public String getStringValue(){  //远程方法调用
        return "默认值";
    }
    public Integer getIntValue(){  //远程方法调用
        return 1;
    }

过滤

@Test
    public void guolv(){
        OptionalEntity optionalEntity1 = new OptionalEntity("name1","66666");
        OptionalEntity optionalEntity2 = new OptionalEntity("name2","33333");
        //不输出
        Optional.ofNullable(optionalEntity1).filter(c -> c.getName().equals("name1")).ifPresent(c -> System.out.println(c+"名字"+"name1") );
        //输出
        Optional.ofNullable(optionalEntity2).filter(c -> c.getName().equals("name1")).ifPresent(c -> System.out.println(c+"名字"+"name1") );
    }

映射

/**
     * 映射
     * map和flatMap都接收一个mapping function参数。
     * map和flatMap返回的都是Optional类型的数据。
     * 即map 返回值 -->  Optional<返回值>
     *   flatMap  Optional<返回值> --> Optional<返回值>
     * 当mapping function返回的是Optional类型的数据时，可以直接使用flatMap，flatMap直接返回该Optional。
     * 当mapping function返回的不是Optional类型的数据时，使用map，因为map会进行一次Optional的包装。
     */
    @Test
    public void yingshe(){
        OptionalEntity optionalEntity = new OptionalEntity();

        //map
//        Optional.ofNullable(optionalEntity)
//                .map(c->optionalEntity.getName())
//                .orElseThrow(() -> new RuntimeException("出错啦"));

        Optional.ofNullable(optionalEntity)
                .map(OptionalEntity::getName)
                .orElseThrow(() -> new RuntimeException("出错啦"));
        //flatMap
        All all = new All();
        Optional.ofNullable(all)
                .flatMap(All::getOneTestOptional)
                .flatMap(OneTest::getTwoTestOptional)
                .map(TwoTest::getName)
                .orElseThrow(()-> new RuntimeException("粗错了"));

    }

所需的实体类

@Data
@AllArgsConstructor
@NoArgsConstructor
public class OptionalEntity {
    /**
     * 姓名
     */
    private String name;
    /**
     * 年龄
     */
    private String age;
}

@Data
@AllArgsConstructor
@NoArgsConstructor
public class All {
    private String name;
    private Optional<OneTest> oneTestOptional;
}

@Data
@AllArgsConstructor
@NoArgsConstructor
public class OneTest {
    private String name;
    private Optional<TwoTest> twoTestOptional;
    private TwoTest twoTest;
}

@Data
@AllArgsConstructor
@NoArgsConstructor
public class TwoTest {
    private String name;
}