जावा स्ट्रीमर्स फॉर बिगिनर्स: जावा में स्ट्रीम का उपयोग करने के लिए एक परिचय

जावा 8 स्ट्रीम डेवलपर्स को पूर्वनिर्धारित संचालन के सेट का उपयोग करके, एक बड़े संग्रह से सटीक डेटा निकालने की अनुमति देती है।

जावा 8 की रिलीज़ से पहले, जावा में "स्ट्रीम" शब्द का उपयोग करना स्वचालित रूप से I / O से जुड़ा होगा। हालाँकि, जावा 8 ने एक धारा शुरू की, जिसे संगणनात्मक चरणों के एक समूह के रूप में संदर्भित किया जा सकता है, जिसे सामान्यतः "धारा पाइपलाइन" के रूप में संदर्भित किया जाता है।

यह आलेख आपको जावा 8 स्ट्रीम से परिचित कराएगा और प्रदर्शित करेगा कि वे आपकी परियोजनाओं में कैसे उपयोगी हो सकते हैं।

एक स्ट्रीम क्या है?

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

कैसे काम करता है धाराएँ

एक स्ट्रीम पाइपलाइन हमेशा एक स्रोत से शुरू होती है। स्रोत का प्रकार उस डेटा के प्रकार पर निर्भर करता है, जिसके साथ आप काम कर रहे हैं, लेकिन दो अधिक लोकप्रिय हैं सरणियाँ और संग्रह।

संग्रह को प्रारंभिक स्ट्रीम में बदलने के लिए, आपको जोड़ना होगा धारा () स्रोत के लिए कार्य। यह स्रोत को स्ट्रीम पाइपलाइन में रखेगा जहां कई अलग-अलग मध्यवर्ती संचालन (जैसे) फ़िल्टर () तथा क्रमबद्ध करें ()) इस पर काम कर सकते हैं।

सभी आवश्यक मध्यवर्ती संचालन आयोजित किए जाने के बाद, आप एक टर्मिनल ऑपरेशन (जैसे कि) शुरू कर सकते हैं प्रत्येक के लिए()), जो स्रोत से पहले निकाले गए डेटा का उत्पादन करेगा।

धाराओं के बिना जीवन

जावा 8 को 2014 में जारी किया गया था, लेकिन इससे पहले, जावा डेवलपर्स को अभी भी सामान्य डेटा के संग्रह से विशेष डेटा निकालने की आवश्यकता थी।

मान लें कि आपके पास यादृच्छिक वर्णों की एक सूची है जो अद्वितीय स्ट्रिंग मान बनाने के लिए यादृच्छिक संख्याओं के साथ संयुक्त हैं, लेकिन आप केवल "C" अक्षर से शुरू होने वाले मान चाहते हैं और आप परिणाम को आरोही में व्यवस्थित करना चाहते हैं गण। यह है कि आप धाराओं के बिना उस डेटा को कैसे निकालेंगे।

सम्बंधित: जावा में स्ट्रिंग्स का उपयोग करने के बारे में आपको क्या जानना चाहिए

फ़िल्टरिंग और छंटाई मान बिना धाराओं के उदाहरण

आयात java.util। सारणी सूची;
आयात java.util। एरेस;
आयात java.util। सूची;
पब्लिक क्लास मेन {
सार्वजनिक स्थैतिक शून्य main (String [] args) {
// ऐरे लिस्ट घोषित और शुरू करें
सूची randomValues ​​= Arrays.asList (
"E11", "D12", "A13", "F14", "C15", "A16",
"बी 11", "बी 12", "सी 13", "बी 14", "बी 15", "बी 16",
"F12", "E13", "C11", "C14", "A15", "C16",
"F11", "C12", "D13", "E14", "D15", "D16"
);
// घोषित सरणी सूची आवश्यक मूल्यों को संग्रहीत करेगी
सूची अपेक्षित
// आवश्यक मूल्यों को निकालने और उन्हें reqquiredValues ​​में संग्रहीत करना
randomValues.forEach (मान -> {
अगर (value.startsWith ("C")) {
अपेक्षित
}
});
// आरोही क्रम में आवश्यक प्रकारों को क्रमबद्ध करें
आवश्‍यक
// प्रत्येक मान को कंसोल पर प्रिंट करें
आवश्यकवैल्यू.फ़ॉरइच ((स्ट्रिंग मान) -> System.out.println (मूल्य));
}
}

