文档章节

java8-Optional类

春天springcarter
 春天springcarter
发布于 11/17 23:15
字数 2306
阅读 25
收藏 1

【推荐】2019 Java 开发者跳槽指南.pdf(吐血整理) >>>

背景

NPE问题,100%的Java程序员都碰到,并且曾经是心中的痛。 1965年英国TonyHoare引入了Null引用,后续的设计语言包括Java都保持了这种设计。

一个例子

业务模型

Person 有车一族, 有Car字段,

Car 车,每个车都有购买保险, 有Insurance字段;

Insurance 保险,每个保险都有名字 有name字段;

需求:获取某个Person对象的购买保险的名称;


常规编程

    public String getCarInsuranceName(Person person) {
        return person.getCar().getInsurance().getName();
    }

检查式编程

 public String getCarInsuranceName_check(Person person) {
        if (Objects.nonNull(person)) {
            final Car car = person.getCar();
            if (Objects.nonNull(car)) {
                final Insurance insurance = car.getInsurance();
                if (Objects.nonNull(insurance)) {
                    return insurance.getName();
                }
            }
        }
        return "unkown";
    }

防御式编程

public String getCarInsuranceName_protect(Person person) {
        if (Objects.isNull(person)) {
            return "unkown";
        }
        final Car car = person.getCar();
        if (Objects.isNull(car)) {
            return "unkown";
        }
        final Insurance insurance = car.getInsurance();
        if (Objects.isNull(insurance)) {
            return "unkown";
        }
        return insurance.getName();
    }

对比一下缺点:

编程方法 缺点
常规编程 NPE问题
检查式编程 1.可读性不好,多层if嵌套; 2.扩展性不好,需要熟悉全流程,否则不知道应该在哪个if中扩展,极易出错;
防御式编程 1. 维护困难,4个不同的退出点,极易出错,容易遗漏检查项目

NPE的痛点

  1. java程序中出现最多的Exception;没有之一;
  2. 使得代码量膨胀混乱,对象的空判断充斥在代码中,但是却没有实际的业务意义;
  3. 类型系统的一个后门,实际上不属于任何类型,也可以说是任何类型;
  4. 本身无意义,标识对缺失值的建模,也破坏了java中弱化指针的理念。

java8中对缺失值的建模对象是Optional,可以基于它解决NPE的痛点,设计更好的API

Optional

领域模型的建模进化

  1. Person , 含有一个Optional<Car> car字段,一个人可能有车,也可能没有车;
  2. Car, 包含有一个Optional<Insurance> insurance字段, 一台车可能买了保险,也可能没有买保险;
  3. Insurance , 保险公司必定有名字所有,他有一个字段 name;

构造方法

构造方法 说明 备注
Optional.empty() 一定是空的对象 跟null有区别,是一个单例对象
Optional.of(T t) 一定是不空的对象 如果给了null值会立刻抛出NPE
Optioanl.ofNullable(T t) 允许为空的对象放在里面 使用值之前需要做检查

map方法-对象中提取和转换值

可以把Optional看成一种单元素的Stream, Map,即把其中的元素按照一定规则转换为其它类型或者进行其它运算后的值,如果没有元素,则啥也不做。

下面的代码是等同的。

public class Test {
    public static final String UNKNOWN = "unknown";
    /**
     * 传统方法
     * @param insurance
     * @return
     */
    public static String getInsuranceName(Insurance insurance){
        if (Objects.isNull(insurance)){
            return UNKNOWN;
        }
        return insurance.getName();
    }
    /**
     * map的方式提取
     * @param insurance
     * @return
     */
    public static String getInsuranceNameOp(Insurance insurance){
       return Optional.ofNullable(insurance).map(Insurance::getName).orElse(UNKNOWN);
    }
}

flatMap方法 - 转换为Optional对象输出;

