Optional类（JDK8）

最新推荐文章于 2023-05-29 14:37:25 发布
最新推荐文章于 2023-05-29 14:37:25 发布
阅读量348 收藏
点赞数
分类专栏： JAVA 文章标签： java
原文链接：https://www.cnblogs.com/zhangboyu/p/7580262.html
版权

java8引入新类Optional类主要解决的问题是臭名昭著的空指针异常（NullPointerException）

本质上，这是一个包含有可选值的包装类，这意味着 Optional 类既可以含有对象也可以为空。

Optional 是 Java 实现函数式编程的强劲一步，并且帮助在范式中实现。但是 Optional 的意义显然不止于此    

主要方法介绍：

构造方法：

private Optional();//返回一个含null的Optional实例
private Optional(T value);//返回一个非null的Optional实例，如果传入null,抛出空指针异常

普通方法 ：

1. 静态方法 empyt()，返回一个空的Optional实例。

public static<T> Optional<T> empty();

2. 静态方法 of(T value)，返回具有 Optional的当前非空值的Optional。如果value是null就抛出空指针异常

public static <T> Optional<T> of(T value);

3. 静态方法 ofNullable(T value)，返回一个指定值的Optional实例，如果参数为null，则返回一个空的 Optional实例

public static <T> Optional<T> ofNullable(T value);

4. get()，如果 Optional中存在值，则返回值，否则抛出 NoSuchElementException 

public T get();

5. isPresent()，如果存在值，则返回 true ，否则为 false 

public boolean isPresent();

6. ifPresent(Consumer<? super T> consumer)，如果存在值，则使用该值调用指定的消费者，否则不执行任何操作

public void ifPresent(Consumer<? super T> consumer){
    if (value != null)
            consumer.accept(value);
}
//eg:
opt.ifPresent( u -> assertEquals(user.getEmail(), u.getEmail()));
//这个例子中，只有 user 用户不为 null 的时候才会执行断言。

7. orElse(T other)，返回值如果存在，否则返回 other(默认值）

public T orElse(T other);

8. orElseGet(Supplier<? extends T> other)，返回值（如果存在），否则调用 other并返回该调用的结果。

public T orElseGet(Supplier<? extends T> other){
    return value != null ? value : other.get();
}

9. orElseThrow(Supplier<? extends X> exceptionSupplier);返回包含的值（如果存在），否则抛出由提供的供应商创建的异常。 

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

10. map(Function<? super T, ? extends U> mapper);//如果存在值，则应用提供的映射函数，如果结果不为空，则返回一个Optional结果的Optional 。 否则返回一个空的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));
        }
    }

11. filter(Predicate<? super T> 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();
    }

