jdk8新特性-Optional

已于 2023-01-28 15:50:00 修改
阅读量2.2k 收藏 7
点赞数 2
分类专栏： Java基础 文章标签： java 前端 开发语言
于 2022-07-07 16:11:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiao_yu_gan/article/details/125661440
版权

1、介绍

什么是Optional：Optional是jdk8推出的一个新类，为了减少代码中的判空代码，使代码更加干净整洁优雅，不提高执行效率。

使用场景：当一个对象需要进行判空代码处理的时候，就可以考虑使用Optional。

Optional类作用：可以将Optional理解为一个容器类，其内部仅能存放一个对象元素，Optional提供了一系列的工具方法进行判断、操作存放的元素。

其中部分API涉及到lambda表达式用法，lambda表达式用法可参见：https://blog.csdn.net/xiao_yu_gan/article/details/124095300。

2、使用语法

方法声明介绍
Optional empty();创建一个空的Optional对象。
Optional of(T value);使用一个非空的值创建Optional对象，传入null将抛出异常。
Optional ofNullable(T value);使用任意值创建Optional对象，若值为null，则创建一个空的Optional对象。
T get();返回Optional对象中的值，若为null，则抛出异常。
boolean isPresent()；若Optional对象中的值不为null，则返回true，否则返回false。
void ifPresent(Consumer<? super T> consumer);若Optional对象中的值不为null，则执行Consumer对象，否则不执行。
Optional filter(Predicate<? super T> predicate);执行Predicate对象，执行结果返回true，返回Optional对象中的值
执行结果返回false或Optional对象中的值为空都返回空的Optional对象。
Optional map(Function<? super T, ? extends U> mapper);执行Function对象，Function的入参为Optional对象中的值，返回值将被包装成Optional返回。
若原本Optional中的值为null，则直接返回空的Optional对象。
Optional flatMap(Function<? super T, Optional> mapper);功能和map方法一样，差别在于执行的Function对象需要返回Optional对象，否则抛出异常，返回对象为null也将抛出异常。
T orElse(T other);若Optional对象中有值，则将值返回，否则返回给定值other值。
T orElseGet(Supplier<? extends T> other);若Optional对象中有值，则将值返回，否则将执行Supplier对象并返回执行结果。
T orElseThrow(Supplier<? extends X> exceptionSupplier);若Optional对象中有值，则将值返回，否则将执行Supplier对象并将返回值作为异常抛出。

3、语法演示

壹：初始化

public class Demo {

    public static void main(String[] args) {

        //创建空的Optional
        Optional<Object> emptyOptional = Optional.empty();

        //使用of创建
        Optional<String> hello = Optional.of("hello");//正常
        Optional<Object> objectOptional = Optional.of(null);//运行时抛出异常

        //使用ofNullable创建
        Optional<String> hello2 = Optional.ofNullable("hello");//正常
        Optional<Object> objectOptional2 = Optional.ofNullable(null);//正常
    }

}

贰：获取Optional中的对象

  • get
public class Demo {

    public static void main(String[] args) {

        Optional<String> helloOptional = Optional.ofNullable("hello");
        Optional<String> nullOptional = Optional.ofNullable(null);

        //使用get获取Optional中的对象
        System.out.println(helloOptional.get());
        /**
         * 运行结果：
         * hello
         */


        System.out.println(nullOptional.get());
        /**
         * 运行结果：
         * 抛出运行时异常 java.util.NoSuchElementException
         */

    }

}
  • orElse
public class Demo {

    public static void main(String[] args) {

        Optional<String> helloOptional = Optional.ofNullable("hello");
        Optional<String> nullOptional = Optional.ofNullable(null);

        //执行orElse
        String result1 = helloOptional.orElse("val is null");
        System.out.println(result1);
        /**
         * 运行结果：
         * hello
         */

        String result2 = nullOptional.orElse("val is null");
        System.out.println(result2);
        /**
         * 运行结果：
         * val is null
         */
    }
}
  • orElseGet
public class Demo {

    public static void main(String[] args) {

        Optional<String> helloOptional = Optional.ofNullable("hello");
        Optional<String> nullOptional = Optional.ofNullable(null);

        //执行orElse
        String result1 = helloOptional.orElseGet(()->{
                return "val is null";
        });
        System.out.println(result1);
        /**
         * 运行结果：
         * hello
         */

        String result2 = nullOptional.orElseGet(()->{
            return "val is null";
        });
        System.out.println(result2);
        /**
         * 运行结果：
         * val is null
         */
    }
}

