2015-01-07 18 views
7

मैं एक एक वस्तु जो लगता है कि निम्नलिखितजावा 8 स्ट्रीम छानने एक सूची में सूची का मूल्य

class MyObject { 

    String type; 
    List<String> subTypes; 

} 

क्या यह संभव है है, MyObject के की एक सूची दी गई जावा 8 धाराओं का उपयोग करने के दोनों प्रकार के फिल्टर करने के लिए और फिर उप प्रकार?

अब तक मैं

myObjects.stream() 
    .filter(t -> t.getType().equals(someotherType) 
    .collect(Collections.toList()); 

है, लेकिन इस के भीतर मैं भी उपप्रकार एक विशेष उप-प्रकार पर उन भी छानने के प्रत्येक पर एक और फिल्टर करना चाहते हैं। मैं यह नहीं समझ सकता कि यह कैसे करें।

एक उदाहरण

myObject { type: A, subTypes [ { X, Y, Z } ] } 
myObject { type: B, subTypes [ { W, X, Y } ] } 
myObject { type: B, subTypes [ { W, X, Z } ] } 
myObject { type: C, subTypes [ { W, X, Z } ] } 

मैं मिलान प्रकार बी और उप-प्रकार जेड में पास होता, तो मैं एक परिणाम उम्मीद करेंगे -> myObject ग्रुप बी, उपप्रकार: डब्ल्यू, एक्स, जेड

निम्नलिखित वर्तमान में एक सूची में 2 आइटम लौटाता है।

myObjects.stream() 
    .filter(t -> t.getType().equals("B") 
    .collect(Collections.toList()); 

लेकिन मैं प्रत्येक उपप्रकारों पर एक अतिरिक्त फ़िल्टर जोड़ना चाहता हूं और केवल 'जेड' मौजूद हूं।

+0

क्या आप एक मैच और मिस का उदाहरण दे सकते हैं? 'उप-प्रकार 'मिलान में * सभी * तत्वों को अवश्य होना चाहिए? –

+0

क्या आप 'उप-प्रकार' फ़िल्टर करना चाहते हैं या क्या? – kraskevich

+0

क्या आप वास्तव में "किसी विशेष उप प्रकार पर फ़िल्टर करने वाले प्रत्येक उप-प्रकारों पर एक और फ़िल्टर" से क्या मतलब है? कृपया एक उदाहरण दें। –

उत्तर

10

आप कर सकते हैं:

myObjects.stream() 
     .filter(t -> t.getType().equals(someotherType) && 
         t.getSubTypes().stream().anyMatch(<predicate>)) 
     .collect(Collectors.toList()); 

यह सब MyObject वस्तुओं जो

  • type सदस्य के बारे में एक मानदंडों को पूरा लायेगा।
  • नेस्टेड List<String> में वस्तुओं है कि कुछ अन्य मानदंडों को पूरा, <predicate>
+0

कोई भी ऐसा करता है: 3 –

8

साथ प्रतिनिधित्व किया शामिल मैं @kocko से स्वीकार किए जाते हैं जवाब है जो दोनों एक अच्छा जवाब और पूरी तरह से सही है देखा। हालांकि थोड़ा सा वैकल्पिक दृष्टिकोण है जहां आप बस फ़िल्टर को चेन करते हैं।

final List<MyObject> withBZ = myObjects.stream() 
     .filter(myObj -> myObj.getType().equals("B")) 
     .filter(myObj -> myObj.getSubTypes().stream().anyMatch("Z"::equals)) 
     .collect(Collectors.toList()); 

यह मूलतः एक ही बात कर रही है लेकिन && संकार्य एक और फिल्टर के पक्ष में हटा दिया जाता है। चेनिंग जावा 8 स्ट्रीम एपीआई के लिए वास्तव में अच्छी तरह से काम करता है: एस और आईएमओ कोड को पढ़ने और उसका पालन करना आसान है।

+0

मैं अंतिम वाक्य पर सहमत हूं। धन्यवाद –

+0

बस के बजाय .stream()। AnyMatch ("Z" :: बराबर) का उपयोग करने का कोई कारण .contains ("Z")? निश्चित नहीं है कि मुझे कुछ याद आ रहा है या यदि वे वास्तव में वही हैं। –

संबंधित मुद्दे