आपको सरणी सूची को घोषित करने और आरंभ करने की आवश्यकता होगी, चाहे आप धाराएँ या किसी अन्य निष्कर्षण की विधि का उपयोग कर रहे हों। यदि आप स्ट्रीम का उपयोग कर रहे हैं, तो आपको आवश्यक मान रखने के लिए एक नया चर घोषित करने की आवश्यकता नहीं है, और न ही उपरोक्त उदाहरण में कोड की अन्य पांच पंक्तियों को बनाएं।

सम्बंधित: Java में Arrays पर ऑपरेशन्स कैसे बनाएं और परफॉर्म करें

ऊपर दिया गया कोड कंसोल में निम्नलिखित आउटपुट का उत्पादन करता है:

C11
C12
C13
C14
C15
C16

धाराओं के साथ जीवन

प्रोग्रामिंग में, दक्षता काफी कम कोड के साथ एक ही परिणाम का उत्पादन करने के लिए बोलती है। यह वही है जो एक प्रोग्रामर के लिए एक स्ट्रीम पाइपलाइन करता है। तो अगली बार जब कोई पूछता है: "आपकी परियोजना में धाराओं का उपयोग करना क्यों महत्वपूर्ण है?" सीधे शब्दों में कहें: "धाराओं कुशल प्रोग्रामिंग का समर्थन करते हैं।"

ऊपर हमारे उदाहरण के साथ जारी रखते हुए, यह इस तरह से धाराओं का परिचय पूरे कार्यक्रम को बदल देता है।

एक स्ट्रीम उदाहरण के साथ फ़िल्टरिंग और क्रमबद्ध मान

आयात java.util। एरेस;
आयात java.util। सूची;
पब्लिक क्लास मेन {
सार्वजनिक स्थैतिक शून्य main (String [] args) {
// ऐरे लिस्ट घोषित और शुरू करें
सूची randomValues ​​= Arrays.asList (
"E11", "D12", "A13", "F14", "C15", "A16",
"बी 11", "बी 12", "सी 13", "बी 14", "बी 15", "बी 16",
"F12", "E13", "C11", "C14", "A15", "C16",
"F11", "C12", "D13", "E14", "D15", "D16"
);
// केवल उन मानों को प्राप्त करता है जो C से शुरू होते हैं, उन्हें क्रमबद्ध करते हैं, और उन्हें कंसोल पर प्रिंट करते हैं।
randomValues.stream ()। फ़िल्टर (मान-> value.startsWith ("C")) सॉर्ट किया गया ()। forEach (System.out:: println);
}
}

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

जैसा कि आप ऊपर के उदाहरण में देख सकते हैं, सी सरणी सूची में मानों को यादृच्छिक रूप से व्यवस्थित किया जाता है। यदि आप पाइपलाइन में इस बिंदु पर धारा को प्रिंट करने के लिए थे, तो मूल्य C15 पहले छपा होगा। इसलिए क्रमबद्ध करें () फ़ंक्शन को आरोही क्रम में नए सरणी को पुनर्व्यवस्थित करने के लिए स्ट्रीम पाइपलाइन से परिचित कराया जाता है।

धारा पाइपलाइन में अंतिम कार्य एक है प्रत्येक के लिए() समारोह। यह एक टर्मिनल फ़ंक्शन है जिसका उपयोग स्ट्रीम पाइपलाइन को रोकने के लिए किया जाता है और कंसोल में निम्न परिणाम उत्पन्न करता है:

C11
C12
C13
C14
C15
C16

मध्यवर्ती संचालन की एक व्यापक सूची है जिसका उपयोग एक स्ट्रीम पाइपलाइन में किया जा सकता है।

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

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

यदि हमारी सरणी सूची में "C" से शुरू होने वाला कोई भी मान लोअरकेस में था, और हमने उन पर एक ही मध्यवर्ती संचालन किया, तो हमें निम्नलिखित परिणाम प्राप्त होंगे।

लोअरकेस वैल्यूज़ उदाहरण पर फ़िल्टरिंग और सॉर्ट ऑपरेशन करना

