Java 8 Streams में मास्टरी: व्यावहारिक कोड उदाहरण और टिप्स

इस ब्लॉग पोस्ट में, हम Java 8 Streams फीचर्स पर चर्चा करने जा रहे हैं और ढेर सारे अलग-अलग कोड उदाहरण प्रदान करेंगे।

Java Streams जावा में फंक्शनल प्रोग्रामिंग लाते हैं और वे Java 8 से शुरू होकर समर्थित हैं इसलिए यदि आपके पास Java का पुराना वर्जन है, तो आपको Java Streams का उपयोग करने के लिए Java 8 पर अपग्रेड करना होगा।

Java Streams का उपयोग क्यों करें?

Streams के कुछ फायदे:

• Streams आपको एक अधिक कुशल Java प्रोग्रामर बनाएंगे (आप देखेंगे कि कोड की बहुत कम लाइनों के साथ आप वास्तव में Streams का उपयोग करके बहुत कुछ हासिल कर सकते हैं)।
• ये लैम्ब्डा एक्सप्रेशन्स का भारी उपयोग करते हैं जो एक तरह के डिस्पोजेबल फंक्शन्स हैं।
• ParallelStreams बड़े डेटासेट के लिए मल्टी-थ्रेडेड ऑपरेशन्स को बहुत आसानी से सक्षम करता है।

Streams पाइपलाइन

अधिकांश मामलों में, एक Streams पाइपलाइन में होता है:

• स्रोत (जहां से आपका डेटा निकलता है)
• शून्य या अधिक इंटरमीडिएट ऑपरेशन्स द्वारा अनुसरण किया जाता है
• और एक टर्मिनल ऑपरेशन

स्रोत एलिमेंट्स की एक स्ट्रीम स्ट्रीम करेगा।

एलिमेंट्स की उस स्ट्रीम को फ़िल्टर, सॉर्ट किया जा सकता है, या इसे मैप किया जा सकता है या प्रत्येक एलिमेंट पर ऑपरेशन्स की विभिन्न श्रृंखला लागू की जा सकती है।

अंत में, इसे या तो कलेक्ट या रिड्यूस किया जा सकता है या कुछ अन्य टर्मिनल ऑपरेशन लेकिन केवल एक टर्मिनल ऑपरेशन किया जाता है।

Stream स्रोत

Stream स्रोत कलेक्शन, लिस्ट, सेट, int, longs, double, strings, आदि के ऐरे से आ सकता है।

Stream ऑपरेशन्स

Stream ऑपरेशन्स या तो इंटरमीडिएट या टर्मिनल होते हैं:

• इंटरमीडिएट ऑपरेशन्स जैसे फ़िल्टर, मैप, या सॉर्ट एक स्ट्रीम लौटाते हैं ताकि हम कई इंटरमीडिएट ऑपरेशन्स को चेन कर सकें।
• टर्मिनल ऑपरेशन्स एक स्ट्रीम प्राप्त करते हैं और वे या तो void लौटा सकते हैं या वे एक नॉन-स्ट्रीम परिणाम जैसे रिडक्शन लौटा सकते हैं, जैसे आइटम्स को लिस्ट में रिड्यूस करना।

इंटरमीडिएट ऑपरेशन्स

• शून्य या अधिक इंटरमीडिएट ऑपरेशन्स अनुमत हैं।
• ऑर्डर मायने रखता है; बड़े डेटासेट के लिए: पहले फ़िल्टर करें फिर सॉर्ट या मैप करें।
• बहुत बड़े डेटासेट के लिए ParallelStream का उपयोग करके मल्टीपल थ्रेड्स सक्षम करें।

कुछ इंटरमीडिएट ऑपरेशन्स में शामिल हैं:

• anyMatch()
• distinct()
• filter()
• findFirst()
• flatmap()
• map()
• skip()
• sorted()

टर्मिनल ऑपरेशन्स

केवल एक टर्मिनल ऑपरेशन अनुमत है।

