java中Optional的应用,以及map和flatMap的区别

关于Option的介绍可以看深入理解java8中的Optional 类就可以了,但是复杂一点的使用在网上却没有搜到,这里结合我开发时遇到的真实案例来讲一下Option的使用。

1.案例一

        在真实业务操作过程中,都是对象里面套对象,这边先简单定义操作对象:

public class PictureCondition {
    private String url;

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

}

       在这里先一个简单的对象,里面也就只有一个属性,在Controller层需要接收一个PictureCondition的对象,应判断这个对象里面的url属性是否为空,或者是有空格出现,如果有的话,则抛出一个异常。

      使用一般的写法是这样判断的:

if(pictureCondition==null||pictureCondition.getUrl()==null||"".equals(pictureCondition.getUrl().trim())){
            throw new RuntimeException("出错啦");
 }

      使用Option的写法是这样的:

Optional.ofNullable(pictureCondition)
                .map(PictureCondition::getUrl)
                .map(String::trim)
                .filter(x -> !"".equals(x))
                .orElseThrow(() -> new RuntimeException("出错啦"));

      对于单层循环使用一般的写法还是可以应对的,但是当层数比较多时,这样写就不太好了。

2.案例二

先定义操作对象

1.定义User对象

public class User {
    //用户名称
    private String username;

    //当前用户的订单信息
    private List<Order> orders;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public List<Order> getOrders() {
        return orders;
    }

    public void setOrders(List<Order> orders) {
        this.orders = orders;
    }
}

2.定义订单对象

public class Order {
    //订单id
    private Long orderId;

    //订单时间
    private Date createTime;

    public Long getOrderId() {
        return orderId;
    }

    public void setOrderId(Long orderId) {
        this.orderId = orderId;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }
}

具体场景:

        当在一个方法里面需要拿到user对象(可能为空)里面是的orders对象,如果当前orders对象为空,则返回一个空的list对象。

写法:

        Java8之前的写法,我们需要先判断user对象是否为null,不为空的话,获取当orders对象是否为空,为空则返回一个空的list

if(user!=null && user.getOrders!=null) {
  return user.getOrders();
} else {
  return Collections.emptyList();
}

        使用Java8的写法,那么就不需要这样判断了,直接看代码:

return Optional.ofNullable(user)
        .map(u -> u.getOrders())
        .orElse(Collections.emptyList())
 

扩展思考:

        Optional.map 是可以无限级联的, 比如再深一层, 获得用户名的大写形式

return Optional.ofNullable(user)
           .map(u -> u.getUsername())
           .map(name -> name.toUpperCase())
           .orElse(null);

这要搁在以前, 每一级调用的展开都需要放一个 null 值的判断

User user = .....
if(user != null) {
  String name = user.getUsername();
  if(name != null) {
    return name.toUpperCase();
  } else {
    return null;
  }
} else {
  return null;
}

3.Optional中的map和flatMap的区别

源码:

map会将传入的Function函数的结果进行封装,先看源码:

    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的ofNullable方法包装Function函数返回的值
        }
    }

flatMap会直接返回Function函数执行的结果,看源码:

    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));//直接返回Function执行的结果
        }
    }

      这样看,好像也看不出来两者太大的区别,不知道什么时候用map,什么时候用flatMap,通过下面的案例进行具体分析

map和flatMap的用法区别

首先对于下列对象的操作

public class School {
    private String name;
    private Optional<Tearch> tearch;  //属性为Option封装的Tearch对象

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Optional<Tearch> getTearch() {
        return tearch;
    }

    public void setTearch(Optional<Tearch> tearch) {
        this.tearch = tearch;
    }
}

class Tearch{
    private String name;
    private Optional<Student> student;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Optional<Student> getStudent() {
        return student;
    }

    public void setStudent(Optional<Student> student) {
        this.student = student;
    }
}

class Student{
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

   这时,如果给你一个School对象,让你得到Student的name属性的值,可以使用下面的方式:

public static String getStudentName(School school){
        return Optional.ofNullable(school)
                .map(School::getTearch)
                .map(Tearch::getStudent)
                .map(Student::getName)
                .orElse("false");
    }

 你可能感觉这样写很对啊,没毛病,可惜这段代码连编译都不会通过的,我们思考一下,School::getTearch会返回School实例的tearch属性,而tearch属性是使用Optional包装的Tearch对象,所以使用了map(School::getTearch),会返回Optional<Optional<Tearch>>对象,而不是我们所想的Optional<Tearch>,这是你可能想自己试一下,我已经做了截图,毕竟有图有真相。

20191119203530875.png

2019111920380750.png

这时就可以使用flatMap来解决这个问题,刚才已经说了,flatMap不会使用Optional包装Function执行的返回结果,所以我们可以使用flatMap来解决这个问题。

    public static String getStudentName(School school){
        return Optional.ofNullable(school)
                .flatMap(School::getTearch)
                .flatMap(Tearch::getStudent)
                .map(Student::getName).orElse("false");
    }

看截图:

20191119204122472.png

       这时map和flatMap的用法就清楚,如果某对象实例的属性本身就为Optional包装过的类型,那么就要使用flatMap方法,就像School::getTearch返回的就是Optional<Tearch>类型的,所以不用再使用Optional进行包装,这时就要选用flatMap方法,对于返回值是其他类型,需要Optional进行包装,如Student::getName得到是String类型的,就需要使用map方法在其外面包装一层Optional对象。

注意:Option类是判断空指针异常时用的,对于其他的if..else只要不是判断空指针的问题,就不要使用Option类,lz就陷入了一个误区,以为学了Option类,看见if...else就往Option来想,这么做真是大作特错。用Option的情况时在判断值是否为null时,Option就发挥作用了。

评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值