12. flatMap(Function<? super T, Optional<U>> mapper);//如果一个值存在，应用提供的Optional映射函数给它，返回该结果，否则返回一个空的Optional 。 这种方法类似于map(Function) ，但是提供的映射器是一个结果已经是Optional映射器，如果被调用， flatMap不会用额外的Optional 。

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 class OptionalTest {
    public static void main(String[] args) {
        //private static final Optional<?> EMPTY = new Optional<>();
        //private final T value;
        //private Optional() { this.value = null;}
        //private Optional(T value) { this.value = Objects.requireNonNull(value);}

        //1.public static<T> Optional<T> empty() 生成一个value为null的Optional
        /*public static<T> Optional<T> empty() {
            Optional<T> t = (Optional<T>) EMPTY;
            return t;
        }*/
        Optional<String> empty = Optional.empty();

        //2.public static <T > Optional < T > of(T value) 生成一个指定value的Optional
        /*public static <T > Optional < T > of(T value) {
            return new Optional<>(value);
        }*/
        Optional<String> optional = Optional.of("optional");

        //3.public static <T> Optional<T> ofNullable(T value) 根据参数判断生成value是不是null的Oprional
        /* public static <T> Optional<T> ofNullable(T value) {
            return value == null ? empty() : of(value);
         }*/
        Optional<String> optional1 = Optional.ofNullable("张三");

        //4.public T get()//获取value值，如果是null抛出异常
        /* public T get() {
            if (value == null) {
                throw new NoSuchElementException("No value present");
            }
            return value;
         }*/
        //String s = empty.get();
        String s1 = optional.get();

        //5.isPresent() 判断value是不是为null
        /*public boolean isPresent() {
            return value != null;
        }*/
        boolean present = empty.isPresent();
        boolean present1 = optional.isPresent();

        //6.ifPresent(Consumer<? super T> consumer) 如果value不为null执行lambda
        /*public void ifPresent(Consumer<? super T> consumer) {
            if (value != null)
                consumer.accept(value);
        }*/
        Optional<String> opt = Optional.of("123456");
        opt.ifPresent(name -> System.out.println(name.length()));

        //7.filter(Predicate<? super T> 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();
        }*/
        Integer year = 2016;
        Optional<Integer> yearOptional = Optional.of(year);
        boolean is2016 = yearOptional.filter(y -> y == 2016).isPresent();
        System.out.println(is2016);
        boolean is2017 = yearOptional.filter(y -> y == 2017).isPresent();
        System.out.println(is2017);

        //8.map(Function<? super T, ? extends U> mapper) 将一个值转换成另一个值，下面的例子是返回字符串的长度，没有则返回默认值0
        /*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));
            }
        }*/
        String name = "james";
        Optional<String> nameOptional = Optional.of(name);
        int len = nameOptional.map(String::length).orElse(0);

        //9.public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper)将一个值转换成另一个值，如果为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 name2 = "bob";
        Optional<String> name21 = Optional.of(name2);
        name21.flatMap((n) -> null);

        //10.public T orElse(T other) 如果optional不为null就返回value, 否则返回other
        /*public T orElse(T other) {
            return value != null ? value : other;
        }*/
        Person person2 = new Person();
        person2.setName("Tom");
        person2.setAge(18);
        Optional<Person> userOptional = Optional.ofNullable(person2);
        Person person3 = userOptional.orElse(new Person() {{
            setAge(17);
            setName("Jack");
        }});

        //11.public T orElseGet(Supplier<? extends T> other) 如果vaue不为null返回value,否则返回Supplier get()
        /*public T orElseGet(Supplier<? extends T> other) {
            return value != null ? value : other.get();
        }*/
        Person person4 = new Person();
        person4.setName("jack");
        Optional<Object> empty1 = Optional.empty();
        String name3 = String.valueOf(empty1.orElseGet(person4::getName));

        //12.orElseThrow 返回Optional包裹的值，如果值为null，则抛出异常
        /*public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
            if (value != null) {
                return value;
            } else {
                throw exceptionSupplier.get();
            }
        }*/
        Optional<String> str = Optional.empty();
        try {
            str.orElseThrow(Exception::new);
        } catch (Exception e) {
            e.printStackTrace();
        }

        //连环null检查
        method1();
    }

    public static String method1() {
        Person person = new Person("Tom");
        Optional<Person> person2 = Optional.ofNullable(person);
        person2.map(p -> p.getName()).map(p -> p.toLowerCase()).orElse(null);

        if (person != null) {
            String name4 = person.getName();
            if (name4 != null) {
                return name4.toLowerCase();
            } else {
                return null;
            }
        } else {
            return null;
        }
    }
}

转载:https://www.cnblogs.com/zhangboyu/p/7580262.html