आयात java.util। एरेस;
आयात java.util। सूची;
पब्लिक क्लास मेन {
सार्वजनिक स्थैतिक शून्य main (String [] args) {
// ऐरे लिस्ट घोषित और शुरू करें
सूची randomValues ​​= Arrays.asList (
"E11", "D12", "A13", "F14", "C15", "A16",
"बी 11", "बी 12", "सी 13", "बी 14", "बी 15", "बी 16",
"F12", "E13", "C11", "C14", "A15", "c16",
"F11", "C12", "D13", "E14", "D15", "D16"
);
// केवल उन मानों को प्राप्त करता है जो C से शुरू होते हैं, उन्हें क्रमबद्ध करते हैं, और उन्हें कंसोल पर प्रिंट करते हैं।
randomValues.stream ()। फ़िल्टर (मान-> value.startsWith ("C")) सॉर्ट किया गया ()। forEach (System.out:: println);
}
}

उपरोक्त कोड कंसोल में निम्नलिखित मान उत्पन्न करेगा:

C11
C12
C14
C15

उपरोक्त आउटपुट के साथ एकमात्र समस्या यह है कि यह सभी का सही प्रतिनिधित्व नहीं करता है सी हमारी सरणी सूची में मान। इस छोटी सी त्रुटि को ठीक करने का एक अच्छा तरीका स्ट्रीम पाइपलाइन के लिए एक और मध्यवर्ती संचालन शुरू करना है; इस ऑपरेशन के रूप में जाना जाता है नक्शा() समारोह।

मैप फंक्शन उदाहरण का उपयोग करना

आयात java.util। एरेस;
आयात java.util। सूची;
पब्लिक क्लास मेन {
सार्वजनिक स्थैतिक शून्य main (String [] args) {
// ऐरे लिस्ट घोषित और शुरू करें
सूची randomValues ​​= Arrays.asList (
"E11", "D12", "A13", "F14", "C15", "A16",
"बी 11", "बी 12", "सी 13", "बी 14", "बी 15", "बी 16",
"F12", "E13", "C11", "C14", "A15", "c16",
"F11", "C12", "D13", "E14", "D15", "D16"
);
// सभी लोअर केस कैरेक्टर्स को अपर केस में बदल देता है,
// केवल उन मानों को प्राप्त करता है जो C से शुरू होते हैं, उन्हें क्रमबद्ध करते हैं, और उन्हें कंसोल पर प्रिंट करते हैं।
randomValues.stream ()। नक्शा (स्ट्रिंग:: toUpperCase)।
}
}

नक्शा() फ़ंक्शन एक वस्तु को एक राज्य से दूसरे में बदलता है; ऊपर हमारे उदाहरण में यह सरणी सूची के सभी निचले वर्णों को अपरकेस वर्णों में बदल देता है।

जगह दे रहा है नक्शा() से ठीक पहले कार्य करते हैं फ़िल्टर () फ़ंक्शन सभी मानों को पुनः प्राप्त करता है जो इसके साथ शुरू होते हैं सी सरणी सूची से।

ऊपर दिए गए कोड कंसोल में निम्नलिखित परिणाम का उत्पादन करते हैं, सफलतापूर्वक सभी का प्रतिनिधित्व करते हैं सी सरणी सूची में मान।

C11
C12
C13
C14
C15
C16

अन्य तीन मध्यवर्ती संचालन जो आप अपने अनुप्रयोगों में उपयोग कर सकते हैं उनमें शामिल हैं:

• झांकना ()
• सीमा ()
• छोड़ें()

जावा 8 स्ट्रीम कुशल कोड के निर्माण की सुविधा देता है

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

यदि आप हमारे भीतर संलग्न कोड की लाइन के बारे में सोच रहे हैं फ़िल्टर () समारोह; इसे "लैम्ब्डा एक्सप्रेशन" के रूप में जाना जाता है। लैम्ब्डा एक्सप्रेशन जावा 8 के साथ पेश की गई एक और विशेषता है, और इसमें बहुत सारे नगेट्स हैं जो आपको उपयोगी लग सकते हैं।

जावा 8 लैम्ब्डा का एक त्वरित परिचय

यदि आप एक जावा प्रोग्रामर हैं और आप जावा 8 लैम्ब्डा के बारे में अधिक जानने में रुचि रखते हैं, तो इस लेख में हम लैम्ब्डा सिंटैक्स और उपयोग पर करीब से नज़र डालने जा रहे हैं।

आगे पढ़िए

लेखक के बारे में