Optional 近似代替三元表达式

int count=a.equal(b)?1:0 

上面的三元表达式 用Optional可以近似这样做：

public class TestTemp1 {
    String b;
    @Test
    public void test1(){
        String a="dd";
        b="dd";
        int count=Optional.ofNullable(a)
                .filter(x->x.equals(b))
                .map(x->1)
                .orElse(0);
        System.out.println(count);

        a="dd";
        b="";
        count=Optional.ofNullable(a)
                .filter(x->x.equals(b))
                .map(x->1)
                .orElse(0);
        System.out.println(count);

    }

}

 

说近似代替由于lamaba原因，变量b不能为局部变量，只能是类的全局变量。

 

这样看，三元表达式好简洁。 但是，当要考虑到a与b为null,三元表达式不简洁了。当a为n层属性时 又要考虑null处理，三元表达式直接泪奔！

下面例子，就是要要判 断第ｎ嵌套下的son的no属性 与变量b进行判断比较，然后相等为1否则为0.  

import java.util.Optional;

public class TestTemp2 {
    String b;
    @Test
    public void test1(){
        Entity root=new Entity("dd",
                        new Entity("dd1",
                                new Entity("dd2",
                                        new Entity("dd3",null)))
        );

        b="dd3";
        int count= Optional.ofNullable(root)
                .map(x->x.son)//从外开始第1层
                .map(x->x.son)//从外开始第2层
                .map(x->x.son)//从外开始第3层
                .filter(x->x.no.equals(b)) //对第3层的no属性进行判断过滤
                .map(x->1) //当符合上一步判 断 输出1
                .orElse(0);//当前面有null时 或条件不成立输出0
        System.out.println(count); //1



        b="dd3";
        count= Optional.ofNullable(root)
                .map(x->x.son)//从外开始第1层
                .map(x->x.son)//从外开始第2层
                .map(x->x.son)//从外开始第3层
                .map(x->x.son)//从外开始第4层
                .filter(x->x.no.equals(b)) //对第4层的no属性进行判断过滤
                .map(x->1) //当符合上一步判 断 输出1
                .orElse(0); //当前面有null时 或条件不成立输出0
        System.out.println(count); //0

        b="dd3";
        count= Optional.ofNullable(root)
                .map(x->x.son)//从外开始第1层
                .map(x->x.son)//从外开始第2层
                .map(x->x.son)//从外开始第3层
                .map(x->x.son)//从外开始第4层
                .map(x->x.son)//从外开始第5层
                .map(x->x.son)//从外开始第6层
                .filter(x->x.no.equals(b)) //对第6层的no属性进行判断过滤
                .map(x->1) //当符合上一步判 断 输出1
                .orElse(0); //当前面有null时 或条件不成立输出0
        System.out.println(count); //0

        b="dd3";
        root=null;
        count= Optional.ofNullable(root)
                .map(x->x.son)//从外开始第1层
                .map(x->x.son)//从外开始第2层
                .map(x->x.son)//从外开始第3层
                .map(x->x.son)//从外开始第4层
                .map(x->x.son)//从外开始第5层
                .map(x->x.son)//从外开始第6层
                .filter(x->x.no.equals(b))//对第6层的no属性进行判断过滤
                .map(x->1) //当符合上一步判 断 输出1
                .orElse(0); //当前面有null时 或条件不成立输出0
        System.out.println(count); //0
    }

    class Entity{
        private  String no;
        private Entity son;

        public Entity() {
        }

        public Entity(String no, Entity son) {
            this.no = no;
            this.son = son;
        }

        public String getNo() {
            return no;
        }

        public Entity getSon() {
            return son;
        }
    }
}

现在，还觉得option啰嗦吗？用三元表达式处理的小哥哥已经哭死在WC中了。