• forEach प्रत्येक एलिमेंट पर समान फंक्शन लागू करता है उदाहरण के लिए प्रत्येक एलिमेंट को प्रिंट करना।
• collect सभी एलिमेंट्स को एक कलेक्शन या लिस्ट या ऐरे में सेव करता है।
• अन्य सभी विकल्प स्ट्रीम को एक सिंगल सारांश एलिमेंट में रिड्यूस करते हैं।

रिडक्शन फंक्शन्स के कुछ उदाहरण हैं:

• count()
• max()
• min()
• reduce()

Java Streams कोड उदाहरण

अब आइए उपरोक्त अवधारणाओं को कोड उदाहरणों में देखें।

इंटीजर स्ट्रीम

पहला उदाहरण सिर्फ एक इंटीजर स्ट्रीम है। हम IntStream क्लास और इसकी रेंज फंक्शन का उपयोग करके एक इंटीजर स्ट्रीम बनाने जा रहे हैं जो हमें इंटीजर्स की एक रेंज देता है।

forEach हमारा टर्मिनल ऑपरेशन है। प्रत्येक आइटम के लिए, हम बस इसे प्रिंट करने जा रहे हैं।

import java.io.IOException; import java.util.stream.IntStream; public class JavaStreams { public static void main(String[] args) throws IOException { IntStream .range(1, 10) .forEach(System.out::print); System.out.println(); } } 

आउटपुट:

123456789 

स्किप के साथ इंटीजर स्ट्रीम

दूसरा उदाहरण एक इंटीजर स्ट्रीम का उपयोग करता है लेकिन हमने यहां एक skip() जोड़ा, इसलिए इस मामले में, हम अपनी स्ट्रीम के पहले 5 एलिमेंट्स को स्किप करने जा रहे हैं।

यह केवल एलिमेंट्स 6 से 9 प्रिंट करेगा। हम आइटम प्रिंट करने के लिए एक सिंपल लैम्ब्डा एक्सप्रेशन का भी उपयोग कर रहे हैं।

import java.io.IOException; import java.util.stream.IntStream; public class JavaStreams { public static void main(String[] args) throws IOException { IntStream .range(1, 10) .skip(5) .forEach(x -> System.out.println(x)); System.out.println(); } } 

आउटपुट:

6 7 8 9 

सम के साथ इंटीजर स्ट्रीम

तीसरा उदाहरण, हम फिर से IntStream का उपयोग करके अपने ऑब्जेक्ट्स की स्ट्रीम बनाते हैं, हालांकि, हम इसे println() स्टेटमेंट के अंदर पैरामीटर के रूप में रखते हैं।

हम जो प्रिंट करने जा रहे हैं वह सिर्फ रेंज 1 से 5 का योग है, दूसरे शब्दों में, 1 2 3 & 4 यह केवल उन नंबरों का योग प्रिंट करेगा:

import java.io.IOException; import java.util.stream.IntStream; public class JavaStreams { public static void main(String[] args) throws IOException { System.out.println( IntStream .range(1, 5) .sum()); System.out.println(); } } 

आउटपुट:

10 

Stream.of

अगला उदाहरण Stream.of फंक्शन का उपयोग करता है, जो वास्तव में उपयोगी है क्योंकि आप इंटीजर्स, फ्लोटिंग पॉइंट वैल्यूज़ या स्ट्रिंग्स या यहां तक कि ऑब्जेक्ट्स को स्ट्रीम कर सकते हैं।

इस उदाहरण में, हम सिर्फ एक सीधा वर्णमाला क्रम सॉर्ट करने जा रहे हैं फिर हम findFirst() फंक्शन का उपयोग करके पहला आइटम ढूंढेंगे। फिर, हम बस लिस्ट में पहले आइटम को प्रिंट करते हैं।

import java.io.IOException; import java.util.stream.Stream; public class JavaStreams { public static void main(String[] args) throws IOException { Stream.of("Ava", "Aneri", "Alberto") .sorted() .findFirst() .ifPresent(System.out::println); } } 

आउटपुट

Alberto 

ऐरे से स्ट्रीम, सॉर्ट, फ़िल्टर और प्रिंट

हमारे अगले उदाहरण में, हम एक ऐरे से स्ट्रीम करने जा रहे हैं। फिर हम सॉर्ट, फ़िल्टर और फिर प्रिंट करने जा रहे हैं।

