कोड उदाहरणों के साथ जावा 8 स्ट्रीम ट्यूटोरियल

इस ब्लॉग पोस्ट में, हम Java 8 Streams सुविधाओं पर चर्चा करने जा रहे हैं और बहुत सारे अलग-अलग कोड उदाहरण प्रदान करेंगे।

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

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

धाराओं के कुछ लाभ:

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

स्ट्रीम पाइपलाइन

ज्यादातर मामलों में, एक स्ट्रीम पाइपलाइन में एक होता है

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

स्रोत तत्वों की एक धारा को स्ट्रीम करने जा रहा है।

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

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

स्ट्रीम स्रोत

स्ट्रीम स्रोत संग्रह, सूचियों, सेटों, इंट, लॉन्ग, डबल, स्ट्रिंग्स आदि की सरणियों से आ सकता है।

स्ट्रीम संचालन

स्ट्रीम संचालन मध्यवर्ती या टर्मिनल हैं:

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

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

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

कुछ मध्यवर्ती कार्यों में शामिल हैं:

• कोई भी मैच ()
• विशिष्ट ()
• फ़िल्टर ()
• findFirst()
• फ्लैटमैप ()
• नक्शा ()
• छोड़ें ()
• क्रमबद्ध ()

टर्मिनल संचालन

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

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

कार्यों को कम करने के कुछ उदाहरण हैं:

• गिनती ()
• अधिकतम ()
• मिनट ()
• कम करें ()

Java Streams Code उदाहरण

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

पूर्णांक स्ट्रीम

पहला उदाहरण सिर्फ एक पूर्णांक धारा है। हम 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

पूर्णांक सरणी का औसत

अब आइए एक नजर डालते हैं कि हम एक इंट ऐरे के वर्गों का औसत कैसे ले सकते हैं।

यहां, हम 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<String> 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<String> 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 से अधिक वर्ण होते हैं।

पाठ्य फ़ाइल से पंक्तियों को स्ट्रीम करें और सूची में सहेजें

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

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

.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<String> 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<String> 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