जावा - लैम्ब्डा एक्सप्रेशंस के साथ एक स्ट्रीम फ़िल्टर करें

जावा स्ट्रीम को 8 में जावा 2014 में सभी तरह से पेश किया गया है, वर्बोज़ जावा को एक कार्यात्मक प्रोग्रामिंग प्रतिमान में पेश करने के प्रयास में। जावा स्ट्रीम एक-लाइनर में संग्रह प्रसंस्करण करने के लिए कई लचीले और शक्तिशाली कार्यात्मक संचालन को उजागर करता है।

कुछ विधेय के आधार पर फ़िल्टरिंग संग्रह सबसे अधिक उपयोग किए जाने वाले कार्यात्मक कार्यों में से एक है, और इसे एक के साथ किया जा सकता है Predicate या अधिक संक्षेप में - a . के साथ लैम्ब्डा अभिव्यक्ति.

इस संक्षिप्त मार्गदर्शिका में, हम देखेंगे कि आप लैम्ब्डा एक्सप्रेशंस के साथ जावा 8 स्ट्रीम को कैसे फ़िल्टर कर सकते हैं।

जावा में फ़िल्टरिंग स्ट्रीम

सामान्य तौर पर, कोई भी Stream के माध्यम से फ़िल्टर किया जा सकता है filter() विधि, और एक दी गई विधेय:

Stream filter(Predicate<? super T> predicate)

स्ट्रीम में प्रत्येक तत्व विधेय के विरुद्ध चलाया जाता है, और यदि विधेय वापस आता है तो आउटपुट स्ट्रीम में जोड़ा जाता है true. आप आपूर्ति कर सकते हैं a Predicate उदाहरण:

Predicate contains = s -> s.contains("_deprecated");
List results = stream.filter(contains).collect(Collectors.toList());

या, लैम्ब्डा एक्सप्रेशन प्रदान करके इसे सरल बनाएं:

List results = stream.filter(s -> s.contains("_deprecated"))
                             .collect(Collectors.toList());

या यहां तक ​​​​कि लैम्ब्डा एक्सप्रेशन को a . में संक्षिप्त करें विधि संदर्भ:

List results = stream.filter(String::isEmpty)
                             .collect(Collectors.toList());

विधि संदर्भों के साथ, आप तर्कों को पारित नहीं कर सकते हैं, हालांकि, आप उस वस्तु में विधियों को परिभाषित कर सकते हैं जिन्हें आप फ़िल्टर कर रहे हैं और उन्हें आसानी से फ़िल्टर करने योग्य बनाने के लिए तैयार कर सकते हैं (जब तक विधि तर्कों को स्वीकार नहीं करती है और एक boolean).

याद रखें कि धाराएँ संग्रह नहीं हैं - वे धाराएं हैं संग्रह का, और आपको उन्हें किसी भी संग्रह जैसे a . में वापस एकत्र करना होगा List, Map, आदि उन्हें स्थायित्व देने के लिए। इसके अतिरिक्त, स्ट्रीम तत्वों पर किए गए सभी ऑपरेशन या तो मध्यवर्ती or अंतिम:

• इंटरमीडिएट ऑपरेशंस पिछले ऑपरेशन के बदलावों के साथ एक नई स्ट्रीम लौटाते हैं
• टर्मिनल ऑपरेशन एक डेटा प्रकार लौटाते हैं और एक स्ट्रीम पर प्रसंस्करण की एक पाइपलाइन को समाप्त करने के लिए होते हैं

filter() है एक मध्यवर्ती संचालन, और धारा समाप्त होने से पहले, अन्य मध्यवर्ती संचालन के साथ जंजीर होने के लिए है। किसी भी परिवर्तन को जारी रखने के लिए (जैसे स्वयं तत्वों में परिवर्तन, या फ़िल्टर किए गए परिणाम), आपको परिणामी असाइन करना होगा आउटपुट स्ट्रीम एक टर्मिनल ऑपरेशन के माध्यम से एक नए संदर्भ चर के लिए।

नोट: यहां तक ​​​​कि कई लैम्ब्डा अभिव्यक्तियों का पीछा करते हुए, आप उचित लाइनब्रेक के साथ पठनीयता के मुद्दों में नहीं चल सकते हैं।

निम्नलिखित उदाहरणों में, हम पुस्तकों की इस सूची के साथ काम करेंगे:

Book book1 = new Book("001", "Our Mathematical Universe", "Max Tegmark", 432, 2014);
Book book2 = new Book("002", "Life 3.0", "Max Tegmark", 280, 2017);
Book book3 = new Book("003", "Sapiens", "Yuval Noah Harari", 443, 2011);
        
List books = Arrays.asList(book1, book2, book3);

