तो, आप यहां जावा में धाराओं के बारे में जानने आए हैं, लेकिन उस प्रकार की जलधाराओं के बारे में नहीं जहां लोग मछली पकड़ने जाते हैं या जल प्रवाह होता है। हम डेटा स्ट्रीम के बारे में बात कर रहे हैं, जो जावा 8 में पेश की गई एक शक्तिशाली सुविधा है जो डेटा के साथ काम करना बहुत आसान बना देती है। चाहे आप इसके लिए बिल्कुल नए हों या आपने इसे आज़माया हो, लेकिन इसे पूरा नहीं कर सके, चिंता न करें। मैं आपको पूरी यात्रा सरल, समझने में आसान भाषा में बताऊंगा।

तैयार? आइए जावा स्ट्रीम्स में गोता लगाएँ!

जावा में स्ट्रीम क्या है?

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

स्ट्रीम के बारे में याद रखने योग्य मुख्य बातें:

1. स्ट्रीम मूल डेटा को संशोधित नहीं करती हैं। इन्हें अपने डेटा पर एक दृश्य या पाइपलाइन के रूप में सोचें।
2. स्ट्रीम डेटा को आलस्य से संसाधित करते हैं, जिसका अर्थ है कि वे तब तक कोई वास्तविक काम नहीं करते हैं जब तक आप उन्हें अंतिम परिणाम देने के लिए नहीं कहते हैं। यह अनावश्यक गणनाओं से बचाता है।
3. स्ट्रीम एक बार उपयोग की जाती हैं। एक बार जब एक धारा का उपभोग हो जाता है, तो वह ख़त्म हो जाती है। यदि आप इसका पुन: उपयोग करना चाहते हैं तो आपको एक नया बनाना होगा।

स्ट्रीम का उपयोग क्यों करें?

सिर्फ फॉर लूप का उपयोग क्यों नहीं किया जाता या संग्रहों में सीधे हेरफेर क्यों नहीं किया जाता? खैर, इसके तीन मुख्य कारण हैं:

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

धाराएँ कैसे काम करती हैं? मूल बातें

आइए दो मुख्य प्रकार के स्ट्रीम ऑपरेशन पर एक नज़र डालें: इंटरमीडिएट और टर्मिनल।

1. मध्यवर्ती संचालन

ये वे ऑपरेशन हैं जो डेटा तैयार करते हैं लेकिन तुरंत अंतिम परिणाम नहीं देते हैं। इन्हें "कार्यशाला" चरणों के रूप में सोचें।

• फ़िल्टर()

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

  java
  Copy code
  List numbers = Arrays.asList(1, 2, 3, 4, 5);
  List evenNumbers = numbers.stream()
                                     .filter(n -> n % 2 == 0)
                                     .collect(Collectors.toList());
  // Output: [2, 4]
  
  

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

• नक्शा()

  यह एक ट्रांसफार्मर है। यह एक तत्व लेता है और कुछ अलग लौटाता है। उदाहरण के लिए, यदि आपके पास स्ट्रिंग्स की एक सूची है और आप प्रत्येक स्ट्रिंग की लंबाई चाहते हैं:
  

  java
  Copy code
  List words = Arrays.asList("apple", "banana", "cherry");
  List lengths = words.stream()
                               .map(String::length)
                               .collect(Collectors.toList());
  // Output: [5, 6, 6]
  
  

  मैप क्यों? मैप() का उपयोग तब किया जाता है जब आपको प्रत्येक तत्व को किसी अन्य चीज़ में बदलने की आवश्यकता होती है, जैसे स्ट्रिंग्स की सूची को उनकी लंबाई की सूची में परिवर्तित करना।

• विशिष्ट()

  यह एक डुप्लिकेट फ़िल्टर की तरह है। यह एक स्ट्रीम से डुप्लिकेट तत्वों को हटा देता है।
  

  java
  Copy code
  List numbers = Arrays.asList(1, 2, 2, 3, 4, 4, 5);
  List distinctNumbers = numbers.stream()
                                         .distinct()
                                         .collect(Collectors.toList());
  // Output: [1, 2, 3, 4, 5]
  
  

  अलग क्यों? एक सामान्य सूची में, आपको डुप्लिकेट के लिए मैन्युअल रूप से जांच करने की आवश्यकता होगी। विशिष्ट() यह आपके लिए एक पंक्ति में करता है।

• क्रमबद्ध()

  यह आपके डेटा को प्राकृतिक क्रम में क्रमबद्ध करता है (या यदि आप चाहें तो कस्टम क्रम में)।
  

  java
  Copy code
  List names = Arrays.asList("Charlie", "Alice", "Bob");
  List sortedNames = names.stream()
                                  .sorted()
                                  .collect(Collectors.toList());
  // Output: ["Alice", "Bob", "Charlie"]
  
  

  सॉर्ट क्यों किया गया? सॉर्टिंग लॉजिक को स्वयं लिखने के बजाय, सॉर्टेड() आपके लिए इसे संभालता है।

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

ये वे हैं जो अंतिम परिणाम उत्पन्न करते हैं, और वे संपूर्ण स्ट्रीम के प्रसंस्करण को ट्रिगर करते हैं। इन्हें "निकास बिंदु" के रूप में सोचें।