यहां, हम केवल उन आइटम्स को फ़िल्टर करने जा रहे हैं जो s से शुरू होते हैं।

हम एक लैम्ब्डा एक्सप्रेशन का उपयोग करते हैं जो X लेता है जो प्रत्येक नाम है और फिर जांचता है कि कौन से अक्षर s से शुरू होते हैं और उन्हें पास करता है।

फिर हम उन्हें सॉर्ट करने जा रहे हैं और फिर उस सॉर्ट को पास करने वाले प्रत्येक आइटम के लिए हम इसे प्रिंट करने जा रहे हैं।

import java.io.IOException; import java.util.Arrays; public class JavaStreams { public static void main(String[] args) throws IOException { String[] names = {"Al", "Ankit", "Kushal", "Brent", "Sarika", "amanda", "Hans", "Shivika", "Sarah"}; Arrays.stream(names) .filter(x -> x.startsWith("S")) .sorted() .forEach(System.out::println); } } 

आउटपुट:

Sarah Sarika Shivika 

इंटीजर ऐरे का औसत

अब देखते हैं कि हम int ऐरे के वर्गों का औसत कैसे ले सकते हैं।

यहां, हम इंटीजर्स को स्ट्रीम करने के लिए Arrays.stream() फंक्शन का उपयोग करते हैं और फिर हम प्रत्येक आइटम को उसके वर्ग में मैप करने के लिए map() का उपयोग करने जा रहे हैं।

import java.util.Arrays; public class JavaStreams { public static void main(String[] args) { Arrays.stream(new int[] {2, 4, 6, 8, 10}) .map(x -> x * x) .average() .ifPresent(System.out::println); } } 

आउटपुट:

44.0 

नोट यह इंटीजर के बजाय डबल प्रिंट करता है।

लिस्ट से स्ट्रीम, फ़िल्टर और प्रिंट

इस उदाहरण में, हम एक लिस्ट से स्ट्रीम करने जा रहे हैं, उन आइटम्स को फ़िल्टर करेंगे और फिर प्रिंट करेंगे।

नोट करें कि map() फंक्शन के भीतर, हम सभी नामों को लोअरकेस में बदलने जा रहे हैं।

import java.util.Arrays; import java.util.List; public class JavaStreams { public static void main(String[] args) { List people = Arrays.asList("Al", "Ankit", "Brent", "Sarika", "amanda", "Hans", "Shivika", "Sarah"); people .stream() .map(String::toLowerCase) .filter(x -> x.startsWith("a")) .forEach(System.out::println); } } 

आउटपुट:

al ankit amanda 

हम देख सकते हैं कि हमारे पास तीन नाम हैं जो a से शुरू होते हैं और वे सभी लोअरकेस में हैं।

टेक्स्ट फ़ाइल से पंक्तियाँ स्ट्रीम करें, सॉर्ट, फ़िल्टर, और प्रिंट करें

हमारे अगले उदाहरण में, हम एक टेक्स्ट फ़ाइल से पंक्तियों को स्ट्रीम करने जा रहे हैं। हम सॉर्ट, फ़िल्टर और प्रिंट करने जा रहे हैं।

मान लें कि हमारे पास bands.txt नामक एक फ़ाइल है जिसकी सामग्री नीचे दिखाई गई है:

Rolling Stones Lady Gaga Jackson Browne Maroon 5 Arijit Singh Elton John John Mayer CCR Eagles Pink Aerosmith Adele Taylor Swift 

हम Files.lines() का उपयोग अपनी स्ट्रीम बनाने के लिए करने जा रहे हैं जो हमें फ़ाइल की प्रत्येक पंक्ति के लिए एक स्ट्रिंग की स्ट्रीम देने जा रही है।

एक बार जब हमारे पास हमारी स्ट्रीम होती है, तो हम उन्हें सॉर्ट करने जा रहे हैं और हम 13 कैरेक्टर्स से अधिक वाले आइटम्स को फ़िल्टर आउट करने जा रहे हैं और फिर शेष आइटम्स को प्रिंट करेंगे।

अंत में, हमें फ़ाइल को बंद करना होगा इसलिए हम bands.close करते हैं।

