java8 optional的简单操作_rhyme-编程思维

我们经常会遇到这种情况:首先判断一个对象是否为null,如果不为null,获取一个对象中的一个属性,如果该属性不为null,又获取该属性的属性,如果该属性的属性不为null,又获取属性的属性的属性;

使用Java8中类Optional优雅解决

 

例子

一个pojo类;

该类有两个属性,有个属性Project是对象,Project也有属性是DiscoverCenter也是对象,DiscoverCenter中有String属性discoverName;

build方法初始化一个Org对象,并给其属性赋值。

import lombok.Data;

@Data
public class Org {
    private String name;
    private Project project;

    @Data
    public static class Project {
        private DiscoverCenter discoverCenter;
    }

    @Data
    public static class DiscoverCenter {
        private String discoverName;
    }

    public static Org build(String name,String discoverName){
        DiscoverCenter discoverCenter = new DiscoverCenter();
        discoverCenter.setDiscoverName(discoverName);

        Project project = new Project();
        project.setDiscoverCenter(discoverCenter);

        Org org = new Org();
        org.setProject(project);
        org.setName(name);

        return org;
    }

    private Org(){}
}

 

现在我们要做的事情是获得嵌套对象最内层的属性String discoverName;

先初始化:

public class TestJava8Optional {
    private Org org;
    @Before
    public void init(){
        org = Org.build("Alibaba", "Nacos");
    }

 

用最常规的if-else方式,逐层判断其属性,不为null,才继续获取属性:

@Test
    public void ifElse(){
        if (null != org){
            Org.Project project = org.getProject();
            if(null != project){
                Org.DiscoverCenter discoverCenter = project.getDiscoverCenter();
                if(null != discoverCenter){
                    String discoverName = discoverCenter.getDiscoverName();
                    System.out.println(discoverName);
                    return;
                }
            }
        }

        throw new IllegalArgumentException("Invalid Object.");

    }

 

 

用Java8 Optional类来处理,先判断org不为null,然后在判断它的属性project,继续逐层判断……

@Test
    public void testNestedObject(){

        String s = Optional.ofNullable(org)
                .map(o -> o.getProject())
                .map(p -> p.getDiscoverCenter())
                .map(d -> d.getDiscoverName())
                .orElseThrow(() -> new IllegalArgumentException("Invalid Object."));
        System.out.println(s);
    }

 

是不是比上面的if-else看起来更加简洁和清晰;

Optional.ofNullable方法是可以接受null值的,Optional的map()函数返回的Optional的泛型是map函数中lambda表达式返回的对象类型,orElseThrow()函数表示如果其中上面一个map函数中的lambda表达式,就抛出的异常。

 

下面对一个嵌套的Map对象获取最内层的value:

/**
     * 获取嵌套最内部的value
     */
    @Test
    public void testNestedMap(){
        Map<String,Object> map = new HashMap<>();
        Map<String,Object> project = new HashMap<>();
        project.put("Nacos","discover");

        Map<String,Object> alibaba = new HashMap<>();
        alibaba.put("project",project);

        Map<String,Object> org = new HashMap<>();
        org.put("alibaba",alibaba);

        map.put("org",org);
        Object o1 = Optional.ofNullable(map)
                .map(m -> m.get("org"))
                .map(o -> ((Map) o).get("alibaba"))
                .map(a -> ((Map) a).get("project"))
                .map(p -> ((Map) p).get("Nacos"))
                .orElse("default value");

        System.out.println(o1);
    }

 

版权声明:本文版权归作者所有,遵循 CC 4.0 BY-SA 许可协议, 转载请注明原文链接
https://www.cnblogs.com/theRhyme/p/10345152.html

建造者模式_rhyme-编程思维

建造者模式可以将部件和其组装过程分开,一步一步创建一个复杂的对象。用户只需要指定复杂对象的类型就可以得到该对象,而无须知道其内部的具体构造细节.   建造者模式(Builder Pattern) 又名生成器模式,是一种对象构建模式。它可以将复杂对象的建造过程抽象出来(抽象类别),使这个抽象过程的不同实现方法可以构造出不

建造者模式_rhyme-编程思维

建造者模式可以将部件和其组装过程分开,一步一步创建一个复杂的对象。用户只需要指定复杂对象的类型就可以得到该对象,而无须知道其内部的具体构造细节.   建造者模式(Builder Pattern) 又名生成器模式,是一种对象构建模式。它可以将复杂对象的建造过程抽象出来(抽象类别),使这个抽象过程的不同实现方法可以构造出不

戏说前端 javascript 之『防抖节流』基础知识 - 编程思维

往事不堪回首犹记在很久之前的某次面试中,和那技术大哥谈的正欢呢,冷不防他来了句:谈一谈防抖和节流吧。抹了把凉汗,我用颤抖的、不自信的语气回答道:呃,防抖就是应该是防止抖动的意思,节流大概是节省流量吧……当时,我的心理活动是这样的:当年心理素质是真的差,这个坎没翻过去,最后的结果就是:知耻而后勇以我不服输的性格,这场子必