Optional 进阶使用

最新推荐文章于 2023-04-25 16:01:33 发布
最新推荐文章于 2023-04-25 16:01:33 发布
阅读量568 收藏
点赞数
文章标签： java
原文链接：https://www.jianshu.com/p/c169ddd34903
版权

Optional 中的方法:

  1. Optional.empty()
  2. Optional of(obj)
  3. Optional ofNullable(obj)
  4. public T get()
  5. public boolean isPresent()
  6. public T orElse(T other)
  7. public T orElseGet(Superlier<? extends T> other)
  8. public void ifPresent(Consumer<? super T> consumer)
  9. public <U> Optional<U> map(Function<? super T, ? extends U> mapper)
  10. public Optional<T> filter(Predicate<? super T>) predicate
  11. public <U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper）
  12. public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws x

注意：每一个被调用的方法都只对他前面的结果负责

（1）Optional.empty()

三种构造方式之一：

重新new一个Optional()，并返回

源码：

    public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }

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

（2）Optional.of(obj)

三种构造方式之一：

将数据 转换成 Optional类型（获取具有指定类型的指定值的Optional类的实例）
要求传入参数非空，否则会报NullPointerException
可通过 .get()方法 获取原值

源码：

    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }

应用场景：

  1. 非常明确 将要传给 Optional.of(obj) 的 obj 参数不可能为 null 时
    比如obj是一个刚new出来的对象，或者是一个非null常量。
     
  2. 想为 obj 断言非 null 时
    比如 想要 obj 一旦为 null 就立即报告 NullPointerException 异常， 而不是隐藏

（3）Optional.ofNullable(obj)

三种构造方式之一：

功能与Optional.of()相同，底层也应用了Optional.of()方法。
但是对 null 类型进行了判断，如果为null，则方法内部会 通过 Optional.empty()方法重新 new 一个新的空的 Optional进行返回

源码：

    public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }

（4）get()

获取调用对象原有值

调用对象为空，则直接返回报错 NoSuchElementException() 信息为 No value present

源码：

    public T get() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }

注意：

没有 isPresent() 作铺垫的 get() 调用在 IntelliJ IDEA 中会收到告警

Reports calls to java.util.Optional.get() without first checking with a isPresent() call if a value is available. If the Optional does not contain a value, get() will throw an exception.

调用 Optional.get() 前不事先用 isPresent() 检查值是否可用. 假如 Optional 不包含一个值, get() 将会抛出一个异常

（5）isPresent()

判断当前对象是否存在，返回 boolean 值

本质上 isPresent() 与 obj != null 无任何分别

源码：

    public boolean isPresent() {
        return value != null;
    }

应用：

假定已有一个实例 Optional<User> user

boolean flag = user.isPresent();

（6）orElse()

存在即返回, 不存在则提供默认值

调用对象非空，则返回该对象

调用对象为空，则返回指定值

源码：

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

应用：

import org.junit.Test;

import java.util.Optional;


public class OptionalAdvanced {

    public final String nullStr = null;
    public final LocalBean localBean = null;


    @Test
    public void testOrElse() {

        // 可以 替换 nullStr.isPresent() ? nullStr : "user orElse() print content";
        String ofNullableStr = Optional.ofNullable(nullStr).orElse("user orElse() print content");
        System.out.println(ofNullableStr);

        // 可以替换 localBean.isPresent() ? localBean.get() : new LocalBean();
        LocalBean localBean = Optional.ofNullable(this.localBean).orElse(new LocalBean());
        System.out.println(localBean);
    }
}

（7）orElseGet()

存在即返回，不存在则由函数来产生

源码：

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

应用：

import org.junit.Test;

import java.util.Optional;


public class OptionalAdvanced {

    @Test
    public void testOrElseGet() {
        LocalBean backBean = Optional.ofNullable(this.localBean).orElseGet(() -> this.giveBean());
        System.out.println(backBean);
    }

    public LocalBean giveBean() {
        return new LocalBean();
    }
}

（8）ifPresent(Consumer<? super T> consumer)

存在才对它做点什么

源码：

    public void ifPresent(Consumer<? super T> consumer) {
        if (value != null)
            consumer.accept(value);
    }

应用：

import org.junit.Test;

import java.sql.SQLOutput;
import java.util.Optional;


public class OptionalAdvanced {

    public final LocalBean localBean = null;