叁：判断Optional中的值

  • isPresent()
public class Demo {

    public static void main(String[] args) {

        Optional<String> helloOptional = Optional.ofNullable("hello");
        Optional<String> nullOptional = Optional.ofNullable(null);

        //使用isPresent判断Optional中的值是否为null
        System.out.println(helloOptional.isPresent());
        /**
         * 运行结果：
         * true
         */

        System.out.println(nullOptional.isPresent());
        /**
         * 运行结果：
         * false
         */

    }

}
  • ifPresent(Consumer<? super T> consumer)
public class Demo {

    public static void main(String[] args) {
        Optional<String> helloOptional = Optional.ofNullable("hello");
        Optional<String> nullOptional = Optional.ofNullable(null);

        //执行ifPresent(Consumer<? super T> consumer)方法
        helloOptional.ifPresent(str->{
            System.out.println("Optional中的值："+str);
        });
        /**
         * 运行结果：
         * Optional中的值：hello
         */


        nullOptional.ifPresent(str->{
            System.out.println("Optional中的值："+str);
        });
        /**
         * 运行结果：
         * 因nullOptional中的对象为null，所以不执行Consumer对象
         */
    }

}
  • filter
public class Demo {

    public static void main(String[] args) {
        Optional<String> helloOptional = Optional.ofNullable("hello");
        Optional<String> nullOptional = Optional.ofNullable(null);

        //执行filter方法
        Optional<String> result1 = helloOptional.filter(str -> {
            if ("hello world".equals(str)) {
                return true;
            }
            return false;
        });
        System.out.println(result1.get());
        /**
         * 运行结果：
         * 返回空的Optional对象，执行get抛出运行时异常 java.util.NoSuchElementException
         */

        Optional<String> result2 = helloOptional.filter(str -> {
            if ("hello".equals(str)) {
                return true;
            }
            return false;
        });
        System.out.println(result2.get());
        /**
         * 运行结果：
         * hello
         */

        Optional<String> result3 = nullOptional.filter(str -> {
            return true;
        });
        System.out.println(result3.get());
        /**
         * 运行结果：
         * 因为nullOptional中的对象为null，所以不执行Predicate对象，直接返回空的Optional对象
         * 执行get抛出运行时异常 java.util.NoSuchElementException
         */

    }

}
  • map
public class Demo {

    public static void main(String[] args) {

        Optional<String> helloOptional = Optional.ofNullable("hello");
        Optional<String> nullOptional = Optional.ofNullable(null);

        //执行map方法
        Optional<String> result1 = helloOptional.map(str -> {
            if ("hello world".equals(str)) {
                return "你好世界";
            }
            return "unknown";
        });
        System.out.println(result1.get());
        /**
         * 运行结果：
         * unknown
         */

        Optional<String> result2 = nullOptional.map(str -> {
            return "你好世界";
        });
        System.out.println(result2.get());
        /**
         * 运行结果：
         * 因nullOptional中的值为null，则map方法直接返回空的Optional对象
         * 执行get抛出运行时异常 java.util.NoSuchElementException
         */
    }

}
  • flatMap
public class Demo {

    public static void main(String[] args) {

        Optional<String> helloOptional = Optional.ofNullable("hello");
        Optional<String> nullOptional = Optional.ofNullable(null);

        //执行flatMap方法
        helloOptional.flatMap(str -> {
            return "unknown";
        });
        /**
         * 运行结果：
         * 编译阶段报错，因flatMap的Function对象需要返回一个Optional对象。
         */
        
        Optional<String> unknown = helloOptional.flatMap(str -> {
            return Optional.ofNullable("unknown");
        });
        System.out.println(unknown.get());
        /**
         * 运行结果：
         * unknown
         */
    }

}

4、使用案例

class Person{
    private String name;
    private int age;
    private EduBack eduBack;

    //省略getter、setter
}

class EduBack{
    private College college;
    private HighSchool highSchool;

    //省略getter、setter
}

class College{
    private String name;

    //省略getter、setter
}

class HighSchool{
    private String name;

    //省略getter、setter
}


public class Demo {

