lambda कैसे एक ऑब्जेक्ट chained/cascaded वस्तुओं wsdl2java द्वारा उत्पन्न से प्राप्त करने के लिए वैकल्पिक और फिल्टर का उपयोग करने के लिए




java-8 stream (2)

Aominè सिफारिशों और वैकल्पिक के साथ नहीं बनाया cascaded वस्तुओं के साथ वैकल्पिक कैसे उपयोग के आधार पर चर्चा करने के लिए धन्यवाद

मैं इस समाधान पर पहुंचा:

Optional.ofNullable(onderneming.getNamen()).map(NamenOndernemingType::getCommercieleNamen)
                .map(NaamOndernemingLijstCommercieelType::getCommercieleNaam).get().stream().filter(Objects::nonNull)
                .filter(x -> x.getTaalcode().getValue() == "nl").findFirst()
                .ifPresent(o -> myMethod("onderneming_commerciele_naam", o.getNaam().getValue()));

मुझे समझ में आ रहा है कि जावा में पदानुक्रमित वस्तुओं के साथ काम करते समय फ्लैटमैप की सिफारिश की जाती है, खासकर जब एक्सएमएल फाइलों के बाहर बनाए गए ऑब्जेक्ट से मूल्य निकालने के लिए।

वैकल्पिक पर निर्भर Whithout और getCommercieleNaam () के बाद से मुझे एक सूची लाएगा, मैं कोडित:

NaamOndernemingLijstCommercieelType naamOndernemingLijstCommercieel = onderneming.getNamen()
        .getCommercieleNamen();
NaamOndernemingType naamOndernemingType = naamOndernemingLijstCommercieel.getCommercieleNaam().stream()
        .filter(x -> x.getTaalcode().getValue() == "nl").findFirst().get();

कुछ शब्दों में, यह कैसकेड ऑब्जेक्ट फेंक कर चल जाएगा और भाषा नीदरलैंड्स के लिए मिला पहला नाम वापस करेगा। मैं इसे बहुत ही असुरक्षित मानता हूं और यदि वे शून्य हैं तो सभी ऑब्जेक्ट्स को चेक करने के बजाय, मैं वैकल्पिक का उपयोग करना पसंद करता हूं।

फिर मैं कोड का प्रयास करता हूं जिसे मैं समझता हूं कि यह सही तरीका है, लेकिन मुझे यह पता नहीं है कि मानदंड से मेल खाने वाली सूची (केवल मेरे परिदृश्य में भाषा == "nl") से मिली वस्तु को प्राप्त करने के लिए फ़िल्टर कैसे लागू होता है:

    Optional<NamenOndernemingType> optionalNamenOnderneming = onderneming.getNamen(); 
    NaamOndernemingType naamOndernemingType = optionalNamenOnderneming.flatMap(NamenOndernemingType::getCommercieleNamen)
            .flatMap(NaamOndernemingLijstCommercieelType::getCommercieleNaam)
            .filter(x -> "nl".equals(x.toString()));

पीएस .: डच में, नाम का अर्थ है नाम (एकवचन) और नमन का अर्थ है नाम (बहुवचन)

ठीक है, निकटतम मुझे मिल गया था

    Optional<NamenOndernemingType> optionalNamenOnderneming = Optional.ofNullable(onderneming.getNamen());
    List<NaamOndernemingType> listNaamOndernemingType = optionalNamenOnderneming
            .flatMap(NamenOndernemingType::getCommercieleNamen)
            .map(NaamOndernemingLijstCommercieelType::getCommercieleNaam);

लेकिन यह न तो काम कर रहा है और इसे ठीक करने के बाद मुझे भी फ़िल्टर करना होगा।

* संपादित

@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "NamenOndernemingType", propOrder = {
    "maatschappelijkeNamen",
    "afgekorteNamen",
    "commercieleNamen"
})
public class NamenOndernemingType {

...

    public NaamOndernemingLijstCommercieelType getCommercieleNamen() {
        return commercieleNamen;
    }


@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "NaamOndernemingLijstCommercieelType", propOrder = {
    "commercieleNaam"
})
public class NaamOndernemingLijstCommercieelType {
...

    public List<NaamOndernemingType> getCommercieleNaam() {

* उपाय *

Optional.ofNullable(onderneming.getNamen()).map(NamenOndernemingType::getCommercieleNamen)
                .map(NaamOndernemingLijstCommercieelType::getCommercieleNaam).get().stream().filter(Objects::nonNull)
                .filter(x -> x.getTaalcode().getValue() == "nl").findFirst()
                .ifPresent(o -> myMethod("onderneming_commerciele_naam", o.getNaam().getValue()));

पीएस .: भविष्य के पाठकों के लिए मेरे खोज योग्य Iel के रूप में मेरा दूसरा प्रश्न पढ़ें: कैसे वैकल्पिक वैकल्पिक के साथ नहीं बनाया cascaded वस्तुओं के साथ वैकल्पिक का उपयोग करें


मुझे नहीं लगता कि आपको यहां एक मानचित्र की आवश्यकता है जिसे आपने कहा है कि getCommercieleNaam एक List<NaamOndernemingType> इसलिए एक बार जब हम समतल करते हैं कि हमारे पास एक Stream<NaamOndernemingType> होगा तो Stream<NaamOndernemingType> जो हम सभी वस्तुओं को "nl" रूप में पा सकते हैं उनके स्ट्रिंग का प्रतिनिधित्व

List<NaamOndernemingType> listNaamOndernemingType = optionalNamenOnderneming
           .flatMap(NaamOndernemingLijstCommercieelType::getCommercieleNaam)              
           .filter(Objects::nonNull)
           .filter(x -> "nl".equals(x.toString()))
           .orElse(null);

यह देखते हुए कि एक Optional एक टर्मिनल ऑपरेशन के रूप में collect नहीं किया जाता है, यदि हम मौजूद हैं तो मूल्य वापस करने के लिए orElse बस इसका उपयोग कर सकते हैं, अन्यथा null वापसी करें। इस मामले में मान एक List<NaamOndernemingType>

ध्यान दें - यदि आप Stream<Stream<R>> करना चाहते हैं तो आपको केवल फ्लैटमैप को कॉल करने की आवश्यकता होगी Stream<Stream<R>> To Stream<T> अन्यथा आप बस एक कॉल करना चाहते हैं जो कि एक Stream<R> वापस आएगा





optional