Optional类方法使用详解

Optional类方法使用详解

1.对象创建

1.empty()

创建空的Optional的对象，不同于new一个对象，该对象不会有空指针异常

<T> Optional<T> empty()

//创建空的Optional的对象，不同于new一个对象，该对象不会有空指针异常
Optional<String> empty = Optional.empty();

2.of()

初始化一个Optional的对象，该方法必须传入非null对象，否则会抛空指针异常

<T> Optional<T> of(T value)

//初始化一个Optional的对象，该方法必须传入非null对象，否则会抛空指针异常
Optional<String> empty1 = Optional.of("1");
Optional<List<String>> empty3 = Optional.of(Arrays.asList("1","2"));

3.ofNullable()

初始化一个Optional的对象，该方法可以存在null，如果为null则创建一个empty()的空Optional对象

<T> Optional<T> ofNullable(T value)

//初始化一个Optional的对象，该方法可以存在null，如果为null则创建一个empty()的空Optional对象
Optional<String> empty2 = Optional.ofNullable(null);

2.取值方法

1.isPresent()

判断Optional对象是否有值，有值为true

boolean isPresent()

Optional<String> empty = Optional.of("1");
//判断Optional对象是否有值，有值为true
boolean present = empty.isPresent(); 

2.isEmpty()

判断是否为空对象 jdk11方法

boolean isEmpty()

Optional<String> empty2 = Optional.ofNullable(null);
//判断是否为空对象 jdk11方法
boolean present1 = empty2.isEmpty();

3.get()

取值，如果是空Optional对象，抛出NoSuchElementException 异常

T get()

Optional<String> empty = Optional.of("1");
//取值，如果是空Optional对象，抛出NoSuchElementException 异常
String str = empty.get();   

4.orElse()

取值，如果是空Optional对象或null，取指定默认值

T orElse(T other)

Optional<String> empty = Optional.empty();
Optional<String> empty1 = Optional.of("1");       
Optional<String> empty2 = Optional.ofNullable(null);
//取值，如果是空Optional对象或null，取指定默认值
String str2 = empty.orElse("2"); //2
String str3 = empty2.orElse("2"); //2
String str4 = empty1.orElse("2"); //1 

5.orElseGet()

取值，如果是空Optional对象或null，取指定默认值，不同于orElse，该方法传入的是Supplier函数

T orElseGet(Supplier<? extends T> other)

Optional<String> empty = Optional.ofNullable(null);
//取值，如果是空Optional对象或null，取指定默认值，不同于orElse，该方法传入的是Supplier函数
String str5 = empty.orElseGet(() -> "11" + "222"); //11222

5.orElseThrow()

取值，如果是空Optional对象或null，抛指定异常

T orElseGet(Supplier<? extends T> other)

Optional<String> empty = Optional.ofNullable(null);
//取值，如果是空Optional对象或null，抛指定异常
empty.orElseThrow(() -> new Exception("aaa"));

3.处理方法

1.ifPresent()

值操作，如果有值，则处理该值，是空Optional对象或null不处理

void ifPresent(Consumer<? super T> consumer)

Optional<String> empty = Optional.ofNullable(null);
//值操作，如果有值，则处理该值，是空Optional对象或null不处理
empty.ifPresent(item -> System.out.println("Optional字符串：" + item));

2.filter()

过滤数据

Optional<T> filter(Predicate<? super T> predicate)

Optional<String> empty = Optional.of("1"); 
//过滤数据
Optional<String> filterOpt = empty.filter(item -> "1".equals(item));
filterOpt.ifPresent(item -> System.out.println("filterOpt字符串：" + item));

3.map()

转换处理

<U> Optional<U> map(Function<? super T, ? extends U> mapper)

Optional<String> empty = Optional.of("1");
//转换处理
Optional<Integer> mapOpt = empty.map(item -> Integer.parseInt(item) + 1);
mapOpt.ifPresent(item -> System.out.println("mapOpt字符串：" + item));

4.flatMap()

转换处理,返回的是Optional对象，类似Stream的map和flatMap关系

<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper)

Optional<List<String>> empty = Optional.of(Arrays.asList("1","2"));
//转换处理,返回的是Optional对象，类似Stream的map和flatMap关系
Optional<String> flatMapOpt = empty.flatMap(item -> item.stream().findFirst());
flatMapOpt.ifPresent(item -> System.out.println("flatMapOpt字符串：" + item));

测试示例

    public static void main(String[] args) throws Exception {
        //创建空的Optional的对象，不同于new一个对象，该对象不会有空指针异常
        Optional<String> empty = Optional.empty();
        //初始化一个Optional的对象，该方法必须传入非null对象，否则会抛空指针异常
        Optional<String> empty1 = Optional.of("1");
        Optional<List<String>> empty3 = Optional.of(Arrays.asList("1","2"));
        //初始化一个Optional的对象，该方法可以存在null，如果为null则创建一个empty()的空Optional对象
        Optional<String> empty2 = Optional.ofNullable(null);
        //判断Optional对象是否有值，有值为true
        boolean present = empty1.isPresent();
        //判断是否为空对象 jdk11方法
        boolean present1 = empty2.isEmpty();
        //取值，如果是空Optional对象，抛出NoSuchElementException 异常
        String str = empty1.get();
        //取值，如果是空Optional对象或null，取指定默认值
        String str2 = empty.orElse("2"); //2
        String str3 = empty2.orElse("2"); //2
        String str4 = empty1.orElse("2"); //1
        //取值，如果是空Optional对象或null，取指定默认值，不同于orElse，该方法传入的是Supplier函数
        String str5 = empty2.orElseGet(() -> "11" + "222"); //11222
        //取值，如果是空Optional对象或null，抛指定异常
        empty2.orElseThrow(() -> new Exception("aaa"));
        //值操作，如果有值，则处理该值，是空Optional对象或null不处理
        empty2.ifPresent(item -> System.out.println("Optional字符串：" + item));
        //过滤数据
        Optional<String> filterOpt = empty1.filter(item -> "1".equals(item));
        filterOpt.ifPresent(item -> System.out.println("filterOpt字符串：" + item));
        //转换处理
        Optional<Integer> mapOpt = empty1.map(item -> Integer.parseInt(item) + 1);
        mapOpt.ifPresent(item -> System.out.println("mapOpt字符串：" + item));
        //转换处理,返回的是Optional对象，类似Stream的map和flatMap关系
        Optional<String> flatMapOpt = empty3.flatMap(item -> item.stream().findFirst());
        flatMapOpt.ifPresent(item -> System.out.println("flatMapOpt字符串：" + item));
    }