लोड हो रहा है...

Java में Streams

सूची से stream() के साथ pipeline शुरू करें, एलिमेंट रखें या बदलें, फिर प्रिंट करें। Pipe.java में सार्वजनिक class Pipe रखें, java.util.ArrayList इम्पोर्ट करें, "oak" और "pine" रखें, और names.stream().filter(n -> n.startsWith("o")).forEach(n -> System.out.println(n)); कॉल करें। javac Pipe.java से कंपाइल करें और java Pipe चलाएँ। स्क्रीन पर oak दिखना चाहिए। दूसरा डेमो map उपयोग करता है ताकि स्क्रीन OAK, फिर PINE दिखाए। वैकल्पिक Records अगले पेज के लिए छोड़ दें। यह पाठ stream pipeline है, सूची पर साधारण forEach नहीं और Generics get(0) डेमो नहीं।

एक मेल खाता शब्द filter करें

Pipe.java खोलें। सार्वजनिक class नाम Pipe रखें। बची हुई Cue lambda-केवल डेमो, बची हुई Bin generics प्रिंट, बची हुई Flag arguments रन, और बची हुई Box Scanner प्रॉम्प्ट हटाएँ अगर वे streams कहानी दबा दें। प्रोग्राम टाइपिंग का इंतज़ार नहीं करना चाहिए और लॉन्च शब्द ज़रूरी नहीं।
ऊपर इम्पोर्ट जोड़ें:
import java.util.ArrayList;
Pipe.main के अंदर, दो शब्दों वाली टाइप की गई सूची बनाएँ, फिर ऐसा stream शुरू करें जो o से शुरू होने वाले शब्द रखे:
ArrayList<String> names = new ArrayList<>();
names.add("oak");
names.add("pine");
names.stream().filter(n -> n.startsWith("o")).forEach(n -> System.out.println(n));
stream() pipeline खोलता है। filter उन एलिमेंट को रखता है जिनकी lambda true लौटाती है। forEach हर रखे गए एलिमेंट को प्रिंट करता है। "oak" o से शुरू होता है। "pine" नहीं। स्क्रीन oak दिखाती है।

Pipe stream filter prints oak

java

import java.util.ArrayList;

public class Pipe {
    public static void main(String[] args) {
        ArrayList<String> names = new ArrayList<>();
        names.add("oak");
        names.add("pine");
        names.stream().filter(n -> n.startsWith("o")).forEach(n -> System.out.println(n));
    }
}

जिस फ़ोल्डर में Pipe.java है, वहाँ javac Pipe.java चलाएँ। जब ब्रैस और सेमीकोलन मेल खाते हैं, javac अपनी कोई लाइन नहीं लिखता। फिर java Pipe चलाएँ — java Pipe.java नहीं। एक सार्वजनिक class रखें ताकि नाम Pipe से मेल खाए।
एक बार रन चलाकर देखें। Java Pipe.main से शुरू होता है। सूची में "oak" और "pine" हैं। stream() शुरू होता है। filter "oak" रखता है। forEach oak प्रिंट करता है। दोनों शब्द कुछ नहीं प्रिंट करते। बिना stream() के केवल names.forEach भी नहीं। args[0] भी नहीं पढ़ता।
स्क्रीन देखते हुए शुरुआती नियम कहें: stream() पाइप शुरू करता है; filter चुनता है; forEach प्रिंट के साइड इफ़ेक्ट से समाप्त करता है। इस पेज पर Records डेमो न बनाएँ। Records अगले वैकल्पिक पाठ का इंतज़ार करता है। stream() हटाकर filter को सूची पर लटकाने की उम्मीद न करें इस शिक्षण आकार में।
अगर बचे Cue forEach फ़ाइल से अभी भी oak फिर pine दिखे, Pipe पर जाएँ और filter स्टेप रखें। अगर javac stream अस्वीकार करे, पुष्टि करें सूची का टाइप ArrayList है और कॉल names.stream() है।

हर शब्द को बड़े अक्षरों में map करें

वही सार्वजनिक class Pipe रखें। filter के बजाय हर शब्द बदलने के लिए pipeline बदलें:
names.stream().map(n -> n.toUpperCase()).forEach(n -> System.out.println(n));
सूची में "oak" और "pine" दोनों रखें। फिर javac Pipe.java से कंपाइल करें और java Pipe चलाएँ। स्क्रीन OAK, फिर PINE दिखाती है। map हर एलिमेंट के लिए नया मान लौटाता है। forEach उन मानों को क्रम में प्रिंट करता है।

Pipe stream map prints OAK then PINE

java

import java.util.ArrayList;

public class Pipe {
    public static void main(String[] args) {
        ArrayList<String> names = new ArrayList<>();
        names.add("oak");
        names.add("pine");
        names.stream().map(n -> n.toUpperCase()).forEach(n -> System.out.println(n));
    }
}

एक बार रन चलाकर देखें। पहला mapped मान OAK है। दूसरा PINE है। दोनों डेमो को दो शिक्षण आकार रखें। पहले साबित करें filter एक शब्द रखता है। फिर साबित करें map हर शब्द बदलता है। दोनों आकार में इम्पोर्ट, टाइप सूची, stream(), और terminal forEach समान हैं।
बाद में अपने प्रयोगों में filter और map जोड़ें तो क्रम मायने रखता है। यह पेज प्रति डेमो एक मध्यवर्ती स्टेप रखता है ताकि स्क्रीन पढ़ने में आसान रहे।

Pipeline आदतें

अभ्यास करते समय स्टेप क्रम में रखें।