• इकट्ठा करना()

  यह सबसे आम टर्मिनल ऑपरेशन है। यह स्ट्रीम के परिणामों को इकट्ठा करता है और उन्हें एक सूची, सेट या अन्य संग्रह में रखता है।
  

  java
  Copy code
  List names = Arrays.asList("Charlie", "Alice", "Bob");
  List upperNames = names.stream()
                                 .map(String::toUpperCase)
                                 .collect(Collectors.toList());
  // Output: ["CHARLIE", "ALICE", "BOB"]
  
  

  संकलित क्यों? आप अपनी स्ट्रीम के परिणामों को एक संग्रह में एकत्रित करने के लिए लगभग हमेशा कलेक्ट() का उपयोग करेंगे। यह आपका अंतिम पड़ाव है।

• प्रत्येक के लिए()

  यदि आपको परिणाम की आवश्यकता नहीं है और आप केवल प्रत्येक आइटम पर एक क्रिया करना चाहते हैं (जैसे उन्हें प्रिंट करना), तो forEach() आपका मित्र है।
  

  java
  Copy code
  numbers.stream()
         .forEach(System.out::println);
  
  

  प्रत्येक के लिए क्यों? यह साइड-इफेक्ट्स के लिए बिल्कुल सही है, जैसे कंसोल पर डेटा प्रिंट करना या फ़ाइल पर लिखना।

• कम करना()

  reduce() डेटा का एक समूह लेता है और इसे एक परिणाम में उबाल देता है। उदाहरण के लिए, संख्याओं की सूची का योग करें:
  

  java
  Copy code
  int sum = numbers.stream()
                   .reduce(0, Integer::sum);
  // Output: 15
  
  

  कम क्यों करें? जब आपको मूल्यों को एक ही परिणाम में संयोजित या संचित करने की आवश्यकता होती है, तो कम करें() आपका विकल्प है।

अन्य प्रकार की धाराएँ

सभी स्ट्रीम संग्रह से नहीं बनाई जाती हैं। जावा विभिन्न प्रकार के डेटा को संभालने के लिए अन्य प्रकार की स्ट्रीम प्रदान करता है:

1. इंटस्ट्रीम, लॉन्गस्ट्रीम, डबलस्ट्रीम

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

   उदाहरण:
   

   java
   Copy code
   IntStream intStream = IntStream.of(1, 2, 3, 4);
   int sum = intStream.sum();  // Output: 10
   
   

2. फ़ाइलों की धारा

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

   java
   Copy code
   try (Stream lines = Files.lines(Paths.get("data.txt"))) {
       lines.forEach(System.out::println);
   } catch (IOException e) {
       e.printStackTrace();
   }
   
   

   फ़ाइल स्ट्रीम का उपयोग क्यों करें? बड़ी फ़ाइलों से निपटते समय, सभी डेटा को मेमोरी में लोड करना कुशल नहीं हो सकता है। स्ट्रीम का उपयोग करने से आप इसे लाइन दर लाइन प्रोसेस कर सकते हैं।

स्ट्रीम का उपयोग कब करें?

• ट्रांसफ़ॉर्मिंग डेटा: जब आपको किसी संग्रह के प्रत्येक तत्व को संशोधित करने की आवश्यकता होती है।
• फ़िल्टरिंग: जब आप केवल उस डेटा का चयन करना चाहते हैं जो कुछ शर्तों से मेल खाता है।
• डेटा एकत्र करना: जब आपको किसी संग्रह को एक परिणाम में कम करने की आवश्यकता होती है (उदाहरण के लिए, योग, औसत)।
• समानांतर प्रसंस्करण: स्ट्रीम भी समानता का समर्थन करती हैं। .parallelStream() के साथ, आप तेज़ प्रोसेसिंग के लिए अपने कार्यों को कई थ्रेड्स में विभाजित कर सकते हैं।

स्ट्रीम बनाम लूप्स: केवल लूप्स का उपयोग क्यों न करें?

अच्छा प्रश्न! आइए तुलना करें:

1. पठनीयता: स्ट्रीम के साथ, आप क्या पर ध्यान केंद्रित करते हैं, न कि कैसे पर। लूप्स आपको बहुत सारे अतिरिक्त बॉयलरप्लेट कोड (जैसे काउंटर और कंडीशनल) लिखने पर मजबूर करते हैं।
2. प्रदर्शन: स्ट्रीम को बड़े डेटा को कुशलतापूर्वक संभालने के लिए अनुकूलित किया गया है, विशेष रूप से आलसी मूल्यांकन और समानता के साथ। लूप्स ऐसे आउट-ऑफ़-द-बॉक्स अनुकूलन की पेशकश नहीं करते हैं।
3. लचीलापन: स्ट्रीम आपको स्वच्छ, कार्यात्मक शैली में श्रृंखला संचालन (जैसे फ़िल्टरिंग, मैपिंग और कम करना) की अनुमति देती है। लूप्स के लिए आपको उनमें अधिक तर्क समाहित करने की आवश्यकता होगी।

ऊपर लपेटकर

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

अब जब आप स्ट्रीम की बुनियादी बातों से अच्छी तरह सुसज्जित हैं, तो यहां क्यों रुकें? ट्विटर, लिंक्डइन पर मुझे फ़ॉलो करें, या अधिक जावा युक्तियों के लिए मेरा ब्लॉग देखें जो आपको कुछ ही समय में पेशेवर बना देगा! और यदि आपको यह मार्गदर्शिका उपयोगी लगी, तो इसे अपने साथी डेवलपर्स के साथ साझा करें—क्योंकि साझा करना देखभाल करने वाला है!

इसे आज़माने के लिए तैयार हैं? आइए उस धारा को अपने अगले प्रोजेक्ट में प्रवाहित करें!