import java.io.IOException; import java.nio.file.Files; import java.nio.file.Paths; import java.util.stream.Stream; public class JavaStreams { public static void main(String[] args) throws IOException { Stream bands = Files.lines(Paths.get("bands.txt")); bands .sorted() .filter(x -> x.length() > 13) .forEach(System.out::println); bands.close(); } } 

आउटपुट:

Jackson Browne Rolling Stones 

हमें दो बैंड मिलते हैं जिनमें 13 से अधिक कैरेक्टर्स हैं।

टेक्स्ट फ़ाइल से पंक्तियाँ स्ट्रीम करें और लिस्ट में सेव करें

इस उदाहरण के लिए, हम ऊपर जैसी ही टेक्स्ट फ़ाइल का उपयोग करेंगे।

हम x.contains() का उपयोग करके अक्षर jit वाले आइटम्स को फ़िल्टर आउट करना चाहते हैं जो सिर्फ एक स्ट्रिंग फंक्शन है।

.collect() का उपयोग करके हम jit अक्षरों वाले सभी को लिस्ट में जोड़ते हैं।

एक बार हमारे पास हमारी लिस्ट हो जाने पर, हम आइटम्स प्रिंट करने के लिए forEach ऑपरेटर का उपयोग कर सकते हैं।

import java.io.IOException; import java.nio.file.Files; import java.nio.file.Paths; import java.util.List; import java.util.stream.Collectors; public class JavaStreams { public static void main(String[] args) throws IOException { List bands2 = Files.lines(Paths.get("bands.txt")) .filter(x -> x.contains("jit")) .collect(Collectors.toList()); bands2.forEach(x -> System.out.println(x)); } } 

आउटपुट:

Arijit Singh 

CSV फ़ाइल से पंक्तियाँ स्ट्रीम करें और गिनें

इस उदाहरण में, हम एक CSV फ़ाइल से पंक्तियों को स्ट्रीम करते हैं और हम अच्छी पंक्तियों को गिनने जा रहे हैं।

मान लीजिए हमारे पास data.txt नामक एक फ़ाइल है जिसकी निम्नलिखित सामग्री है:

A,12,3.7 B,17,2.8 C,14,1.9 D,23,2.7 E F,18,3.4 

यहां, पंक्ति E में कोई डेटा नहीं है, इसलिए हम इसे अपनी स्ट्रीम से बाहर करना चाहते हैं।

निम्नलिखित कोड में, हम प्रत्येक पंक्ति को पढ़ने जा रहे हैं फिर हमें कॉमा पर विभाजित करके एक ऐरे में विभाजित करना होगा ताकि प्रत्येक पंक्ति आइटम्स का एक ऐरे बन जाए।

फिर हम उन पंक्तियों को फ़िल्टर आउट करने के लिए एक फ़िल्टर लागू करते हैं जिनमें तीन आइटम नहीं हैं।

import java.io.IOException; import java.nio.file.Files; import java.nio.file.Paths; import java.util.stream.Stream; public class JavaStreams { public static void main(String[] args) throws IOException { Stream rows1 = Files.lines(Paths.get("data.txt")); int rowCount = (int)rows1 .map(x -> x.split(",")) .filter(x -> x.length == 3) .count(); System.out.println(rowCount + " rows."); rows1.close(); } } 

आउटपुट:

5 rows 

रिडक्शन - योग

यह उदाहरण आपको दिखाता है कि रिडक्शन का उपयोग कैसे करें। हम योग में रिड्यूस करने जा रहे हैं। यहां, हमारे पास Stream.of() फंक्शन का उपयोग करके एक डबल स्ट्रीम है। हमने तीन अलग-अलग आर्ग्यूमेंट्स में तीन डबल्स परिभाषित किए हैं और हम रिड्यूस फंक्शन का उपयोग करने जा रहे हैं।

import java.util.stream.Stream; public class JavaStreams { public static void main(String[] args) { double total = Stream.of(7.3, 1.5, 4.8) .reduce(0.0, (Double a, Double b) -> a + b); System.out.println("Total = " + total); } } 

आउटपुट:

13.600000000000001