不做挖坑人
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JDK8 Optional容器类的常用方法总结
wangyybx的博客
01-22 2583
最近有时间，特将JDK8中新增的Optional的常用方法结合自己的使用和理解，总结一下！ Optional 可以看做一个容器：它可以保存各种类型的值，或者仅仅保存null，即Optional 类是一个可以为null的容器对象。Optional的优点是提供很多有用的方法，这样我们就不用显式进行空值检测而实现避免NullPointerException的情况。Optional 的常用方法查看相关源码...
mac os jdk8
09-23
Optional 类 − Optional 类已经成为 Java 8 类库的一部分，用来解决空指针异常。 Nashorn, JavaScript 引擎 − Java 8提供了一个新的Nashorn javascript引擎，它允许我们在JVM上运行特定的javascript应用。
JDK8新特性之Optional类
千里之行，始于足下
04-06 333
Optional 是 JDK8 新增加的一个工具类，位于 java.util 包下。 Optional 类的引入很好的解决空指针异常（微笑）。
jdk8新特性-Optional
xiao_yu_gan的博客
07-07 2170
jdk8-Optional使用
JDK8之Optional类
FurtherSkyQ的博客
05-15 359
Optional。
JDK8特性：Optional类的用法
Newbie的专栏
03-11 356
JDK8中新增的Optional工具类使用说明
JDK1.8 Optional 笔记.pdf
09-19
JDK1.8 Optional用法案例详细解读
JDK8+Java+常用版本
10-26
jdk8虽然出现很久了，但是可能我们还是有很多人并不太熟悉，本文主要就是介绍说明一些jdk8相关的内容。 主要会讲解： lambda表达式 方法引用 默认方法 Stream 用Optional取代null 新的日志和时间 ...
JDK8新特性
07-13
扩展方法、Lambda 表达式、内置的四大核心的函数式接口、方法引用与构造器引用、Stream API、Optional类..
jdk8-112安装包.rar
05-24
Optional 类 − Optional 类已经成为 Java 8 类库的一部分，用来解决空指针异常。 Nashorn, JavaScript 引擎 − Java 8提供了一个新的Nashorn javascript引擎，它允许我们在JVM上运行特定的javascript应用。
Java8实战学习笔记（五）——高效 Java 8 编程（二）
xinyu112的博客
06-26 423
一、用Optional取代null二、用Optional取代null
JDK8新特性-Optional类
学习使我快乐
06-25 177
JDK8新特性-Optional类 说明 Java 8 Optional 类 :Optional 类的引入很好的解决空指针异常。 本文主要从Optional类的methods进行学习和分析。 构造或者创建 API 说明 举例 Optional(T value) 私有构造 empty() 返回一个空的EMPTY对象 of(T value) 通过此方法构造一个Optional对象，传递Value是空时会报空指针异常；非空则不报； ofNullable(T value) ub
Optional类详解及使用方法示例
Ascend1977的博客
05-29 4275
Optional类是java8中引入的一个非常有用的类，它可以用来解决空指针异常带来的不便。这个类可以将对象包装为一个Optional对象，如果该对象为空，则可以使用一些默认值或者执行一些默认操作。Optional 是 Java 实现函数式编程的强劲一步，并且帮助在范式中实现。Java8的Optional类提供了丰富的 API 方法，这里按照其功能分类介绍。
Java8 Optional 使用方法详解
RichardGeek的博客
08-10 1167
Java 8 Optional 类的使用
Java8_Optional类
Y_Y526的博客
01-22 502
1.Optional作用 Optional类JDK8开始引入的，为的是能够更加优雅地处理NullPointerException，优雅地判空和处理空值。Optional对象是一种包装器对象，包装了类型T的对象或者是没有包装任何对象。若是包装了类型T的对象可以认为值是存在的。Optional类以更安全的方式代替了类型T的引用，这种引用要么就是引用某个对象，要么为null。 2.Optional的创建 使用 Optional.of 、Optional.ofNullable 或 Optional.empty O
JDK8：使用Optional进行变量判空、集合遍历
YHJ
06-12 9401
NPE(Null Pointer Exception)一直是我们最头疼的问题，也是最容易忽视的地方。NPE常是导致Java应用程序失败的最常见的原因。在日常研发工作中，经常会处理各种变量、集合，但在使用的过程中，往往要进行空判断，不然会出现NPE。 JDK8新特性之Optional介绍 Optional类实际上是个容器：它可以保存类型T的值，或者仅仅保存null。Optional 类的引入很好的解决空指针异常。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。尽量避免在程序中直接调用O
【Java 8】优雅的解决空指针NullPointerException —— Optional API的详解与使用示例
vilavin的博客
10-10 751
文章目录一、Java 8 为什么引入Optional类？二、什么是Optional类？三、如何创建Optional对象四、如何从Optional对象中提取和转换值？1. map方法2. flatMap方法五、如何获取Optional对象和设置默认值？1. get()2. orElse(T other)3. orElseGet(Supplier<? extends T> other)4. orElseThrow(Supplier<? extends X> exceptionSuppli
JDK8新特性(四)：Optional 类的使用
扛麻袋的少年的博客
01-12 6014
Optional类的使用 JDK8以前，编写代码，通常会出现 NullPointerException (空指针异常)，通常情况下我们都是通过 if ... else... 来对对象进行为空判断，然后再进行逻辑处理，代码写起来也比较冗余。 JDK8新增了Optional类，使用该类可以避免我们对空指针的检查，使代码看起来比较优雅。 1.Optional类介绍 ...
JDK8新特性之Optional类,5分钟包你完全学会
m0_74340515的博客
11-13 452
在编写代码的时候为了防止空指针异常，往往需要各种非空的判段,而过多的判段会导致代码臃肿不堪。为了解决这一问题JDK8引入了Optional类，对于程序员，养成使用Optional类习惯，可以写出更为优雅的代码。Optional类就好像是一个包装类，我们可以把具体的数据封装到Optional对象内部。3，map和flatMap都是对操作的数据进行转换，得到的数据依然时OPtional类包装好的，保证了使用的安全。4，filter 对数据进行过滤如果都不符合判段的条件返回一个无数据的Optional对象。
jdk8新特性optional
最新发布
08-27
JDK 8引入了一个重要的新特性，即Optional类。Optional类是一个容器对象，它可能包含null值，也可能包含非null值。使用Optional类可以避免空指针异常的发生，并提供了一种更优雅的方式来处理可能为空的值。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值