जावा 8 स्ट्रीम

Question

का उपयोग करके किसी सूची से केवल आवश्यक वस्तुओं को प्राप्त करना क्लास attrib1, attrib2 और List<Child> बच्चे को इसके संबंधित गेटर्स और सेटर्स के साथ मानें।

Child एक अन्य वर्ग है जिसमें पांच गुण attrib1 - attrib5 इसके संबंधित गेटर्स और सेटर्स के साथ है।

अब मैंने List<Parent> अभिभावक बनाया है। फिर मैं निम्नलिखित स्थिति के साथ List<Parent> फ़िल्टर करना चाहता हूं: - Child.Attrib1 > 10;

इसलिए मैंने जावा 8 स्ट्रीम द्वारा निम्न क्वेरी बनाई।

parent.stream().filter(e -> e.getChild().stream().anyMatch(c -> c.getAttrib1() > 10)); 

लेकिन समस्या यह है मैं हर Parent वस्तु में सभी बच्चे मिल जाएगा है। यहां मैं केवल उन बच्चों की वस्तु को List<Child> में प्राप्त करना चाहता हूं जो दी गई स्थिति का पालन करता है।

मुझे सूची में सभी बच्चे वस्तुओं को कैसे हटाया जाना चाहिए जो स्थिति का पालन नहीं करते हैं और नई सूची प्राप्त करते हैं।

Answer 1

यदि आप सभी बच्चों को प्राप्त करना चाहते हैं तो आपको Stream<Child> की आवश्यकता है। निम्नलिखित अभिव्यक्ति चाल कर सकता:

parents.stream().flatMap(e -> e.getChildren().stream()).filter(c -> c.getAttrib1() > 10)

इस सूची में कहां से मिल विशेषता मान है में सभी माता पिता के सभी बच्चों लौटना चाहिए अधिक से अधिक 10

आप माता-पिता सूची अपडेट करना चाहते हैं सभी चाइल्ड तत्व है कि एक शर्त असफल निकाल कर, आप निम्न कर सकते हैं:

parents.forEach(p -> p.getChildren().removeIf(c -> c.getAttrib1() > 10));

यह एक नई सूची बनाने नहीं करता है। इसके बजाय यह parents सूची स्वयं अपडेट करता है।

Answer 2

मैं समझ सकता जैसा कि आप बच्चे को सूचियों के लिए अतिरिक्त फ़िल्टर जोड़ने चाहिए:

parent.stream().filter(e -> e.getChild().stream().anyMatch(c -> c.getAttrib1() > 10)).forEach(e -> e.setChild(e.getChild().stream().filter(c -> c.getAttrib1 > 10).collect(toList()))) 

आप setChild नहीं किया है:

• आप सूची से आइटम निकाल सकते हैं
• को पूरी तरह से नए माता पिता वस्तुओं बनाएं

हटाने के लिए आप इसेटरेटर का उपयोग कर सकते हैं:

parent.stream().filter(e -> e.getChild().stream().anyMatch(c -> c.getAttrib1 > 10)) 
    .forEach(e -> { 
     for(Iterator<Child> it = e.getChild().iterator(); it.hasNext();){ 
      Child cur = it.next(); 
      if(cur.getAttrib1() <= 10) it.remove(); 
    } 
}) 

Answer 3

मुझे पता है कि सवाल लगभग 2 साल पुराना है, लेकिन उम्मीद है कि यह उत्तर किसी की मदद कर सकता है।

com.coopstools.cachemonads नामक एक लाइब्रेरी है। यह जावा स्ट्रीम (और वैकल्पिक) कक्षाओं को बाद में उपयोग के लिए इकाइयों के कैशिंग की अनुमति देने के लिए बढ़ाता है।

List<Parent> goodParents = CacheStream.of(parents) 
      .cache() 
      .map(Parent::getChildren) 
      .flatMap(Collection::stream) 
      .map(Child::getAttrib1) 
      .filter(att -> att > 10) 
      .load() 
      .distinct() 
      .collect(Collectors.toList()); 

जहां, माता-पिता किसी सरणी या धारा है:

समाधान के साथ पाया जा सकता है।

स्पष्टता के लिए, कैश विधि माता-पिता को स्टोर करती है; और भार विधि माता-पिता को वापस खींचती है। और यदि माता-पिता के पास बच्चे नहीं हैं, तो नल सूचियों को हटाने के लिए पहले मानचित्र के बाद एक फ़िल्टर की आवश्यकता होगी।

इस पुस्तकालय का उपयोग किसी भी परिस्थिति में किया जा सकता है जहां मानचित्र/सॉर्ट/फ़िल्टर/आदि सहित बच्चों पर संचालन करने की आवश्यकता होती है, लेकिन जहां एक पुरानी इकाई की अभी भी आवश्यकता होती है।

कोड https://github.com/coopstools/cachemonads (जहां मैं रीडमी में अपने उदाहरण को शामिल किया है) में पाया जा सकता है, या Maven से डाउनलोड किया जा सकता है:

<dependency> 
    <groupId>com.coopstools</groupId> 
    <artifactId>cachemonads</artifactId> 
    <version>0.2.0</version> 
</dependency> 

(या, Gradle, com.coopstools: cachemonads: 0.2 .0)