📊 Pipe के लिए stream आदतें

स्टेप	कॉल	शुरुआती जाँच
शुरू	`names.stream()`	सूची से pipeline खोलता है
कुछ रखें	`filter(n -> ...)`	lambda true लौटाए तो रखता है
हर एक बदलें	`map(n -> ...)`	lambda नया मान लौटाती है
प्रिंट समाप्त	`forEach(n -> System.out.println(n))`	प्रिंट करने वाला terminal स्टेप
`stream()` छोड़ें	इस आकार में सूची पर `filter` नहीं	`filter` या `map` से पहले `stream()` लगाएँ

Streams सिर्फ Lambda नहीं और Records नहीं

Lambda ने सूची पर सीधे forEach सिखाया। Streams पहले stream() लगाता है ताकि अंतिम forEach से पहले filter या map कर सकें। Records बाद के वैकल्पिक पेज पर संक्षिप्त डेटा टाइप लाएगा। आज एक शुरुआती फ़ाइल में तीनों काम न मिलाएँ।
filter से रखा oak अभी भी pipeline से बहने वाला सूची एलिमेंट है। यह Flag का args[0] नहीं। जब बची Cue फ़ाइल बिना filter के हर एलिमेंट प्रिंट करे, उसे इतिहास मानें और Pipe की stream().filter लाइन रखें।
इस पेज के filter और map कॉल बिना stream() के शिक्षण आकार नहीं हैं। बिना terminal forEach के pipeline प्रिंट नहीं करता। हर डेमो अभ्यास करते समय पाइप के दोनों सिरे साथ रखें। Records syntax इस पेज से दूर रखें जब तक वह पाठ न आए, भले ही वैकल्पिक पथ में संक्षिप्त डेटा टाइप का शीर्षक देख चुके हों।

Records से पहले फ़ोल्डर जाँच

सफल कंपाइल के बाद फ़ोल्डर सूचीबद्ध करें। Pipe.java और Pipe.class साथ दिखने चाहिए। सोर्स संपादित करें, सेव करें, javac Pipe.java चलाएँ, फिर java Pipe। पुराना .class अगर map पर स्विच के बाद कंपाइल छोड़ें तो पुराना filter स्क्रीन दिखा सकता है।
अगर javac डुप्लिकेट सार्वजनिक classes की शिकायत करे, केवल Pipe सार्वजनिक रखें। अगर filter डेमो पर स्क्रीन oak और pine दोनों दिखाए, startsWith("o") जाँच छूट सकती है — filter lambda वापस लाएँ। अगर कुछ प्रिंट न हो, पुष्टि करें add stream() से पहले चला।
इस पेज पर पूरे pipeline की जगह Cue की सूची-केवल forEach न चिपकाएँ। Bin का get(0) Pipe में न चिपकाएँ। वैकल्पिक streams काम है stream प्लस एक मध्यवर्ती स्टेप प्लस forEach।

वैकल्पिक Records से पहले

आप सार्वजनिक class Pipe, ArrayList इम्पोर्ट, "oak" और "pine" जोड़ना, names.stream().filter(n -> n.startsWith("o")).forEach(...), oak देखना, फिर names.stream().map(n -> n.toUpperCase()).forEach(...), OAK फिर PINE देखना रख सकते हैं। javac Pipe.java से कंपाइल करें और java Pipe चलाएँ। तालिका शुरू, filter, map और समाप्ति अलग करती है। अगला वैकल्पिक पेज Records है।
स्पष्ट streams जोड़ी के लिए Pipe डेमो रखें। pipeline अभ्यास करते समय Cue lambda फ़ाइलें इस पेज से दूर रखें। pipeline अभ्यास करते समय Bin generics फ़ाइलें इस पेज से दूर रखें। Records काम उस पाठ तक इस पेज से दूर रखें। ये आदतें आगे बढ़ने से पहले चेकपॉइंट हैं। जब filter स्क्रीन oak या map स्क्रीन OAK फिर PINE दिखाए, Streams ने इस पाठ का काम कर दिया और वैकल्पिक पथ जारी रखें तो Records के लिए तैयार हैं।
फ़ोल्डर में आखिरी बार: एक सार्वजनिक Pipe, इम्पोर्ट मौजूद, टाइप ArrayList<String>, filter या map से पहले stream(), terminal forEach, Scanner इंतज़ार नहीं, लॉन्च शब्द ज़रूरी नहीं। खुले डेमो पर फिर javac Pipe.java और java Pipe चलाएँ। अगर स्क्रीन अभी भी oak या OAK फिर PINE दिखाए, Streams आकार मज़बूत है और अगले पेज पर वैकल्पिक Records पर जा सकते हैं। हर पठन में एक साफ़ pipeline आदत रखें ताकि हर बार वही नक्शा सिखे।

🧠 अपने ज्ञान की परीक्षा करें

शुरू करने के लिए तैयार

अपने ज्ञान की परीक्षा करें

इस इंटरैक्टिव क्विज़ के साथ अपनी चुनौती लें और देखें कि आप विषय को कितनी अच्छी तरह समझते हैं

❓

प्रश्न

🎯

70%

पास करने के लिए

♾️

∞

समय

🔄

∞

प्रयास

📝 निर्देश

हर प्रश्न को ध्यान से पढ़ें
हर प्रश्न के लिए सबसे अच्छा उत्तर चुनें
आप जितनी बार चाहें क्विज़ दोबारा दे सकते हैं
आपकी प्रगति शीर्ष पर दिखाई जाएगी