optional 订阅
optional 是一个英语单词,形容词,作形容词时意思是“可选择的,随意的”。 展开全文
optional 是一个英语单词,形容词,作形容词时意思是“可选择的,随意的”。
信息
外文名
optional
词    性
形容词
optional单词发音
英[ˈɒpʃənl];美[ˈɑːpʃənl] [1] 
收起全文
精华内容
下载资源
问答
  • optional
    2022-02-15 19:35:24

    1.Optional
    Optional是Java8提供的为了解决null安全问题的一个API。善用Optional可以使代码中很多繁琐、丑陋的设计变得十分优雅。
    java8之所以要提出这个对象,是因为java8中主要引入了lambda表达式,这种函数式编程中大量的链式调用,如果用原始的方法去判断nullpointException,会破坏lambda这种风格。

    比如在Android开发中,接口json中,对象里面有对象,对象中有属性。每次使用或作为参数传参时,都要!=null非空判断。一个还好,当属性嵌套得非常深的时候,就会出现以下代码。
    public class Person {
    private int age;
    private String name;
    private Address address;

    public Person(int age, String name, Address address) {
    this.age = age;
    this.name = name;
    this.address = address;
    }

    //…省略set、get方法

    public static class Address {
    private String roomNum;
    private String areaNum;
    public Address(String roomNum, String areaNum) {
    this.roomNum = roomNum;
    this.areaNum = areaNum;
    }
    //…省略set、get方法
    }
    }

    //错误码
    String errorNum = “error”;
    if (barry.getAddress() != null
    && barry.getAddress().getAreaNum() != null
    && !barry.getAddress().getAreaNum().equals(errorNum)) {
    String areaNum = barry.getAddress().getAreaNum();
    //最后使用areaNum属性做事情
    System.out.println("areaNum = " + areaNum);
    }
    总之,就是不好看,臃肿,也不优雅。

    Java8中,为了解决以上问题,引入了Optional类。Optional是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true,调用get()方法会返回该对象。

    2.Optional中的方法
    ①创建Optional
    Optional有三个静态构造方法:
    (1) Optional.of(T value)
    public static < T> Optional< T> of(T value) {
    return new Optional<>(value);
    }
    该方法通过一个非 null 的 value 来构造一个 Optional,返回的 Optional 包含了 value 这个值。对于该方法,传入的参数一定不能为 null,否则便会抛出 NullPointerException。

    举例:
    Optional< String> op1 = Optional.of(“Hello”);
    System.out.println(op1.isPresent()); // 输出 true
    System.out.println(op1.get()); // 输出 Hello
    Optional< String> op2 = Optional.of(null); // 抛出异常

    (2) Optional.ofNullable(T value)
    public static < T> Optional< T> ofNullable(T value) {
    return value == null ? empty() : of(value);
    }
    该方法和 of 方法的区别在于,传入的参数可以为 null 。从源码内部可以看出,该方法会判断传入的参数是否为 null,如果为 null 的话,返回的就是 Optional.empty()。

    举例:
    Optional< String> op2 = Optional.ofNullable(null);
    System.out.println(op2.isPresent()); // 输出 false

    (3) Optional.empty()
    public static< T> Optional< T> empty() {
    @SuppressWarnings(“unchecked”)
    Optional< T> t = (Optional< T>) EMPTY;
    return t;
    }
    该方法用来构造一个空的 Optional,即该 Optional 中不包含值 。其实底层实现还是 如果 Optional 中的 value 为 null ,则该 Optional 为不包含值的状态,然后在 API 层面将 Optional 表现的不能包含 null值,使得 Optional 只存在 包含值 和 不包含值 两种状态。

    ②isPresent()
    判断Optional中包裹的值,如果不为null,返回true,为null返回false。

    举例:
    (1) Optional< Object> optional = Optional.ofNullable(null);
    if (optional.isPresent()) {
    Object value = optional.get();
    //做操作
    System.out.println(value);
    }

    (2)ifPresent() 如果实例非空,调用 Comsumer Lambda 表达式:
    Optional< String> op1 = Optional.of(“Hello”);
    op1.ifPresent((s) -> {
    System.out.println(s); // 输出 Hello
    });

    ③Optional.get()
    获取Optional中包裹的值,如果值为null,抛出NoSuchElementException异常,一般会配合isPresent()进行判断后,再使用get获得值

    举例:
    (1)Optional< String> op1 = Optional.of(“Hello”);
    System.out.println(op1.isPresent()); // 输出 true
    System.out.println(op1.get()); // 输出 Hello
    (2)Optional< String> optional = Optional.ofNullable(“wally”);
    if (optional.isPresent()) {
    String value = optional.get();
    //做操作…
    }

    ④orElse
    判断Optional中包裹的值,如果值为null,返回orElse()中传入的默认值。

    举例:
    Optional< String> op1 = Optional.of(“Hello”);
    System.out.println(op1.orElse(“World”)); // 输出 Hello
    Optional< String> op2 = Optional.ofNullable(null);
    System.out.println(op2.orElse(“World”)); // 输出 World

    ⑤orElseGet(Supplier<? extends T> other)
    如果实例非空,返回该实例,否则返回 Supplier

    举例:
    Optional< String> op1 = Optional.of(“Hello”);
    System.out.println(op1.orElseGet(() -> {return new String(“World”);})); // 输出 Hello
    Optional< String> op2 = Optional.ofNullable(null);
    System.out.println(op2.orElseGet(() -> {return new String(“World”);})); // 输出 World

    ⑥orElseThrow()
    判断Optional中包裹的值,如果为null,抛出Supplier接口中get()返回的Throwable异常对象。否则返回Optional中包裹的值。

    举例:
    try {
    //对象方式
    Object value = optional.orElseThrow(new Supplier< Throwable>() {
    @Override
    public Throwable get() {
    return new NullPointerException(“value is null”);
    }
    });
    //lambda方式
    Object value = optional.orElseThrow((Supplier< Throwable>) () -> new NullPointerException(“value is null”));
    //输出
    System.out.println("value: " + value);
    } catch (Throwable throwable) {
    throwable.printStackTrace();
    }

    ⑦map(Function f)
    判断Optional中包裹的值,如果不为null,调用Function接口的apply()方法,获得新值,生成新的一个Optional并包裹新值。如果为null,则返回一个null值的Optional。

    举例:
    Optional< String> newOptional = Optional.of(“hello”).map(new Function<Object, String>() {
    @Override
    public String apply(Object o) {
    return “hi”;
    }
    });
    if (newOptional.isPresent()) {
    String value = newOptional.get();
    System.out.println(value);
    }

    ⑧flatMap(Function mapper)
    flatMap和map类似,但是Function接口的apply方法返回的是Optional对象。注意apply方法返回的Optional中包裹的值不能为null,否则抛出NullPointerException异常。

    举例:
    Optional< String> optional = Optional.of(“oh no”).flatMap(new Function<String, Optional< String>>() {
    @Override
    public Optional< String> apply(String s) {
    return Optional.of(“oh shit”);
    }
    });
    optional.ifPresent(System.out::println);

    ⑨filter
    对Optional中包裹的值,做过滤操作,调用Predicate中的test方法,做过滤操作判断,如果返回true,返回原始的Optional,否则返回一个null值的Optional。配合ifPresent()判断,过滤成功则不会调用输出方法。

    举例:
    Optional< String> stringOptional = Optional.of(“wally”).filter(new Predicate< String>() {
    @Override
    public boolean test(String value) {
    return value.length() > 3;
    }
    });
    stringOptional.ifPresent(System.out::println);

    3.Optional的使用
    一般,我们判断对象null的代码如下:
    public static String getName(User u) {
    if (u == null)
    return “Unknown”;
    return u.name;
    }
    有了optional后,我们千万不要改写成下面这种方式:
    public static String getName(User u) {
    Optional< User> user = Optional.ofNullable(u);
    if (!user.isPresent())
    return “Unknown”;
    return user.get().name;
    }

    这样改写非但不简洁,而且其操作还是和第一段代码一样。无非就是用isPresent方法来替代u==null。这样的改写并不是Optional正确的用法,我们再来改写一次。
    public static String getName(User u) {
    return Optional.ofNullable(u)
    .map(user->user.name)
    .orElse(“Unknown”);
    }
    这样才是正确使用Optional的姿势。那么按照这种思路,我们可以安心的进行链式调用,而不是一层层判断了。

    注意:要使用Optional,必须将所有属性都用Optional包一次,所以文章开头我们的Person类的Model就要改一下:
    public class PersonWithOptional {
    private Optional< Integer> age;
    private Optional< String> name;
    private Optional< Address> address;

    public PersonWithOptional(Optional< Integer> age, Optional< String> name, Optional< Address> address) {
    this.age = age;
    this.name = name;
    this.address = address;
    }

    public static class Address {
    private Optional< String> roomNum;
    private Optional< String> areaNum;
    public Address(Optional< String> roomNum, Optional< String> areaNum) {
    this.roomNum = roomNum;
    this.areaNum = areaNum;
    }
    //…省略set、get方法
    }
    //…省略set、get方法
    }

    Optional.of(barry).flatMap(new Function<PersonWithOptional, Optional<PersonWithOptional.Address>>() {
    @Override
    public Optional<PersonWithOptional.Address> apply(PersonWithOptional person) {
    //取出Address属性对象
    return barry.getAddress();
    }
    }).flatMap(new Function<PersonWithOptional.Address, Optional< String>>() {
    @Override
    public Optional< String> apply(PersonWithOptional.Address address) {
    //取出Address属性对象中的areaNum属性
    return address.getAreaNum();
    }
    }).filter(new Predicate< String>() {
    @Override
    public boolean test(String areaNum) {
    //校验areaNum的合法性,不合法在下面的ifPresent时被抛弃掉
    return !areaNum.equals(errorNum);
    }
    }).ifPresent(new Consumer< String>() {
    @Override
    public void accept(String areaNum) {
    //最后使用areaNum属性做事情
    System.out.println("areaNum = " + areaNum);
    }
    });
    可能有人会说,你这不是纯属增加代码量吗,这比传统写法写多好多代码呀!对于这种情况,终究还是那句话,代码是人看的,代码太复杂不利于阅读,尤其是那种写完几个星期后,只有上帝才知道是什么的代码~况且我们还有lambda这个大杀器!
    使用lambda,省略了内部类,是不是代码量少了,也依然结构清晰~
    Optional.of(barry)
    .flatMap(person -> barry.getAddress())
    .flatMap(PersonWithOptional.Address::getAreaNum)
    .filter(areaNum -> !areaNum.equals(errorNum))
    .ifPresent(areaNum -> System.out.println("areaNum = " + areaNum));

    更多相关内容
  • 本文我们介绍了Java 9 Optional Api新增的三个方法。or方法在Optional为空时返回Optional对象。 ifPresentOrElse()在值存在时执行Consumer参数,反之执行另一个参数回调参数。感兴趣的朋友跟随小编一起看看吧
  • optional_cC语言中Rust的Optional类型的实现这是一个可怕的概念证明,试图通过宏的魔力将Rust的Optional Type(在许多其他语言中)的功能引入C。 您可以将其与标准类型,您自己的类型,结构定义一起使用,用法是无限...
  • npm i @eastbanctech/ts-optional API文档 文档可。 用法示例 可以使用以下方法创建可选实例: Optional.ofNullable(someValue) Optional.of(nonNullableValue) Optional.empty() 可以像这样使用: const ...
  • Optional

    千次阅读 2019-11-06 09:10:55
    Optional java.util.Optional类是从 Java 8 引入的。 Optional 类主要解决空指针异常(NullPointerException) 的问题。 本质上,Optional 类一个包含有可选值的容器类,它既可以含有对象也可以为空。 示例1: ...

    注:本博客中有关实体类Dept的源代码请参看博客:Dept类源代码

    理论基础

    java.util.Optional类是从 Java 8 引入的。
    Optional 类主要解决空指针异常(NullPointerException) 的问题。
    本质上,Optional 类一个包含有可选值的容器类,它既可以含有一个对象也可以为空。

    创建Optional对象:

    • Optional.empty():创建空的Optional;
    • Optional.of(inst):创建非空(包含对应值的)的Optional,若inst为null,则抛出NullPointerException;
    • Optional.ofNullable(inst):创建允许null值的,若inst为null,则创建空的;

    从Optional中读取实例的变量值:

    • T get():存在则返回变量值,否则抛出NoSuchElementException异常;

    • T orElse(T other):存在返回变量值,不存在返回括号中的默认值(other);

      User user = Optional.ofNullable(userMapper.getUserById(1001))
              			.orElse(new User(1000, "未知"));        
      System.out.println("用户名是: " + user.getUsername());
      
    • T orElseGet(Supplier<? extends T> other):orElse延迟调用版,只有在对象不存在时,才会调用。

      User user = Optional.ofNullable(userMapper.getUserById(1001))
              			.orElseGet(new User(1000, "未知"));    
      System.out.println("用户名是: " + user.getUsername());
      
    • orElseThrow(Supplier<? extends X> exceptionSupplier):当 Optional 中有值的时候,返回值;没有值的时候会抛出的异常由传入的 exceptionSupplier的异常;

      在 SpringMVC 的控制器中,我们可以配置统一处理各种异常。查询某个实体时,如果数据库中有对应的记录便返回该记录,否则就可以抛出异常。

      User user = Optional.ofNullable(userMapper.getUserById(1001))
      			        .orElseThrow(new GlobalException("id 为 " + id + " 的用户不存在!"))
      
    • isPresent() :判断容器中是否有值。

    • ifPresent(Consumer<? super T> lambda):存在则返回变量值,否则执行括号中的Lambda表达式。

      Optional<User> user = Optional.ofNullable(userMapper.getUserById(1001));
      user.ifPresent(u -> System.out.println("用户名是: " + u.getUsername()));
      
    • or(Supplier<? extends Optional<? extends T>> supplier):如果一个 Optional 包含值,则返回自己;否则返回由参数 supplier 获得的 Optional

    • ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction):如果一个 Optional 包含值,则对其包含的值调用函数 action,即 action.accept(value),这与 ifPresent 一致;与 ifPresent 方法的区别在于,ifPresentOrElse 还有第二个参数 emptyAction —— 如果 Optional 不包含值,那么 ifPresentOrElse 便会调用 emptyAction,即 emptyAction.run()

    • stream():将 Optional 转为一个 Stream,如果该 Optional 中包含值,那么就返回包含这个值的 Stream;否则返回一个空的 Stream(Stream.empty())。

      public List<User> getUsers(Collection<Integer> userIds) {
          return userIds.stream()
                  .map(this::getUserById)    // 获得 Stream<Optional<User>>
                  .flatMap(Optional::stream) // Stream 的 flatMap 方法将多个流合成一个流
                  .collect(Collectors.toList());
      }
      

    示例:

    // map: map 方法会使用 Optional.ofNullable 将其包装为 Optional
    Optional<String> username = Optional.ofNullable(userMapper.getUserById(1001))
            							.map(user -> user.getUsername());   
    System.out.println("用户名是: " + username.orElse("未知"));
    
    // map
    Optional<String> username = Optional.ofNullable(userMapper.getUserById(1001))
    							        .map(user -> user.getUsername())
    							        .map(name -> name.toLowerCase())
    							        .map(name -> name.replace('_', ' '));
    System.out.println("用户名是: " + username.orElse("未知"));
    
    // flatMap:flatMap 要求参数中的函数 mapper 输出的就是 Optional
    Optional<String> username = Optional.ofNullable(userMapper.getUserById(1001))
    							        .flatMap(user -> Optional.of(user.getUsername()))
    							        .flatMap(name -> Optional.of(name.toLowerCase()));     
    System.out.println("用户名是: " + username.orElse("未知"));
    
    // filter:filter 方法接受一个 Predicate 来对 Optional 中包含的值进行过滤,如果包含的值满足条件,那么还是返回这个 Optional;否则返回 Optional.empty
    Optional<String> username = Optional.ofNullable(userMapper.getUserById(1001))
    							        .filter(user -> user.getId() < 10)
    							        .map(user -> user.getUsername());      
    System.out.println("用户名是: " + username.orElse("未知"));
    
    

    示例1:

    public static void main(String[] args) {
        Optional<Object> op = Optional.empty();
        System.out.println(op.isPresent());//是否为null,存在返回true,否则返回false
        System.out.println(op.isEmpty());//是否为空
    
        //of与get通常搭配使用
        Optional<String> op1 = Optional.of("haha");//封装字符串生成Optional对象
        System.out.println(op1.isPresent());
        System.out.println(op1.get());//获取内部封装的数据
    
        //ofNullable与通常搭配使用
        Optional<Object> op2 = Optional.ofNullable(null);
        System.out.println(op2.isPresent());
        System.out.println(op2.isEmpty());
        System.out.println(op2.orElse("hehe"));
    }
    

    结果:
    在这里插入图片描述

    示例2:求部门的地址,若部门为空返回ACCOUNTING部门

    • 测试代码:利用Optional避免空指针
    public static void main(String[] args) {
        Dept dept = new Dept(20, "RESEARCH", "DALLAS");
        dept = null;  //------------- ①
        Optional<Dept> op = Optional.ofNullable(dept);
        Dept res = op.orElse(new Dept(10, "ACCOUNTING", "CHICAGO"));// 如果有值则将其返回,否则返回参数指定的其他值。
        System.out.println(res);
    }
    
    • 运行:
    1. 当编号①处代码注释起来时:
      在这里插入图片描述
    2. 当编号①处代码未注释起来时:
      在这里插入图片描述

    任何访问对象方法或属性的调用都可能导致 NullPointerException。

    示例3:使用Optional简化if-else

    • 代码:
    public static void main(String[] args) {
        Dept dept = new Dept(20, "RESEARCH", "DALLAS");
        dept = null;  //------------- ①
        String res = Optional.ofNullable(dept)
    			            .map(Dept::getLoc)
    			            .map(String::toUpperCase)
    			            .orElse(null); //如果有值则将其返回,否则返回参数指定的其他值。
        System.out.println(res);
    }
    

    有了 Optional,我们便可以方便且优雅的在自己的代码中处理 null 值,而不再需要一昧通过容易忘记和麻烦的 if (object != null) 来判断值不为 null

    • 运行:
    1. 当编号①处代码注释起来时:
      在这里插入图片描述
    2. 当编号①处代码未注释起来时:
      在这里插入图片描述
    展开全文
  • 使用要求该库需要TS 2.8+版本才能使用安装npm install optional-chain用法 import { optional } from "optional-chain" ;type User = { name ?: { first : string }}const user : User = getUser ( ) ; // { name: ...
  • Optional.js:JS的Java可选

    2021-05-02 09:13:29
    Optional.js 一个容器对象,该对象在JavaScript中包装可能未定义的值-受启发 Optional . ofNullable ( promptForUserName ) . map ( getUserId ) . filter ( verify ) . ifPresent ( login ) ; 特征 在浏览器和...
  • JAVA Optional类用法分享

    2020-08-28 13:37:00
    本篇文章主要给大家分析了JAVA中Optional类用法以及代码分析,跟着小编学习下吧。
  • Boost.Optional的教育性C ++ 20实现,也是-C ++ 20 std :: optional。 boost20.optional Boost.Optional的教育性C ++ 20实现,也是-C ++ 20 std :: optional。 此实现的主要动机是探索以下C ++ 20功能:概念受限的...
  • JDK1.8 Optional 笔记.pdf

    2021-09-19 12:12:02
    JDK1.8 Optional用法案例详细解读
  • 我们知道 Java 8 增加了一些很有用的 API, 其中一个就是 Optional,下面这篇文章主要给大家介绍了关于如何正确使用Java8中Optional机制的相关资料,文中通过示例代码介绍的非常详细,需要的朋友可以参考借鉴,下面来...
  • 可选裸:一个简单的单文件标头版本,类似于C ++ 17,可选,用于默认可构造的可复制类型,适用于C ++ 98和更高版本 内容建立测试注释和参考附录 用法示例# include " nonstd/optional.hpp "# include < cstdlib># ...
  • 主要介绍了Swift中Optional值的链式调用学习笔记,Optional链是Swift入门学习中的基础知识,需要的朋友可以参考下
  • 主要介绍了Java8 Optional原理及用法解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • std-optional:std 的实现

    2021-06-21 03:11:15
    标准可选 c++17 草案中 std::optional 接口的实现
  • 我们知道 Java 8 增加了一些很有用的 API, 其中一个就是 Optional,下面这篇文章主要给大家介绍了关于Java8中Optional的一些常见错误用法的相关资料,文中通过示例代码介绍的非常详细,需要的朋友可以参考下
  • 语言:Français 使用activeTab,Cookie,历史记录和 在optional_permissions中 测试说明
  • Optional 使用方法详解

    千次阅读 多人点赞 2022-05-15 21:41:03
    Optional的作用是什么?他都有哪些方法?阿里规范点名说尽量用Optional来避免空指针,那么什么场景用Optional?本篇文章围绕这三点来进行讲解。

    Optional的作用是什么?他都有哪些方法?阿里规范点名说尽量用Optional来避免空指针,那么什么场景用Optional?本篇文章围绕这三点来进行讲解。

    一、Optional类的来源

    到目前为止,臭名昭著的空指针异常是导致Java应用程序失败的最常见原因。以前,为了解决空指针异常,Google公司著名的Guava项目引入了Optional类,Guava通过使用检查空值的方式来防止代码污染,它鼓励程序员写更干净的代码。受到Google Guava的启发,Optional类已经成为Java 8类库的一部分。

    二、Optional类是什么?

    Optional 类(java.util.Optional) 是一个容器类,它可以保存类型T的值,代表这个值存在。或者仅仅保存null,表示这个值不存在。原来用 null 表示一个值不存在,现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常。

    Optional提供很多有用的方法,这样我们就不用显式进行空值检测。

    三、Optional类用法

    Optional类的Javadoc描述如下:这是一个可以为null的容器对象。
    如果值存在则isPresent()方法会返回true,调用get()方法会返回该对象。
    如果值不存在则isPresent()方法会返回false,调用get()方法会NPE。

    创建Optional类对象的方法:

    • Optional.of(T t) : 创建一个 Optional 实例,t必须非空;
    • Optional.empty() : 创建一个空的 Optional 实例
    • Optional.ofNullable(T t):t可以为null

    判断Optional容器中是否包含对象:

    • boolean isPresent() : 判断是否包含对象
    • void ifPresent(Consumer<? super T> consumer) :如果有值,就执行Consumer接口的实现代码,并且该值会作为参数传给它。

    获取Optional容器的对象:

    • T get(): 如果调用对象包含值,返回该值,否则抛异常
    • T orElse(T other) :如果有值则将其返回,否则返回指定的other对象。
    • T orElseGet(Supplier<? extends T> other) :如果有值则将其返回,否则返回由Supplier接口实现提供的对象。
    • T orElseThrow(Supplier<? extends X> exceptionSupplier) :如果有值则将其返回,否则抛出由Supplier接口实现提供的异常。

    过滤:

    • Optional<T> filter(Predicate<? super <T> predicate):如果值存在,并且这个值匹配给定的 predicate,返回一个Optional用以描述这个值,否则返回一个空的Optional。

    映射

    • <U>Optional<U> map(Function<? super T,? extends U> mapper):如果有值,则对其执行调用映射函数得到返回值。如果返回值不为 null,则创建包含映射返回值的Optional作为map方法返回值,否则返回空Optional。
    • <U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper):如果值存在,就对该值执行提供的mapping函数调用,返回一个Optional类型的值,否则就返回一个空的Optional对象

    四、代码示例

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    class Student {
        private String name;
        private Integer age;
    }
    

    1、创建Optional类

    public void test1() {
    	// 声明一个空Optional
    	Optional<Object> empty = Optional.empty();
    	
    	// 依据一个非空值创建Optional
    	Student student = new Student();
    	Optional<Student> os1 = Optional.of(student);
    	
    	// 可接受null的Optional
    	Student student1 = null;
    	Optional<Student> os2 = Optional.ofNullable(student1);
    }	
    

    2、判断Optional容器中是否包含对象

    isPresent不带参数,判断是否为空,ifPresent可以选择带一个消费函数的实例。(isPresentifPresent一个是 is 一个是 if 注意一下哈)

    public void test1() {
        Student student = new Student();
        Optional<Student> os1 = Optional.ofNullable(student);
        boolean present = os1.isPresent();
        System.out.println(present);
    
        // 利用Optional的ifPresent方法做出如下:当student不为空的时候将name赋值为张三
        Optional.ofNullable(student).ifPresent(p -> p.setName("张三"));
    }
    

    3、获取Optional容器的对象

    public void test1() throws Exception {
        Student student = null;
        Optional<Student> os1 = Optional.ofNullable(student);
        // 使用get一定要注意,假如student对象为空,get是会报错的
        // java.util.NoSuchElementException: No value present
        Student student1 = os1.get();
    
        // 当student为空的时候,返回我们新建的这个对象,有点像三目运算的感觉
        Student student2 = os1.orElse(new Student("张三", 18));
    
        // orElseGet就是当student为空的时候,返回通过Supplier供应商函数创建的对象
        Student student3 = os1.orElseGet(() -> new Student("张三", 18));
    
        // orElseThrow就是当student为空的时候,可以抛出我们指定的异常
        os1.orElseThrow(() -> new Exception());
    }
    

    4、过滤

    public void test1() {
        Student student = new Student("李四", 3);
        Optional<Student> os1 = Optional.ofNullable(student);
        os1.filter(p -> p.getName().equals("张三")).ifPresent(x -> System.out.println("OK"));
    }
    

    5、映射

    map代码示例:

    public void test1() {
         Student student = new Student("李四", 3);
         Optional<Student> os1 = Optional.ofNullable(student);
         // 如果student对象不为空,就加一岁
         Optional<Student> emp = os1.map(e ->
         {
             e.setAge(e.getAge() + 1);
             return e;
         });
     }
    

    这块的map说实话对lambda不是很熟练的 理解起来是很绕脑子的。

    这里的map实际上就是用的Function函数,Function函数是有两个参数的,第一个是入参数据类型,第二个是返回数据类型。Function函数作用就是传入一个对象,然后返回一个对象,返回的对象类型可以自己设置。

    T 就是代表实例的泛型数据类型,就是谁调用的 入参 必须跟调用者泛型的数据类型一样。
    U 就是自己说了算,调用完map之后返回什么数据类型,那么U就设置什么

    在这里插入图片描述
    flatMap代码示例: flatMap跟map是一样的只不过他返回的是optional对象。

    public static Optional<Integer> stringToInt(String s) {
         try {
             return Optional.of(Integer.parseInt(s));
         } catch (NumberFormatException e) {
             e.printStackTrace();
             return Optional.empty();
         }
     }
    
    Optional.ofNullable(props.getProperty(name))
            .flatMap(OptionalUtils::stringToInt)
            .filter(i -> i>0)
            .orElse(0);
    

    五、什么场景用Optional?

    以前一直不懂Optional有啥用,感觉太无语了,Java8还把它当做一个噱头来宣传,最近终于发现它的用处了,当然不用函数式编程的话,是没感觉的;

    如下提供了几个应用场景,基本上都是开发当中经常遇到的。

    1、场景一

    PatientInfo patientInfo = patientInfoDao.getPatientInfoById(consultOrder.getPatientId());
    if (patientInfo != null) {
        consultInfoResp.setPatientHead(patientInfo.getHead());
    }
    
    // 使用Optional 和函数式编程,一行搞定,而且像说话一样
    Optional.ofNullable(patientInfo).ifPresent(p -> consultInfoResp.setPatientHead(p.getHead()));
    

    2、场景二

    public void test1() throws Exception {
        Student student = new Student(null, 3);
        if (student == null || isEmpty(student.getName())) {
            throw new Exception();
        }
        String name = student.getName();
        // 业务省略...
    
        // 使用Optional改造
        Optional.ofNullable(student).filter(s -> !isEmpty(s.getName())).orElseThrow(() -> new Exception());
    }
    
    public static boolean isEmpty(CharSequence str) {
        return str == null || str.length() == 0;
    }
    

    3、场景三

    public static String getChampionName(Competition comp) throws IllegalArgumentException {
        if (comp != null) {
            CompResult result = comp.getResult();
            if (result != null) {
                User champion = result.getChampion();
                if (champion != null) {
                    return champion.getName();
                }
            }
        }
        throw new IllegalArgumentException("The value of param comp isn't available.");
    }
    

    这个在开发中是很常见的一种逻辑。去判读传进来的参数时候为空,或者是从数据库中获取的对象。由于某些原因,我们不能很流程的直接这样写。

    comp.getResult().getChampion().getName()
    

    上面的写法用Optional改写:

    public static String getChampionName(Competition comp) throws IllegalArgumentException {
        return Optional.ofNullable(comp)
                .map(Competition::getResult)  // 相当于c -> c.getResult(),下同
                .map(CompResult::getChampion)
                .map(User::getName)
                .orElseThrow(()->new IllegalArgumentException("The value of param comp isn't available."));
    }
    

    4、场景四

    类型之间的转换,并且当没有值的时候返回一个默认值

    int timeout = Optional.ofNullable(redisProperties.getTimeout())
    					  .map(x -> Long.valueOf(x.toMillis()).intValue())
    					  .orElse(10000);
    
    展开全文
  • java8的Optional 详解

    千次阅读 2022-04-30 08:12:59
    1、Optional 介绍 传统的写代码方式经常会遇到NullPointerException,这就需要我们在代码中经常判空。而判空的写法又会显得很累赘,这里就可以用到Optional来简化代码。 Optional是在java.util包下的一个用于代替...

    1、Optional 介绍

    传统的写代码方式经常会遇到NullPointerException,这就需要我们在代码中经常判空。而判空的写法又会显得很累赘,这里就可以用到Optional来简化代码。

    Optional是在java.util包下的一个用于代替null的一个工具类。

    import java.util.Optional;
    
    1. Optional 是个容器:它可以保存类型T的值,或者仅仅保存null。Optional提供很多有用的方法,这样我们就不用显式进行空值检测。
    2. Optional 类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true,调用get()方法会返回该对象。
    3. Optional 类的引入很好的解决空指针异常

    2、构建Optional

    构建一个Optional对象;方法有:empty( )、of( )、ofNullable( )

            //返回一个描述给定值的Optional ,如果不为null ,则返回一个空的Optional 。
            //参数:值–描述的可能为null值
            //类型参数:<T> –值的类型
            //返回值:一个Optional与如果指定值是非当前值null ,否则一个空Optional
            Optional.ofNullable(T value);//value为null的话返回-Optional.empty();
    
            //返回一个Optional描述给定的非null值。
            //参数:value –要描述的值,必须为非null
            //类型参数:<T> –值的类型
            //返回值:存在值的Optional
            Optional.of(T value);//  value需要非 null,null会抛异常;
    
            //返回一个空的Optional实例。 此Optional没有值。
            //类型参数:<T> –不存在的值的类型
            //返回值:一个空的Optional
            //api注意:尽管这样做可能很诱人,但应通过将==与Optional.empty()返回的实例进行比较来避免测试对象是否为空。
            // 不能保证它是一个单例。
            // 而是使用isPresent()
            Optional.empty();// 用来构造一个空的 Optional;
    

    3、Optional的相关方法介绍

    1. isPresent(): 持有非空值,返回true;否则false;
      		Optional optional = Optional.ofNullable(null);
            Optional optional1 = Optional.of("");
            Optional optional2 = Optional.empty();
            System.out.println(optional.isPresent());
            System.out.println(optional1.isPresent());
            System.out.println(optional2.isPresent());
    

    打印结果:

    false
    true
    false
    
    1. ifPresent(): 如果 Optional 中有值,则对该值调用consumer.accept,否则什么也不做。
    2. orElse: 参数是一个值,如果 Optional 中有值则将其返回,否则返回 orElse 方法传入的参数。

    Optional 中有值:

    //Optional 中有值
    Optional optional = Optional.ofNullable("fdgshsgf");
    System.out.println(optional.orElse("reiwgybv"));
    

    打印结果:
    在这里插入图片描述

    Optional 中没有值:

    //Optional 中有没有值
    Optional optional = Optional.ofNullable(null);
    System.out.println(optional.orElse("reiwgybv"));
    

    打印结果:
    在这里插入图片描述
    注意:
    Optional 只有null时表示为空值,其他任何情况都不表示空值,如空字符串。

     Optional optional = Optional.ofNullable("");
     System.out.println(optional.orElse("reiwgybv"));
    

    打印结果是空字符串:
    在这里插入图片描述

    1. orElseGet: 传入的参数为一个 Supplier 接口的实现。
    2. orElseThrow: 没有值的时候会抛出异常,抛出的异常由传入的 exceptionSupplier 提供。

    示例:

    return Optional.ofNullable(iNewsMapper.selectNewsWithNewsCategoryById(id))
            .orElseThrow(() -> new BaseException(DataSourceResponseEnum.SELECT_ERROR));
    
    
    1. map: 为空返回 Optional.empty;否则返回一个新的 Optional:函数 mapper 在以 value 作为输入时的输出值;可以多次使用map操作。
    Optional<String> username = Optional.ofNullable(getUserById(id))
    		.map(user -> user.getUsername())
    		.map(name -> name.replace('_', ' '));
    			
    System.out.println("Username is: " + username.orElse("Unknown"));
    
    1. flatMap: map 方法参数中的函数 mapper 输出的是值,然后 map 方法会使用 Optional.ofNullable 将其包装为 Optional;而 flatMap 要求参数中的函数 mapper 输出的就是 Optional。
    Optional<String> username = Optional.ofNullable(getUserById(id))
    		.flatMap(user -> Optional.of(user.getUsername()))
    		.flatMap(name -> Optional.of(name.toLowerCase()));
    		
    System.out.println("Username is: " + username.orElse("Unknown"));
    
    1. filter: 接受一个 Predicate 来对 Optional 中包含的值进行过滤,如果包含的值满足条件,那么还是返回这个 Optional;否则返回 Optional.empty。

    4、源码解析

    package java.util;
    
    import java.util.function.Consumer;
    import java.util.function.Function;
    import java.util.function.Predicate;
    import java.util.function.Supplier;
    import java.util.stream.Stream;
    
    /**
    一个可能包含也可能不包含非null值的容器对象。 如果存在值,则isPresent()返回true 。 如果不存在任何值,则该对象被视为空,并且isPresent()返回false 。
    提供了其他取决于所包含值是否存在的方法,例如orElse() (如果不存在值,则返回默认值)和ifPresent() (如果存在值,则执行操作)。
    这是一个基于值的类; 在Optional实例上使用标识敏感的操作(包括引用等于( == ),标识哈希码或同步)可能会产生不可预测的结果,应避免使用
     */
    public final class Optional<T> {
        /**
         * empty()通用实例
         */
        private static final Optional<?> EMPTY = new Optional<>();
    
        /**
         * 如果不为空,则为该值;否则为false。 如果为null,则表示不存在任何值
         */
        private final T value;
    
        /**
            构造一个空实例。
            impl注意:
            通常,每个VM仅应存在一个空实例EMPTY 
         */
        private Optional() {
            this.value = null;
        }
    
        /**
            返回一个空的Optional实例。 此Optional没有值。
            类型参数:<T> –不存在的值的类型
            返回值:一个空的Optional
            api注意:
            尽管这样做可能很诱人,但应通过将==与Optional.empty()返回的实例进行比较来避免测试对象是否为空。 不能保证它是一个单例。 而是使用isPresent() 
         */
        public static<T> Optional<T> empty() {
            @SuppressWarnings("unchecked")
            Optional<T> t = (Optional<T>) EMPTY;
            return t;
        }
    
        /**
            使用描述的值构造一个实例。
            参数:值–要描述的非null值
            抛出:NullPointerException如果值为null
         */
        private Optional(T value) {
            this.value = Objects.requireNonNull(value);
        }
    
        /**
            返回一个Optional描述给定的非null值。
            参数:value –要描述的值,必须为非null
            类型参数:<T> –值的类型
            返回值:存在值的Optiona
         */
        public static <T> Optional<T> of(T value) {
            return new Optional<>(value);
        }
    
        /**
            返回一个描述给定值的Optional ,如果不为null ,则返回一个空的Optional 。
            参数:值–描述的可能为null值
            类型参数:<T> –值的类型
            返回值:一个Optional与如果指定值是非当前值null ,否则一个空Optional
         */
        public static <T> Optional<T> ofNullable(T value) {
            return value == null ? empty() : of(value);
        }
    
        /**
            如果存在值,则返回该值,否则抛出NoSuchElementException 。
            返回值:此Optional描述的非null值
            抛出:NoSuchElementException如果不存在任何值
            api注意:此方法的首选替代方法是orElseThrow() 。
         */
        public T get() {
            if (value == null) {
                throw new NoSuchElementException("No value present");
            }
            return value;
        }
    
        /**
            如果存在值,则返回true ,否则返回false 。
    
            返回值:如果存在值,则为true ,否则为false
         */
        public boolean isPresent() {
            return value != null;
        }
    
        /**
            如果不存在值,则返回true ,否则返回false 。
    
            返回值:如果不存在值,则为true ,否则为false
         */
        public boolean isEmpty() {
            return value == null;
        }
    
        /**
            如果存在值,则使用该值执行给定的操作,否则不执行任何操作。
            参数:动作–要执行的动作(如果存在值)
         */
        public void ifPresent(Consumer<? super T> action) {
            if (value != null) {
                action.accept(value);
            }
        }
    
        /**
            如果存在值,则使用该值执行给定的操作,否则执行给定的基于空的操作。
            参数:动作–要执行的动作(如果存在值)emptyAction –要执行的基于空的操作(如果不存在任何值)
            抛出:NullPointerException如果存在一个值并且给定的操作为null ,或者不存在任何值并且给定的基于空的操作为null 
         	@since 9
         */
        public void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction) {
            if (value != null) {
                action.accept(value);
            } else {
                emptyAction.run();
            }
        }
    
        /**
            如果存在一个值,并且该值与给定的谓词匹配,则返回描述该值的Optional ,否则返回一个空的Optional 。
    
            参数:谓词–应用于值的谓词(如果存在)
            返回值:一个Optional描述此的值Optional ,如果一个值存在并且该值给定的谓词相匹配,否则一个空Optional
            抛出:NullPointerException如果谓词为null
         */
        public Optional<T> filter(Predicate<? super T> predicate) {
            Objects.requireNonNull(predicate);
            if (!isPresent()) {
                return this;
            } else {
                return predicate.test(value) ? this : empty();
            }
        }
    
        /**
            如果存在值,则返回一个Optional描述(就像by ofNullable ),将给定映射函数应用于该值的结果,否则返回一个空的Optional 。
            如果映射函数返回null结果,则此方法返回空的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));
            }
        }
    
        /**
             如果存在一个值,则返回将给定Optional -bearing映射函数应用于该值的结果,否则返回一个空的Optional 。
            此方法类似于map(Function) ,但是映射函数是其结果已经是Optional函数,如果调用该函数,则flatMap不会将其包装在其他Optional 。
    
            参数:mapper –应用于值的映射函数(如果存在)
            类型参数:<U> –映射函数返回的Optional值的类型
            返回值:施加的结果Optional荷瘤映射函数此的值Optional ,如果一个值存在,否则一个空Optional
            抛出:NullPointerException如果映射函数为null或返回null结果
    
         */
        public <U> Optional<U> flatMap(Function<? super T, ? extends Optional<? extends U>> mapper) {
            Objects.requireNonNull(mapper);
            if (!isPresent()) {
                return empty();
            } else {
                @SuppressWarnings("unchecked")
                Optional<U> r = (Optional<U>) mapper.apply(value);
                return Objects.requireNonNull(r);
            }
        }
    
        /**
            如果值存在时,返回一个Optional描述的值,否则将返回一个Optional产生通过供给功能。
    
            参数:供应商–产生要返回的Optional的供应功能
            返回值:返回一个Optional描述此的值Optional ,如果一个值存在,否则Optional所生产的供应功能。
            抛出:NullPointerException如果提供的函数为null或产生null结果
         * @since 9
         */
        public Optional<T> or(Supplier<? extends Optional<? extends T>> supplier) {
            Objects.requireNonNull(supplier);
            if (isPresent()) {
                return this;
            } else {
                @SuppressWarnings("unchecked")
                Optional<T> r = (Optional<T>) supplier.get();
                return Objects.requireNonNull(r);
            }
        }
    
        /**
            如果存在值,则返回仅包含该值的顺序Stream ,否则返回空Stream 。
    
            返回值:作为Stream的可选值
         * @since 9
         */
        public Stream<T> stream() {
            if (!isPresent()) {
                return Stream.empty();
            } else {
                return Stream.of(value);
            }
        }
    
        /**
            如果存在值,则返回该值,否则返回other 。
    
            参数:其他–要返回的值(如果不存在任何值)。 可以为null 。
            返回值:值(如果存在),否则other
         */
        public T orElse(T other) {
            return value != null ? value : other;
        }
    
        /**
            如果存在值,则返回该值,否则返回由供应函数产生的结果。
    
            参数:供应商–产生要返回的值的供应函数
            返回值:值(如果存在),否则提供功能产生的结果
         */
        public T orElseGet(Supplier<? extends T> supplier) {
            return value != null ? value : supplier.get();
        }
    
        /**
         * If a value is present, returns the value, otherwise throws
         * {@code NoSuchElementException}.
         *
         * @return the non-{@code null} value described by this {@code Optional}
         * @throws NoSuchElementException if no value is present
         * @since 10
         */
        public T orElseThrow() {
            if (value == null) {
                throw new NoSuchElementException("No value present");
            }
            return value;
        }
    
        /**
            如果存在值,则返回该值,否则抛出由异常提供函数产生的异常。
    
            参数:exceptionSupplier –产生要抛出的异常的提供函数
            类型参数:<X> –引发的异常类型
            返回值:值(如果存在)
            抛出:X –如果不存在任何值NullPointerException如果不存在任何值并且异常提供函数为null
            api注意:带有空参数列表的对异常构造函数的方法引用可用作提供者
         */
        public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
            if (value != null) {
                return value;
            } else {
                throw exceptionSupplier.get();
            }
        }
    }
    

    5、结合业务现实解析

    创建一个动物实体类:

    /**
     * 动物实体类
     */
     @Data
    public class Animal {
    
        private String lb;//类别
    
        private String name;//姓名
    
        private Integer age; //年龄
    
        }
    

    (1)Optional 构建

     		//返回一个描述给定值的Optional ,如果不为null ,则返回一个空的Optional 。
            //参数:值–描述的可能为null值
            //类型参数:<T> –值的类型
            //返回值:一个Optional与如果指定值是非当前值null ,否则一个空Optional
            Optional s1 = Optional.ofNullable(null);
    
            // 构建一个value不可以为null的optional对象,如果of()的入参为null会报空指针异常;
            Optional<Animal> s2 = Optional.of(new Animal("哺乳动物", "小狗",5));
    
            // 构建一个value可以为null的optional对象;
            Optional<Animal> s3 = Optional.ofNullable(null);
    
            System.out.println(s1);
            System.out.println(s2);
            System.out.println(s3);
    

    输出结果:
    在这里插入图片描述

    (2)判断类业务

     		Optional<Animal> myUser1 = Optional.empty();
            Optional<Animal> myUser2 = Optional.of(new Animal("哺乳动物", "小猫",8));
    
            // filter传入一个lambda,lambda返回值为boolean;true:不做任何改变,false:返回一个空的optional;
            Optional<Animal> myUser3 = myUser2.filter(animal -> "小猫".equals(animal.getName()));
            Optional<Animal> myUser4 = myUser2.filter(animal -> "小7猫".equals(animal.getName()));
    
            // isPresent就是判断value是不是null;我们在调用get之前,一定要先调用isPresent,因为直接如果value是null,直接调用get会报异常;
            if (myUser1.isPresent()) {
                Animal value = myUser1.get();
                System.out.println("optional value:" + value);
            } else {
                System.out.println("optional value==null");
            }
            // ifPresent传入一段lambda,当value!=null时,执行里面的逻辑;当当value==null时,啥都不干;
            myUser2.ifPresent(value -> System.out.println("optional value:" + value));
    
    
            System.out.println(myUser3);
            System.out.println(myUser4);
    

    输出结果:
    在这里插入图片描述

    (3)获取类业务(常用)

    		Optional<Animal> userInfoEmptyOpt = Optional.empty();
            Optional<Animal> userInfoOpt = Optional.of(new Animal("猫科动物","哆啦A梦",15));
    
    
            // 1、直接获取,注意如果value==null,会报NoSuchElementException异常
            Animal userInfo1 = userInfoOpt.get();
    
            // 2、orElse可以传入一个UserInfo类型的对象作为默认值;
            //    当value!=null时,返回value值;当value==null时,返回默认值作为代替;
            Animal userInfo2 = userInfoEmptyOpt.orElse(new Animal("猫科动物1","哆啦A梦",15));
    
            // 3、orElseGet和orElse不同的是orElseGet可以传入一段lambda表达式;
            // 当value!=null时,返回value值;
            // 当value==null时,使用该lambda返回的对象作为默认值;
            Animal userInfo3 = userInfoEmptyOpt.orElseGet(() -> new Animal("猫科动物2","哆啦A梦",15));
    
            // 4、orElseThrow可以传入一段lambda表达式,lambda返回一个Exception;当value!=null时,返回value值;当value==null时,抛出该异常;
            Animal userInfo4 = userInfoOpt.orElseThrow(NullPointerException::new);
    
            System.out.println(userInfo1);
            System.out.println(userInfo2);
            System.out.println(userInfo3);
            System.out.println(userInfo4);
    

    输出结果:
    在这里插入图片描述

    (4)转换类业务

    		Optional<Animal> userInfoOpt = Optional.of(new Animal("犬科动物","史努比",10));
    
            // 原来value的类型是UserInfo,经过map转换为Optional<String>
            Optional<String> username = userInfoOpt.map(Animal::getLb);
    
            // 当map的入参也是一个Optional时,经过map转化后会形成Optional<Optional<String>>这种嵌套结构;但flatMap可以把这种嵌套结构打平;
            Optional<Optional<String>> unFlatMap = userInfoOpt.map(animal -> Optional.of(animal.getLb()));
            Optional<String> flatMap = userInfoOpt.flatMap(animal -> Optional.of(animal.getLb()));
    
            System.out.println(username);
            System.out.println(unFlatMap);
            System.out.println(flatMap);
    

    输出结果:
    在这里插入图片描述

    6、项目业务API测试

    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import lombok.ToString;
    import java.math.BigDecimal;
    
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    @ToString
    public class Leader {
    
        private Long employeeId;
        private BigDecimal bonus;
    
    }
    
    
    
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import lombok.ToString;
    
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    @ToString
    public class Employee {
    
        private Long id;
        private String name;
        private Boolean leader;
    
    }
    
    
    
    
    
    
    import java.util.Optional;
     /**
         * 找到ID为1的员工,如果有奖金就打印出来,没有就打印没有奖金;
         * @throws
         */
    public class FiltUtil {
    
        public void OptionalStudy() {
            Optional<Leader> leader = Optional.ofNullable(getEmployeeById(1L)
                    .filter(Employee::getLeader)
                    .map(Employee::getId)
                    .flatMap(this::getLeaderByEmployeeId)
                    .orElse(null));
            if (leader.isPresent()) {
                Optional.of(leader.map(Leader::getBonus).map(bonus -> String.format("员工ID为1的leader奖金为:%s", bonus)).orElse("员工ID为1的leader也没有奖金")).ifPresent(System.out::println);
            } else {
                System.out.println("员工ID为1的leader未找到,他可能只是一个基层员工,不配拥有奖金");
            }
        }
    
        private Optional<Employee> getEmployeeById(Long id) {
            //return Optional.of(new Employee(1L, "大老板", Boolean.TRUE));
            return Optional.of(new Employee(1L, "大老板", Boolean.FALSE));
        }
    
        private Optional<Leader> getLeaderByEmployeeId(Long employeeId) {
            //return employeeId == 1L ? Optional.of(new Leader(1L, BigDecimal.valueOf(1000000000))) : Optional.empty();
            return employeeId == 1L ? Optional.of(new Leader(1L, null)) : Optional.empty();
        }
    
    //主函数测试
        public static void main(String[] args) {
            FiltUtil filtUtil = new FiltUtil();
            filtUtil.OptionalStudy();
    
        }
    }
    
    展开全文
  • Optional 详解 Java

    千次阅读 多人点赞 2021-04-13 10:36:41
    Optional的使用详解 1、Optional介绍 Optional 类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true,调用get()方法会返回该对象。 Optional 是个容器:它可以保存类型T的值,或者仅仅保存null。...
  • 告别 NPE,全网最全 Optional 实战理解

    千次阅读 2020-10-21 12:03:16
    之前,Google Guava项目曾提出用Optional类来包装对象从而解决NullPointerException。受此影响,JDK8的类中也引入了Optional类,在新版的SpringData Jpa和Spring Redis Data中都已实现了对该方法的支持。我们今天...
  • js代码-ES11的Optional Chaining示例代码。
  • java中Optional的使用

    千次阅读 多人点赞 2022-03-19 16:07:17
    使用Optional来规范我们的开发,让我们的Api更容易被他人理解。
  • jmxremote_optional-repackaged.jar 当遇到这样的错误时Unsupported protocol: jmxmp使用 将下载的架包放在jdk根目录下面的jre下面的ext下面,类似如下目录 D:\jdk1.7.0_71\jre\lib\ext
  • optional详解

    万次阅读 2019-09-19 10:59:15
    public class Test { public static void main(String[] args) { People people = new People();... Optional<People> p = Optional.ofNullable(people); String name = p.flatMap(People::getCa...
  • 前端开源库-optional-require可选要求,nodejs要求不使用try/catch就可以处理找不到模块的错误
  • 前端开源库-optional-tags可选标记,由HTML规范定义的“可选标记”数组。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 444,002
精华内容 177,600
关键字:

optional