类似于Stream的flatMap方法,把元素切割或者组合成另外一个流输出。

    public static String getInsuranceName(Person person) {
        return Optional.ofNullable(person)
                .flatMap(Person::getCar)
                .flatMap(Car::getInsurance)
                .map(Insurance::getName).orElse(UNKNOWN);
    }

默认值设置方法(5种适合不同的场景)

默认值方法 说明 场景
or(Supplier<Optional>) 为空则延迟构造一个Optional对象 可以采用延迟的方式,对接某些代码来产生默认值
orElse(T t) 为空则采用默认值 直接,简单
orElseGet(Supplier<T> sp) 为空则通过函数返回 延迟返回,可以对接某些代码逻辑
orElseThrow() 为空则跑出异常 默认是NoSuchElementException
orElseThrow(Supplier<Throwable> sp) 为空则跑出自定义异常 异常类型可以自定义

使用值(获取或者消费)

主要分两种场景,直接获取值, 采用get()方法;

里面有值,则消费, ifPresent(Consumer<T> c)

消费或者获取方法 说明 场景
get() 获取Optional中的值,如果没有值,会抛出异常 确认里面有值才会调用该防范
ifPresent(Consumer<T> c) 有值则执行自定义代码段,消费该值 流式编程,有值继续处理逻辑
ifPresentOrElse(Consumer<T> c , Runnable r) 如果有值,则消费,没有值,进行另外的处理 有值或者没有值都进行处理java9才有

多个Optional进行运算

通过使用flatMap,map可以做到,方法里执行的已经做好了对empty的情况进行处理。

实例如下:



    public static String getCheapestPrizeIsuranceNameOp(Person person, Car car) {
        return Optional.ofNullable(person)
                .flatMap(p -> Optional.ofNullable(car).map(c -> getCheapest(p, c)))
                .orElse(UNKNOWN);
    }

    public static String getCheapestPrizeIsuranceName(Person person, Car car) {
        if (Objects.nonNull(person) && Objects.nonNull(car)) {
            return getCheapest(person, car);
        }
        return UNKNOWN;
    }

    /**
     * 模拟得到最便宜的保险
     *
     * @param person 人
     * @param car    车
     * @return 最便宜的车险名称
     */
    private static String getCheapest(Person person, Car car) {
        return "pinan";
    }

filter方法 (过滤)

因为Optional中只有一个值,所以这里的filter实际上是判断单个值是不是。

对比代码:

    public static Insurance getPinanInsurance(Person person){
        Optional<Insurance> insuranceOptional = Optional.ofNullable(person).map(Person::getCar).map(Car::getInsurance);
        if (insuranceOptional.isPresent() &&  Objects.equals("pinan", insuranceOptional.get().getName())){
            return insuranceOptional.get();
        }
        return null;
    }

    public static Insurance getPinanInsurance_filter(Person person){
        return Optional.ofNullable(person)
                .map(Person::getCar)
                .map(Car::getInsurance)
                .filter(item->Objects.equals(item.getName(),"pinan" ))
                .orElse(null);
    }

empty方法 (构造一个空的Optional对象)


Optional改造历史代码

封装可能潜在为null的对象


    public Object getFromMap(String key){

        Map<String,Object> map = new HashMap<>(4);
        map.put("a", "aaa");
        map.put("b", "bbb");
        map.put("c", "ccc");

        Object value = map.get(key);
        if (Objects.isNull(value)){
            throw new NoSuchElementException("不存在key");
        }
        return value;

    }


    public Object getFromMapOp(String key){

        Map<String,Object> map = new HashMap<>(4);
        map.put("a", "aaa");
        map.put("b", "bbb");
        map.put("c", "ccc");

        Object value = map.get(key);

        return Optional.ofNullable(value).orElseThrow(()->new NoSuchElementException("不存在key"));
    }

发生异常的建模可以替换为Optional对象

