Java8 Optional类的使用

一、简介

　　Optional 是一个对象容器，具有以下两个特点：

　　　　1. 提示用户要注意该对象有可能为null
　　　　2. 简化if else代码

　　真正体现Optional“有效避免空指针异常”是其ifPresent()、orElse()、orElseGet()以及orElseThrow()这几个方法。

二、使用介绍

　　1. 创建：
　　　　Optional.empty()： 创建一个空的 Optional 实例

　　　　Optional.of(T t)：创建一个 Optional 实例，当 t为null时抛出异常

　　　　Optional.ofNullable(T t)：创建一个 Optional 实例，但当 t为null时不会抛出异常，而是返回一个空的实例

　　2. 获取：
　　　　get()：获取optional实例中的对象，当optional 容器为空时报错

　　3. 判断：
　　　　isPresent()：判断optional是否为空，如果空则返回false，否则返回true

　　　　ifPresent(Consumer c)：如果optional不为空，则将optional中的对象传给Comsumer函数

　　　　orElse(T other)：如果optional不为空，则返回optional中的对象；如果为null，则返回 other 这个默认值

　　　　orElseGet(Supplier<T> other)：如果optional不为空，则返回optional中的对象；如果为null，则使用Supplier函数生成默认值other

　　　　orElseThrow(Supplier<X> exception)：如果optional不为空，则返回optional中的对象；如果为null，则抛出Supplier函数生成的异常

　　4. 过滤：
　　　　filter(Predicate<T> p)：如果optional不为空，则执行断言函数p，如果p的结果为true，则返回原本的optional，否则返回空的optional

　　5. 映射：
　　　　map(Function<T, U> mapper)：如果optional不为空，则将optional中的对象 t 映射成另外一个对象 u，并将 u 存放到一个新的optional容器中。

　　　　flatMap(Function< T,Optional<U>> mapper)：跟上面一样，在optional不为空的情况下，将对象t映射成另外一个optional

　　　　区别：map会自动将u放到optional中，而flatMap则需要手动给u创建一个optional

三、Demo应用

需求：

学校想从一批学生中，选出年龄大于等于18，参加过考试并且成绩大于80的人去参加比赛。

准备数据：

public class Student {
private String name;
private int age;
private Integer score;

//省略 construct get set
}

public List<Student> initData(){
Student s1 = new Student("张三", 19, 80);
Student s2 = new Student("李四", 19, 50);
Student s3 = new Student("王五", 23, null);
Student s4 = new Student("赵六", 16, 90);
Student s5 = new Student("钱七", 18, 99);
Student s6 = new Student("孙八", 20, 40);
Student s7 = new Student("吴九", 21, 88);

return Arrays.asList(s1, s2, s3, s4, s5, s6, s7);
}

java8 之前写法：

@Test
public void beforeJava8() {
    List<Student> studentList = initData();
    for (Student student : studentList) {
        if (student != null) {
            if (student.getAge() >= 18) {
                Integer score = student.getScore();
                if (score != null && score > 80) {
                    System.out.println("入选：" + student.getName());
                }
            }
        }
    }
}

java8 写法：

@Test
public void useJava8() {
    List<Student> studentList = initData();
    for (Student student : studentList) {
        Optional<Student> studentOptional = Optional.of(student);
        Integer score = studentOptional.filter(s -> s.getAge() >= 18).map(Student::getScore).orElse(0);
 
        if (score > 80) {
            System.out.println("入选：" + student.getName());
        }
    }
}

实战演练代码重构

这么说比较抽象，我么结合具体的项目代码看一看，例如，前台发起请求，传来一个报警参数，后台提取报警的ID，去数据库中查询对应ID的报警事件，并且获取该报警事件的名字和类型。我们来看看实现这个需求，传统的JAVA7的代码会怎么写：

public String test0(AlarmAllParmeter alarmAllParmeter) {
        String errorResult = "";
        if (null != alarmAllParmeter) {
            Integer alarmId = alarmAllParmeter.getAlarmEventInputId();
            if (null != alarmId) {
                AlarmEventInput alarmEventInput = alarmEventInputService.get(alarmId);
                if (null != alarmEventInput) {
                    String alarmName = alarmEventInput.getAlarmName();
                    int alarmType = alarmEventInput.getAlarmType();
                    return String.valueOf(alarmType) + "-" + alarmName;
                } else {
                    return errorResult;
                }
            } else {
                return errorResult;
            }
        } else {
            return errorResult;
        }
    }

 

可以明显看出，为了防止空指针异常，我们在代码中写了大量的if(null != T)的模板代码。而初次学习Optional类的朋友很可能会写出如下代码：

public String test1(AlarmAllParmeter alarmAllParmeter){
        String errorResult = "";
        Optional<AlarmAllParmeter> op = Optional.ofNullable(alarmAllParmeter);
        if(op.isPresent()){
            Integer alarmId = op.get().getAlarmEventInputId();
            Optional<Integer> op1 = Optional.ofNullable(alarmId);
            if(op1.isPresent()){
                AlarmEventInput alarmEventInput = alarmEventInputService.get(op1.get());
                Optional<AlarmEventInput> op2 = Optional.ofNullable(alarmEventInput);
                if (op2.isPresent()) {
                    String alarmName = alarmEventInput.getAlarmName();
                    int alarmType = alarmEventInput.getAlarmType();
                    return String.valueOf(alarmType) + "-" + alarmName;
                } else {
                    return errorResult;
                }
            }
            else {
                return errorResult;
            }
        }
        else {
            return errorResult;
        }
    }

可以看出，其编程的思路还是停留在“命令式编程”的层面，这种强行用Optional类的做法反而显得多此一举，本质上和传统写模板代码一样，真的就只是给对象套了个Optional容器而已。接下来，我们用Optional正确的打开方式来实现这个需求，重构最初的代码：

public String test2(AlarmAllParmeter alarmAllParmeter){
        return Optional.ofNullable(alarmAllParmeter)
                       .map(a -> a.getAlarmEventInputId())
                       .map(a -> alarmEventInputService.get(a))
                       .map(a -> String.valueOf(a.getAlarmType())+"-"+a.getAlarmName())
                       .orElse("");
}

最终通过Junit4测试结果如下：

public class OptionalTestTest {
 
    AlarmAllParmeter alarmAllParmeter = new AlarmAllParmeter();
    @Before
    public void setAlarmAllParmeter(){
        alarmAllParmeter.setAlarmEventInputId(1001);
    }
 
    @Test
    public void test0() {
        System.out.println("Test0 is: "+new OptionalTest().test0(alarmAllParmeter));
    }
 
    @Test
    public void test1() {
        System.out.println("Test1 is: "+new OptionalTest().test1(alarmAllParmeter));
    }
 
    @Test
    public void test2() {
        System.out.println("Test2 is: "+new OptionalTest().test2(alarmAllParmeter));
    }
}

控制台输出结果一致————
Test0 is: 1-测试报警实体
Test1 is: 1-测试报警实体
Test2 is: 1-测试报警实体

最后，再次强调一下，这一篇文章所提到的Optional的正确使用方式是进行链式处理，而不应该像不少网文所说的那样去做isPresent()判断，再去get()取值。
————————————————
版权声明：本文为CSDN博主「luckykapok918」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/luckykapok918/article/details/106239526