    @Test
    public void testIfPresent() {
        // 可替换此类型的判断代码
        //if (user.isPresent())
        //    System.out.println(user.get());

        Optional<LocalBean> fullBean = Optional.ofNullable(new LocalBean());
        fullBean.ifPresent(System.out::println);

        Optional<LocalBean> nullBean = Optional.ofNullable(this.localBean);
        nullBean.ifPresent(System.out::println);
    }
}

（9）map() 函数

获取对象中的某个字段的值

源码：

    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));
        }
    }

应用：

import org.junit.Test;

import java.sql.SQLOutput;
import java.util.Locale;
import java.util.Optional;


public class OptionalAdvanced {

    public final String nullStr = null;
    public final LocalBean nullBean = null;


    @Test
    public void testMap() {
        // 对象为空
        LocalBean nullBean = null;
        String there_is_no_name = Optional.ofNullable(nullBean).map(bean -> bean.getName()).orElse("there is no name");
        System.out.println(there_is_no_name);   // there is no name

        // 属性为空
        LocalBean emptyBean = new LocalBean();
        String this_is_empty_bean = Optional.ofNullable(emptyBean).map(bean -> bean.getName()).orElse("there is no name");
        System.out.println(this_is_empty_bean); // there is no name

        // 对象、属性 均非空
        LocalBean fullBean = new LocalBean();
        fullBean.setName("kobe");
        Optional<LocalBean> fullBeanOptional = Optional.ofNullable(fullBean);

        String here_has_name = fullBeanOptional.map(bean -> bean.getName()).orElse("there is no name");
        System.out.println(here_has_name);      // kobe

        // 调用其他函数
        fullBeanOptional.map(bean -> bean.getName()).ifPresent(System.out::println);   // kobe

        // map 可能无限级联的, 比如再深一层, 获得用户名的大写形式
        String upperCase = fullBeanOptional.map(bean -> bean.getName()).map(name -> name.toUpperCase(Locale.ROOT)).orElse("there is no name");
        System.out.println(upperCase);      // KOBE
    }
}

Groovy 提供了一种安全的属性/方法访问操作符

 ?.

应用：

user?.getUsername()?.toUpperCase();

Swift 也有类似的语法, 只作用在  Optional 的类型上.

（10）filter()

把不符合条件的值变为 empty()

源码：

    public Optional<T> filter(Predicate<? super T> predicate) {
        Objects.requireNonNull(predicate);
        if (!isPresent())
            return this;
        else
            return predicate.test(value) ? this : empty();
    }

应用：

    @Test
    public void testFlatMap() {

        // 对象、属性 均非空
        LocalBean fullBean = new LocalBean();
        fullBean.setAge(22);
        Optional<LocalBean> fullBeanOptional = Optional.ofNullable(fullBean);

        LocalBean fullBack = fullBeanOptional.filter(bean -> bean.getAge() == 22).orElse(new LocalBean());
        System.out.println(fullBack);      // LocalBean(age=22, name=null, address=null)

        LocalBean emptyBack = fullBeanOptional.filter(bean -> bean.getAge() > 22).orElse(new LocalBean());
        System.out.println(emptyBack);      // LocalBean(age=null, name=null, address=null)
    }

（11）flatMap()

总是与 map() 方法成对的，

map中获取的返回值自动被Optional包装,即  返回值 ----> Optional<返回值>

flatMap中返回值保持不变,但必须是Optional类型,即Optional<返回值> -> Optional<返回值>

参考：https://www.cnblogs.com/lijingran/p/8727149.html

源码：

    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));
        }
    }

应用：

    @Test
    public void testFlatMap() {
        // 对象、属性 均非空
        LocalBean fullBean = new LocalBean();
        fullBean.setAge(22);
        Optional<LocalBean> fullBeanOptional = Optional.ofNullable(fullBean);
        Optional<Integer> integer = fullBeanOptional.flatMap(OptionalAdvanced::getOrderNumber);
        System.out.println(integer);
    }
    private static Optional<Integer> getOrderNumber(LocalBean fullBean) {
        return Optional.ofNullable(fullBean).map(bean -> bean.getAge());
    }

（12）orElseThrow()

有值时直接返回, 无值时抛出想要的异常

源码：

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

应用：

    @Test
    public void testOrElseThrow() {
        // 对象、属性 均非空
        LocalBean nullBean = null;
        Optional<LocalBean> nullBeanOptional = Optional.ofNullable(nullBean);
        LocalBean xinxicuowu = nullBeanOptional.orElseThrow(() -> new RuntimeException("xinxicuowu"));
        System.out.println(xinxicuowu);
    }

