जावा 8 स्ट्रीम और लैम्बडास का उपयोग करते हुए पैरेंट तत्वों का जिक्र करते हुए लूप के लिए नेस्टेड को फिर से कैसे करें?

Question

मेरे पास कोड का नीचे का टुकड़ा है।

public static ModuleKey getDeployableModuleFromModulesList(List<Module> modules) { 
     ModuleKey deployableModuleKey = null; 
     for(Module module : modules) { 
      List<Artifact> artifacts = module.getArtifacts(); 
      for(Artifact artifact : artifacts) { 
       if(artifact.getType().equals("ear")) { 
        return module.getKey(); 
       } else if(!artifact.getType().equals("ear")) { 
        if(artifact.getType().equals("war")) { 
         deployableModuleKey = module.getKey(); 
        } 
       } 
      } 
     } 
     return deployableModuleKey; 
    } 

इस कोड कुंजी = 'कान' या कुंजी = 'युद्ध' के साथ पिछले एक के साथ पहली बार 'deployableModuleKey' पाता है। मैं जावा 8 स्ट्रीम और लैम्बडास का उपयोग कर उपर्युक्त कार्यक्षमता प्राप्त करना चाहता हूं।

अब तक मैं क्या करने की कोशिश की है:

modules.stream().flatMap(e -> e.getArtifacts().stream()) 
    .filter(e -> e.getType().equals("ear")).findFirst() 
    .orElseGet(() -> modules.stream().flatMap(e -> e.getArtifacts().stream()) 
    .filter(e -> e.getType().equals("war")).reduce((a, b) -> b).orElse(null)); 

ऊपर कोड स्निपेट प्रकार Artifact बजाय Module की एक वस्तु वापस आ जाएगी। मैं उस मॉड्यूल को प्राप्त करना चाहता हूं जहां आर्टिफैक्ट शर्तों से मेल खाता है। एक बार जब मैं मॉड्यूल पाता हूं तो मैं module.getKey() कर कर कुंजी वापस कर सकता हूं। ऐसा करने के लिए मैं जानना चाहता हूं कि हम लूप के लिए माता-पिता के तत्वों को कैसे संदर्भित करते हैं।

मुझे यकीन नहीं है कि मेरा जावा 8 कोड पूरी तरह से सही है या नहीं।
क्या कोई इस संबंध में मेरी सहायता कर सकता है?

Answer 1

मैंने अपनी समस्या का हल निकाला है।

public static ModuleKey getDeployableModuleFromModulesList(List<Module> modules) { 
    Optional<ModuleKey> op = modules.stream().filter(module -> module.getArtifacts().stream().anyMatch(artifact -> artifact.getType().equals("ear"))).map(module -> module.getKey()).findFirst(); 
    if (!op.isPresent()) { 
     op = modules.stream().filter(module -> module.getArtifacts().stream().anyMatch(artifact -> artifact.getType().equals("war"))).map(module -> module.getKey()).reduce((a, b) -> b); 
    } 
    return op.orElse(null); 
} 

वैसे भी, अन्य समाधान भी स्वागत है। अगर कोई दूसरा समाधान जोड़ता है, तो मैं उन सभी को आजमाउंगा।

Answer 2

स्ट्रीम के साथ बात यह है कि, जब आप filter या map जैसे मध्यवर्ती ऑपरेशन का उपयोग करके अपनी स्ट्रीम संशोधित कर लेते हैं, तो आप पिछले ऑपरेशन के मानों को वापस नहीं देख सकते हैं। तो आपको हमेशा अपनी स्ट्रीम में संदर्भित करने के लिए (Module) अपने मूल्य में संदर्भित करने के लिए वर्कअराउंड ढूंढना होगा। निम्नलिखित समाधान में, मैं anyMatch संचालन के साथ दो माध्यमिक धाराएं खोलता हूं, जो मॉड्यूल में एक आर्टिफैक्ट होता है जिसमें वांछित कुंजी होती है।

इस चाल करना चाहिए:

ModuleKey key = Optional.ofNullable(modules.stream().filter(m -> m.getArtifacts().stream() 
    .anyMatch(a -> a.equals("ear"))).findFirst().orElse(modules.stream() 
    .filter(m -> m.getArtifacts().stream().anyMatch(a -> a.equals("war"))) 
    .reduce((a, b) -> b).orElse(null))).map(Module::getKey).orElse(null); 

पहला तत्व खोजने के लिए, findFirst है, जो एक Optional<T> रिटर्न का उपयोग करें। हम OptionalOptional#orElse के साथ चेन करते हैं, जो इसे अनचाहे करता है और, यदि यह खाली है, तो एक और मूल्य लौटाता है (इस मामले में अंतिम तत्व खोजने के लिए reduce((a, b) -> b) का उपयोग करके)। यदि कुछ भी नहीं मिला है, तो हम नहीं चाहते हैं कि कोड NullPointerException फेंक दें। तो इससे पहले कि हम getKey विधि को कॉल करें, हम इसे में Optional.ofNullable के साथ लपेटें और orElse से null पर सेट करें, जो आपके कोड में निर्दिष्ट डिफ़ॉल्ट मान है।

एक तरफ ध्यान दें के रूप में,

else if(!artifact.getType().equals("ear")) { 
    if(artifact.getType().equals("war")) { 
    } 
} 

else if(artifact.getType.equals("war")) { 
} 

Answer 3

को कम किया जा सकता मुझे लगता है कि आप जानते हैं कि आपके पुराने जावा शैली कोड में अनावश्यक if जांच।

मैंने छोटे आसान-चंचल कार्यों में तोड़कर ऑपरेशन की अपनी बड़ी एकल धारा लिखी है जिसे कोई भी समझ जाएगा।

public static ModuleKey getDeployableModuleFromModulesList(List<Module> modules) { 

    return findEARKey(modules.stream()) 
      .orElse(findWARKey(modules.stream()).orElse(null)); 

} 

public static Optional<ModuleKey> findEARKey(Stream<Module> moduleStream){ 

    return moduleStream.flatMap(e -> e.getArtifacts().stream()) 
      .filter(e -> e.getType().equals("ear")) 
      .map(Artifact::getKey).findFirst(); 
} 

public static Optional<ModuleKey> findWARKey(Stream<Module> moduleStream){ 

    return moduleStream.flatMap(e -> e.getArtifacts().stream()) 
      .filter(e -> e.getType().equals("war")) 
      .map(Artifact::getKey).findFirst(); 
}