Stream.filter के साथ फ़िल्टर संग्रह ()

आइए पुस्तकों के इस संग्रह को फ़िल्टर करें। कोई भी विधेय जाता है - तो आइए उदाहरण के लिए फ़िल्टर करें जिसके द्वारा पुस्तकों में 400 से अधिक पृष्ठ हैं:

List results = books.stream()
                          .filter(b -> b.getPageNumber() > 400)
                          .collect(Collectors.toList());

इसका परिणाम एक सूची में होता है जिसमें शामिल हैं:

[
Book{id='001', name='Our Mathematical Universe', author='Max Tegmark', pageNumber=432, publishedYear=2014}, 
Book{id='003', name='Sapiens', author='Yuval Noah Harari', pageNumber=443, publishedYear=2011}
]

फ़िल्टर करते समय, श्रृंखला के लिए वास्तव में उपयोगी विधि है map(), जो आपको वस्तुओं को किसी अन्य मान पर मैप करने देता है। उदाहरण के लिए, हम प्रत्येक पुस्तक को उसके नाम से मैप कर सकते हैं, और इस प्रकार केवल नामों विधेय से फिट होने वाली पुस्तकों में से filter() फोन:

List results = books.stream()
                            .filter(b -> b.getPageNumber() > 400)
                            .map(Book::getName)
                            .collect(Collectors.toList());

इसके परिणामस्वरूप स्ट्रिंग्स की एक सूची होती है:

[Our Mathematical Universe, Sapiens]

Stream.filter () के साथ एकाधिक विधेय पर फ़िल्टर संग्रह

आम तौर पर, हम संग्रहों को एक से अधिक मानदंडों के आधार पर फ़िल्टर करना चाहते हैं। यह कई को जंजीर करके किया जा सकता है filter() कॉल or शॉर्ट-सर्किट विधेय का उपयोग करते हुए, जो एक में दो स्थितियों के लिए जाँच करता है filter() पु का र ना।

 List results = books.stream()
                    .filter(b -> b.getPageNumber() > 400 && b.getName().length() > 10)
                    .collect(Collectors.toList());
                    


 List results2 = books.stream()
                    .filter(b -> b.getPageNumber() > 400)
                    .filter(b -> b.getName().length() > 10)
                    .collect(Collectors.toList());

कई मानदंडों का उपयोग करते समय - लैम्ब्डा कॉल कुछ लंबा हो सकता है। इस बिंदु पर, उन्हें स्टैंडअलोन विधेय के रूप में निकालने से अधिक स्पष्टता मिल सकती है। हालांकि, कौन सा दृष्टिकोण तेज है?

जटिल स्थिति या एकाधिक फ़िल्टर वाला एकल फ़िल्टर?

यह आपके हार्डवेयर पर निर्भर करता है कि आपका संग्रह कितना बड़ा है, और आप समानांतर धाराओं का उपयोग करते हैं या नहीं। सामान्य तौर पर - एक जटिल स्थिति वाला एक फ़िल्टर सरल परिस्थितियों (छोटे से मध्यम संग्रह) के साथ कई फ़िल्टर से बेहतर प्रदर्शन करेगा, या एक ही स्तर (बहुत बड़े संग्रह) पर प्रदर्शन करेगा। यदि आपकी शर्तें बहुत लंबी हैं - तो आपको उन्हें कई में बांटने से लाभ हो सकता है filter() बेहतर पठनीयता के लिए कॉल, क्योंकि प्रदर्शन बहुत समान है।

दोनों को आजमाना सबसे अच्छा विकल्प है, पर प्रदर्शन नोट करें लक्ष्य युक्ति, और तदनुसार अपनी रणनीति समायोजित करें।

गिटहब उपयोगकर्ता वोल्कोडाव्स थ्रूपुट संचालन में एक फ़िल्टरिंग बेंचमार्क किया, और परिणामों की मेजबानी की "जावाफिल्टर-बेंचमार्क" भंडार। परिणामों को एक सूचनात्मक तालिका में संक्षेपित किया गया है:

यह बड़े संग्रह आकारों में रिटर्न की स्पष्ट कमी को दर्शाता है, दोनों दृष्टिकोण समान स्तर के आसपास प्रदर्शन करते हैं। समानांतर स्ट्रीम बड़े संग्रह आकारों में महत्वपूर्ण रूप से लाभान्वित होते हैं, लेकिन छोटे आकार (~ 10k तत्वों से नीचे) पर प्रदर्शन को रोकते हैं। यह ध्यान देने योग्य है कि समानांतर धाराओं ने अपने थ्रूपुट को गैर-समानांतर धाराओं की तुलना में बहुत बेहतर बनाए रखा, जिससे वे इनपुट के लिए काफी अधिक मजबूत हो गए।