总结：

使用 Optional 时尽量不直接调用 Optional.get() 方法, Optional.isPresent() 更应该被视为一个私有方法, 应依赖于其他像 Optional.orElse(), Optional.orElseGet(), Optional.map() 等这样的方法.

Optional 的方法中基本都是内部调用  isPresent() 判断, 真时处理值, 假时什么也不做.

声明：

转自：Java8 Optional 的正确使用方式 - 简书

其他大神更细致的讲解：https://www.cnblogs.com/lijingran/p/8727149.html
 

蒂法洛克
关注
Java8新特性之Optional类进阶知识
jui121314的博客
09-13 8347
目录 ●再说Optional类 ●实战演练代码重构 ●小结 ●再说Optional类 上一篇文章概述性地介绍了一下Optional类，可能许多读者还是无法很好的掌握。笔者一开始接触这个类的时候也没有发现其有什么特别的好处，特别是对于“可以有效地避免空指针异常”这个特点理解得不够深刻，为什么这么说呢？结合一段代码，说说笔者当初的疑惑，以及是如何一步一步解决这个疑惑的： //原始业务代码...
Swift 进阶
09-29
学习如何使用可选链（optional chaining）和强制解包（forced unwrapping）来安全地访问可能为nil的值是非常重要的。此外，了解Optional绑定（if let, guard let）的使用，可以让你的代码更加健壮和易于阅读。 ...
详细介绍JDK8中Optional对象的高级用法
最新发布
sbcsdn111的博客
04-25 1085
Optional 是 Java 8 引进的一个新特性，我们通常认为 Optional 是用于缓解 Java 臭名昭著的空指针异常问题。Optional 是个容器：它可以保存类型 T 的值，或者仅仅保存 null。如果值存在则 isPresent() 方法会返回 true，调用 get() 方法会返回该对象。Optional 提供很多有用的方法，这样我们就不用显式进行空值检测。
Optional类 [MySQL][数据库]
m0_57001006的博客
03-26 420
Optional类 Optional类提出的背景: 到目前为止,臭名昭著的空指针异常是导致java应用程序执行失败的最常见原因.以前为了解决空指针异常,Google(谷歌)公司著名的Guava项目引入了Optional类,Guava项目中通过使用检查空值的方式来防止代码污染,它鼓励程序员写出更加干净的代码 – 受到Google Guava的启发,Optional在jdk8.0的时候正式的加入了java的核心类库中 Optional类的使用 Optional< T >类(java.util.Opt
Java 8 开始新增的 Optional 类 - 创建 Optional 对象
HONEY MOOSE
05-17 805
创建一个 Optional 对象 有下面的一些方法可以被用来创建Optional对象。 empty 静态方法 如果你想创建一个空的 Optional 的对象，我们简单的使用 Optional 类提供的empty()静态方法： @Test public void whenCreatesEmptyOptional_thenCorrect() { Optional<String> empty = Optional.empty(); ...
Optional判空使用说明书
一个搬砖工人
03-05 1421
我们程序员做了大量的 null 值检查。尽管有时候这种检查完全没有必要，但我们已经习惯了例行公事。终于，Java 8 看不下去了，就引入了 Optional，以便我们编写的代码不再那么刻薄呆板。 从数据库中根据会员 ID 拉取一个会员的姓名，然后将姓名打印到控制台： @SpringBootTest public class SpringbootTest { @Test void contextLoads() { Member mem = getMemberByIdFromDB
swift4.0进阶
11-22
可选值部分讨论了Swift中的一个核心概念：可选值（Optional）。在Swift中，变量总是有一个值，如果你不提供一个值，它会有一个默认值。可选值允许变量不持有值，这对于处理可能不存在的数据非常有用。在可选值的章节...
Swift进阶.epub
05-02
深入理解可选链（optional chaining）和强制解包（forced unwrapping）能帮助避免运行时错误。 3. **泛型**：泛型允许编写可重用的代码，这些代码可以操作多种数据类型。通过泛型，开发者可以在不牺牲类型安全性的...
swift4.x进阶书籍
09-30
进阶内容可能包括深入理解可选链（Optional Chaining）、强制解包（Forced Unwrapping）以及可选安全的最佳实践。 4. **错误处理**：Swift 提供了一种基于异常的错误处理机制。书里可能会详细讨论 do-catch 语句、...
【Java】Optional、OptionalDouble、OptionalInt、OptionalLong
付费专栏已不再维护，请勿购买
11-23 2101
本文分享Java8推出的Optional容器体系，包括java.util.Optional、java.util.OptionalDouble、java.util.OptionalInt、java.util.OptionalLong
JDK8：使用Optional进行变量判空、集合遍历
YHJ
06-12 9573
NPE(Null Pointer Exception)一直是我们最头疼的问题，也是最容易忽视的地方。NPE常是导致Java应用程序失败的最常见的原因。在日常研发工作中，经常会处理各种变量、集合，但在使用的过程中，往往要进行空判断，不然会出现NPE。 JDK8新特性之Optional介绍 Optional类实际上是个容器：它可以保存类型T的值，或者仅仅保存null。Optional 类的引入很好的解决空指针异常。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。尽量避免在程序中直接调用O
Java8中Optional的正确使用姿势
我是guyue，guyue就是我O(∩_∩)O
02-20 1222
单纯的使用Optional并不能很好的解决业务中的NPE问题 - 简书 https://www.jianshu.com/p/f21afe47a3e7 单纯的使用Optional并不能很好的解决业务中的NPE问题 工作中经常会遇到NPE（NullPointException）问题怎么处理，得到最多的回答就是Optional来处理，但是单纯的使用Optional并不能很好的...
java ispresent_java中对象的判断，isEmpty()和null(!Optional.ofNullable(对象).isPresent())区别，以及Optional的用法...
weixin_31578739的博客
02-24 4092
java中对象的判断，isEmpty()和null以及Optional.ofNullable(对象).isPresent()区别null是对象为空list对象.isEmpty()方法判断这个对象的值为空list对象.isEmpty()是不等于null的如果是一个list确保对象不为null才能判断值是否为空，或size()要大于零。调用CollectionUtils.isNotEmpty(list...
【函数式编程实战】(九) Optional实战大全
小明的Java问道之路
07-27 2251
本讲了解null的缺陷，了解为什么用Optional 取代null，学习Optional 的必要性，代码里怎么用Optional 才能更优雅
聊一聊 java8 中的 Optional
代码小疯子
06-20 947
1 Optional 的简介 Optional 类位于 java.util包下，保存类型为 T 的值包括（null），其isPresent()方法调用时，如果值存在会返回true，调用其 get()方法会返回该值。 Optional 的作用 ：Optional 类的引入主要是为了解决空指针异常(NullPointerException)。 2 Optional 的构造方法 创建 Optional 实例的方式有三种，分别是of、empty、ofNullable 三个静态方法。 2.1 Optional.of
关于optional的orElse和orElseGet、orElseThrow
gerald2008的专栏
05-18 2956
orElse 如果Optional实例有值则将其返回，否则返回orElse方法传入的参数 public T orElse(T other) 参数：other，即需要被返回的值 返回：当只存在时返回值，不存在返回other（可以理解为自定义值，如字符串的内容） 例子： //调用工厂方法创建Optional实例 Optional<String> name = Optional.of("Dolores"); //创建一个空实例 Optional empty = O
JDK1.8新特性总结 - 篇四(Optional容器类)
爱喝咖啡的程序员的博客
05-28 603
一. 简介 为了尽可能的避免空指针异常，jdk8中提出了Optional类。它是一个容器类，代表一个值是否实际存在。 以下是Optional类的常用方法: 1. public static<T> Optional<T> of(T value) 2. public static...
谈谈java8新特性Optional<T>
baomw的博客
04-26 3177
java.lang.NullPointerException 相信对每一个java程序员来说都不陌生的，常常因为缺少一个判空导致系统各自通讯错误，异常。从java8开始，给我们提供了一个对象判空操作处理类Optional。 根据jdk8官方文档，可以知道，该根据类存在于java.util下的final类，也就是说是官方提供给我们的一个工具类。 当然首先我们来看下具体的使用方法： Option...
JAVA8新特性之Optional＜T＞ 类
jothan的博客
07-26 4090
1前言 1.1 什么是Optional 类：Optional 类 (java.util.Optional) 是一个容器类，代表一个值存在或不存在，原来用 null 表示一个值不存在，现在用 Optional 可以更好的表达这个概念；并且可以避免空指针异常 2常用API（带*号表示常用） Optional.of(T t)：创建一个 Optional 实例 @Test public void test01(){ // Optional.of - 如果传递的参数是 null，抛出异常 NullPointerE
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值