这种是建模思想的转变,不一定适用每个人;

 /**
     * 如果字符串不是数字,会抛出异常
     * @param a 字符串
     * @return 数字
     */
    public Integer string2Int(String a){
        return Integer.parseInt(a);
    }

    /**
     * Optional.empty对应异常的情况,后续比较好处理;
     * @param a 字符串
     * @return 可能转换失败的整数,延迟到使用方去处理
     */
    public Optional<Integer> string2Int_op(String a){
        try{
            return Optional.of(Integer.parseInt(a));
        }catch (Exception ex){
            return Optional.empty();
        }
    }

尽量不使用封装的Optional

封装的OptionalInt, OptionalLong ,因为Optional里面只有一个元素,使用封装类没有性能优势,而且缺失了重要的flatMap, map,filter方法;

总的来说,Optional的使用,简化了代码,使得代码可读性和可维护性更好。

最后来个例子:


    public Integer getFromProperties(Properties properties, String key) {
        String value = properties.getProperty(key);
        if (Objects.nonNull(value)) {
            try {
                Integer integer = Integer.parseInt(value);
                if (integer > 0) {
                    return integer;
                }
            } catch (Exception ex) {
                //无需处理异常
                return 0;
            }
        }
        return 0;
    }


    public Integer getFromProperties_op(Properties properties, String key) {
        return Optional.ofNullable(properties.getProperty(key))
                .map(item -> {
                    try {
                        return Integer.parseInt(item);
                    } catch (Exception ex) {
                        return 0;
                    }
                })
                .orElse(0);
    }

Optional源码阅读

一个容器对象,可能有也可能没有非空值,如果值存在,isPresent()返回true,如果没有值,则对象被当成空,isPresent()返回false;
更多的方法依赖于容器中是否含有值,比如orElse(返回一个默认值当没有值)
ifPresent(Consumer c) 是当值存在的时候,执行一个动作;

这是一个基于值的类,使用标识敏感的操作,包含 比较引用的 == , hashcode , synchronization  针对一个Optional对象,可能有无法预料的结果,然后应该避免这类操作。

编写API的注意点:
Optional最初被用来设计为方法的返回值,当明确需要代表没有值的情况。
返回null,可能出错;而返回Optional对象不是一个null对象,它总是指向一个Optional对象实例。
/**
 * A container object which may or may not contain a non-{@code null} value.
 * If a value is present, {@code isPresent()} returns {@code true}. If no
 * value is present, the object is considered <i>empty</i> and
 * {@code isPresent()} returns {@code false}.
 *
 * <p>Additional methods that depend on the presence or absence of a contained
 * value are provided, such as {@link #orElse(Object) orElse()}
 * (returns a default value if no value is present) and
 * {@link #ifPresent(Consumer) ifPresent()} (performs an
 * action if a value is present).
 *
 * <p>This is a <a href="../lang/doc-files/ValueBased.html">value-based</a>
 * class; use of identity-sensitive operations (including reference equality
 * ({@code ==}), identity hash code, or synchronization) on instances of
 * {@code Optional} may have unpredictable results and should be avoided.
 *
 * @apiNote
 * {@code Optional} is primarily intended for use as a method return type where
 * there is a clear need to represent "no result," and where using {@code null}
 * is likely to cause errors. A variable whose type is {@code Optional} should
 * never itself be {@code null}; it should always point to an {@code Optional}
 * instance.
 *
 * @param <T> the type of value
 * @since 1.8
 */

其它的代码比较简单,模型就是里面含有一个T类型的值,empty()是一个特殊的Optional对象,里面的值是null;

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
     */
    private final T value;

    /**
     * Constructs an empty instance.
     *
     * @implNote Generally only one empty instance, {@link Optional#EMPTY},
     * should exist per VM.
     */
    private Optional() {
        this.value = null;
    }

