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);

    }

}

View Code

 

說近似代替因爲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;
        }
    }
}

View Code

如今，還以爲option囉嗦嗎？用三元表達式處理的小哥哥已經哭死在WC中了。