    /**
     * 传统方式获取高校名称
     * @param person
     * @return
     */
    public String getCollege(Person person){
        if(person==null){
            return null;
        }
        if(person.getEduBack()==null){
            return null;
        }
        if(person.getEduBack().getCollege()==null){
            return null;
        }
        return person.getEduBack().getCollege().getName();
    }

    /**
     * 使用Optional方式获取高中名称
     * @param person
     * @return
     */
    public String getHighSchool(Person person) {
        String highSchoolName = Optional.ofNullable(person)
                .map(p -> p.getEduBack())
                .map(edu -> edu.getHighSchool())
                .map(h -> h.getName())
                .orElse(null);
        return highSchoolName;
    }

    /**
     * 使用Optional方式获取高中名称(使用方法引用优化lambda)
     * @param person
     * @return
     */
    public String getHighSchoolQuot(Person person){
        String highSchoolName = Optional.ofNullable(person)
                .map(Person::getEduBack)
                .map(EduBack::getHighSchool)
                .map(HighSchool::getName)
                .orElse(null);

        return highSchoolName;
    }

    public static void main(String[] args) {
        HighSchool highSchool = new HighSchool();
        highSchool.setName("高中学校");

        College college = new College();
        college.setName("高校学校");

        EduBack eduBack = new EduBack();
        eduBack.setCollege(college);
        eduBack.setHighSchool(highSchool);

        Person person = new Person();
        person.setName("张三");
        person.setEduBack(eduBack);

        Demo demo = new Demo();
        System.out.println(demo.getCollege(person));

        System.out.println(demo.getHighSchool(person));
        System.out.println(demo.getHighSchoolQuot(person));
    }
}

5、实现原理

//jdk8中Optional类部分源码
public final class Optional<T> {
    /**
     * Common instance for {@code empty()}.
     */
    private static final Optional<?> EMPTY = new Optional<>();

    /**
     * If non-null, the value; if null, indicates no value is present
     * Optional类中的value变量，实际就是Optional容器中存放的值，其它所有的方法都是围绕此变量操作。
     */
    private final T value;

    //empty方法初始化一个空的Optional对象，最终就是调用此方法，将value变量设为null。
    private Optional() {
        this.value = null;
    }
    