小结

  1. Optional表示一个可能缺失的对象,API可以依据这个进行建模,但是要注意序列化的问题;可以避免空指针的问题,并且提升代码的可读性和可维护性。
  2. Optional的构造方法有3个,of,ofNullable,empty;
  3. map,flatmap , filter 可以快速的转换和过滤值;
  4. 值缺失的处理方法有3个,orElse, orElseGet, orElseThrow;

原创不易,转载请注明出处。

© 著作权归作者所有

春天springcarter
粉丝 0
博文 27
码字总数 32823
作品 0
深圳
私信 提问
java8 -函数式编程之Optional

前言 在某些情况下,首先要判断某个参数或者某个方法的返回值是否为null,才能继续操作该参数。对于某些链式操作需要多次通过if语句判断是否为空,才能确保不抛出NullPointerException,这段...

细肉云吞
2018/12/24
270
1
Java系列 – 用Java8新特性进行Java开发太爽了(续)

本人博客文章网址:https://www.peretang.com/using-java8s-new-features-to-coding-is-awesome-2/ 前言 上周, 我们谈论了关于Java8的新特性有那些, 什么是函数式编程, 什么是Lambda表达式, 这...

PereTang
2017/07/18
0
0
序列化禁止使用Optional

1: 概论 Optional 是Java8用来改变java引发NPE的解决办法,但是不是绝对的解决办法 2: 例子: 很多博文一上来就给力以下使用例子 1 @Data2 public class User {3 private String name;4 privat...

---dgw博客
10/29
0
0
JAVA8之妙用Optional解决判断Null为空的问题

引言 在文章的开头,先说下NPE问题,NPE问题就是,我们在开发中经常碰到的NullPointerException.假设我们有两个类,他们的UML类图如下图所示 在这种情况下,有如下代码 user.getAddress().ge...

夜黑人模糊灬
11/06
166
2
Java8新特性之:Optional

一. 用Optional取代null 1. Optional类 java.util.Optional是一个封装Optional值的类。 变量存在时,Optional类只是对类进行简单的封装。变量不存在时,缺失的值会被建模成一个“空”的Optio...

Turnsole1
2018/05/27
0
0

没有更多内容

加载失败,请刷新页面

加载更多

阿里巴巴的 Kubernetes 应用管理实践经验与教训

作者 | 孙健波(天元) 阿里巴巴技术专家 导读:本文整理自孙健波在 ArchSummit 大会 2019 北京站演讲稿记录。首先介绍了阿里巴巴基于 Kubernetes 项目进行大规模应用实践过程中遇到的问题;...

阿里巴巴云原生
8分钟前
2
0
pinpoint采样原理分析

使用pinpoint进行全链路监控时,支持对请求的采样,某条请求是否被采样,取决于整个链路开始的机器。该机器使用特定的采样算法。采样的标志会一直在链路中透传。比如在http里面,会在header里...

xiaomin0322
13分钟前
2
0
在IDEA开发工具中使用lombok

1. 首先我们需要安装IntelliJ IDEA中的lombok插件,打开IntelliJ IDEA后点击菜单栏中的File-->Settings,或者使用快捷键Ctrl+Alt+S进入到设置页面 我们点击设置中的Plugins进行插件的安装,在...

欧阳飘
14分钟前
2
0
爱码仕 5G生活畅想 (五) 每个人每个家庭都有一朵私有的云

30年前,微软让每个家庭都有一台电脑的理念成为了现实;而今云计算的观念已为老百姓们所熟识。数据就是能源;数据就是财富;谁生产了数据,这数据的所有权就归谁所有。随着原生云基础设施的完...

LitStone
16分钟前
3
0
嵌入式入门:嵌入式领域的职业发展方向是什么?

嵌入式入门:嵌入式领域的职业发展方向是什么? 在如今的IT市场上看,嵌入式的发展的应用都是广受欢迎的,在嵌入式入门学习中,我们可以发现嵌入式的发展方向有很多,门槛高低不一样。下面就...

xyd118
16分钟前
3
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部