जावा 8 वैकल्पिक

Question

के साथ दोहराव प्राप्त स्टेटमेंट को प्रतिस्थापित करना मेरे पास एक उपयोग केस है, जहां मेरे पास कक्षाएं और शीर्ष श्रेणी का ऑब्जेक्ट है। मैं एक मूल्य प्राप्त करना चाहता हूं जो एनएच स्तर पर है। मैं एनपीई से बचने के लिए इसे प्राप्त करने के लिए दोबारा गेटर्स का उपयोग कर रहा हूं। नमूना कोड (यह मानते हुए ही टिककर खेल देखते हैं)

class A { 
    String a1; 
    String getA1() { 
     return a1; 
    } 
} 

class B { 
    A a; 
    A getA() { 
     return a; 
    } 
} 

class C { 
    B b; 
    B getB() { 
     return b; 
    } 
} 

class D { 
    C c; 
    C getC() { 
     return c; 
    } 
} 

अगर मैं वर्ग D का एक उद्देश्य d है, और A की String a1 प्राप्त करना चाहते हैं, क्या मैं कर रहा हूँ पीछा कर रहा है:

String getAValue(D d) { 
    String aValue = null; 
    if(d != null && d.getC() != null && d.getC().getB() != null && d.getC().getB().getA() != null) { 
     aValue = d.getC().getB().getA().getA1(); 
    } 
    return aValue; 
} 

यह दोहराव एक बदसूरत लग रहा है। Java8 वैकल्पिक का उपयोग करके मैं इसे कैसे टाल सकता हूं?

संपादित करें: मैं उपरोक्त कक्षाओं को संशोधित नहीं कर सकता। मान लें कि यह डी ऑब्जेक्ट मुझे सेवा कॉल के रूप में वापस कर दिया गया है। मैं केवल इन गेटर्स से अवगत हूं।

Answer 1

लपेटें एक वैकल्पिक में प्रत्येक नेस्टेड वर्ग:

Class A { 
    String a1; 
} 
Class B { 
    Optional<A> a; 
} 
Class C { 
    Optional<B> b; 
} 
Class D { 
    Optional<C> c; 
} 

फिर flatMap का उपयोग करें और इन वैकल्पिक मूल्यों पर काम करने के लिए नक्शे:

String a1 = d.flatMap(D::getC) // flatMap operates on Optional 
      .flatMap(C::getB) // flatMap also returns an Optional 
      .flatMap(B::getA) // that's why you can keep calling .flatMap() 
      .map(A::getA1) // unwrap the value of a1, if any 
      .orElse("Something went wrong.") // in case anything fails 

आप Monads की अवधारणा की जाँच कर सकते हैं। और यदि आप साहसी महसूस कर रहे हैं, Scala is too distant from Java। एक अच्छा एक लाइनर के लिए map() कॉल की एक श्रृंखला के साथ

Answer 2

उपयोग Optional:

String getAValue(D d) { 
    return Optional.ofNullable(d) 
     .map(D::getC).map(C::getB).map(B::getA).map(A::getA1).orElse(null); 
} 

यदि कुछ ही श्रृंखला के साथ null, d सहित है, orElse() निष्पादित करेंगे।