    private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }

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

    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }
    
    public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }
    
    //value变量为null，直接抛出异常，否则直接返回value变量值。
    public T get() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }
}
雨橄
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java-JDK8新特性总结-接口方法/Lambda/方法引用/Optional
07-12
总结JDK8新特性，内容言简意赅，突出重点 内容：包括接口中的方法/Lambda/方法引用/Optional/函数式接口 适合人群：有一定编程基础及Java基础的伙伴 使用场景：开发和面试题中都会用到，开发中合理运用Java 8新特性...
JDK8新特性(四)：Optional 类的使用
扛麻袋的少年的博客
01-12 6111
Optional类的使用 JDK8以前，编写代码，通常会出现 NullPointerException (空指针异常)，通常情况下我们都是通过 if ... else... 来对对象进行为空判断，然后再进行逻辑处理，代码写起来也比较冗余。 JDK8新增了Optional类，使用该类可以避免我们对空指针的检查，使代码看起来比较优雅。 1.Optional类介绍 ...
详解 JDK8 新特性之 Optional 类
h2806504347的博客
06-17 271
详解 JDK8 新特性之 Optional 类
JDK8：使用Optional进行变量判空、集合遍历
YHJ
06-12 9440
NPE(Null Pointer Exception)一直是我们最头疼的问题，也是最容易忽视的地方。NPE常是导致Java应用程序失败的最常见的原因。在日常研发工作中，经常会处理各种变量、集合，但在使用的过程中，往往要进行空判断，不然会出现NPE。 JDK8新特性之Optional介绍 Optional类实际上是个容器：它可以保存类型T的值，或者仅仅保存null。Optional 类的引入很好的解决空指针异常。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。尽量避免在程序中直接调用O
JDK8新特性之Optional类,5分钟包你完全学会
m0_74340515的博客
11-13 455
在编写代码的时候为了防止空指针异常，往往需要各种非空的判段,而过多的判段会导致代码臃肿不堪。为了解决这一问题JDK8引入了Optional类，对于程序员，养成使用Optional类习惯，可以写出更为优雅的代码。Optional类就好像是一个包装类，我们可以把具体的数据封装到Optional对象内部。3，map和flatMap都是对操作的数据进行转换，得到的数据依然时OPtional类包装好的，保证了使用的安全。4，filter 对数据进行过滤如果都不符合判段的条件返回一个无数据的Optional对象。
JDK8之Optional
bluede2015的博客
04-09 187
是用来解决空指针的问题的
详细介绍JDK8中Optional对象的高级用法
sbcsdn111的博客
04-25 963
Optional 是 Java 8 引进的一个新特性，我们通常认为 Optional 是用于缓解 Java 臭名昭著的空指针异常问题。Optional 是个容器：它可以保存类型 T 的值，或者仅仅保存 null。如果值存在则 isPresent() 方法会返回 true，调用 get() 方法会返回该对象。Optional 提供很多有用的方法，这样我们就不用显式进行空值检测。
JDK8新特性（pdf版）
06-26
JDK8新特性课程内容包括了解Java发展史、Lambda表达式、接口的增强、函数式接口、方法引用、Stream API、Optional、新时间日期API等。 一、Java发展历史 Java的发展历史可以追溯到1991年，Sun公司成立了一个称为...
jdk8新特性对应代码
07-14
jdk8新特性学习代码，包含Lambda，StreamAPI，Optional的相关代码，适合新手学习了解，有比较详细的代码注解，帮助你更好理解，加油！！！
JDK8新特性
07-13
扩展方法、Lambda 表达式、内置的四大核心的函数式接口、方法引用与构造器引用、Stream API、Optional类..
jdk8新特性.zip
09-29
JDK1.8已经发布很久了，在很多企业中都已经在使用。并且Spring5、SpringBoot2.0都推荐使用JDK1.8以上版本...Java8新特性如下： Lambda表达式 函数式接口 方法引用 接口的默认方法和静态方法 Optional Streams 并行数组
JDK8新特性之Optional类
千里之行，始于足下
04-06 338
Optional 是 JDK8 新增加的一个工具类，位于 java.util 包下。 Optional 类的引入很好的解决空指针异常（微笑）。
JDK8：Optional详解与源码分析，如何优雅的处理空指针
秃了也弱了
08-03 229
在日常开发中，NullPointerException相信所有人都见过，不管你是刚入行的萌新还是骨灰级玩家，对于它都是耳熟能详的。它的出现可以说无处不在，总是能在各种场景下出现。那么对于如何防止它的出现，我们平时都是被动的采用各种非空校验，但是它还是经常能出现在我们的视线中。if(student!
JDK8新特性-Optional 浅谈
AIandfuture的博客
07-25 36
总而言之，`Optional` 提供了一种更加优雅和安全的方式来处理可能为空的对象，避免了空指针异常，并且可以简化代码逻辑。`Optional` 可以将可能为空的对象包装起来并提供一系列的操作方法，这些方法可以用来处理包装对象为空的情况，避免直接操作空引用导致的异常。它的设计目的是为了提供一种更好的方式来处理可能为空的对象。：`Optional` 提供了一些便利的方法，可以在不引发空指针异常的情况下对包装对象进行流式操作，例如 `map`、`filter`、`orElse` 等。明确标识可能为空的返回值。
JDK8新特性之Optional
巴卡巴卡哇的博客
01-19 550
Java8新特性之OptionalOptional简单介绍方法源码具体使用为什么要使用Optional？总结 Optional 简单介绍 Optional类（java.util.Optional）是一个容器类，代表一个值存在或不存在，原来用null表示一个值不存在，现在使用Optional类可以更好的表达这个概念，并且它还可以避免空指针异常。 方法源码 of /** * 创建一个Optional容器 * Returns an {@code Optional} with
jdk中的optional
mm910618的博客
02-25 519
从 Java 8 引入的一个很有趣的特性是Optional 类。Optional 类主要解决的问题是臭名昭著的空指针异常（NullPointerException） —— 每个 Java 程序员都非常了解的异常。 本质上，这是一个包含有可选值的包装类，这意味着 Optional 类既可以含有对象也可以为空。 Optional 是 Java 实现函数式编程的强劲一步，并且帮助在范式中实现。但是 Optional 的意义显然不止于此。 我们从一个简单的用例开始。在 Java 8 之前，任何...
JDK8特性：Optional类的用法
Newbie的专栏
03-11 379
JDK8中新增的Optional工具类使用说明
JDK8 新特性-Optional类用法详解
最新发布
qq_45443475的博客
09-26 186
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、付费专栏及课程。

余额充值