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

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

स्ट्रीम का उपयोग करने का एक उदाहरण नामों की सूची को वर्णमाला क्रम में क्रमबद्ध करना है। हम नामों की एक सूची बना सकते हैं और फिर उन्हें क्रमबद्ध करने के लिए स्ट्रीम का उपयोग कर सकते हैं जैसा कि नीचे दिखाया गया है:

सूची नाम = Arrays.asList('जॉन', 'मैरी', 'डेविड', 'एमिली', 'टॉम');
name.stream().sorted().forEach(System.out::println); //आउटपुट: डेविड, एमिली, जॉन, मैरी, टॉम

यहां, हमने सूची में स्ट्रीम() विधि का उपयोग करके एक स्ट्रीम बनाई है। फिर हमने स्ट्रीम में तत्वों को प्राकृतिक क्रम में क्रमबद्ध करने के लिए sorted() विधि लागू की है। अंत में, स्ट्रीम में प्रत्येक तत्व को प्रिंट करने के लिए forEach() विधि का उपयोग किया जाता है।

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

स्ट्रीम के साथ लैम्ब्डा का उपयोग करने के लिए, हमें कार्यात्मक इंटरफेस की अवधारणा को समझने की आवश्यकता है। ये ऐसे इंटरफ़ेस हैं जिनमें केवल एक अमूर्त विधि है। लैम्ब्डा अभिव्यक्तियों का उपयोग कार्यात्मक इंटरफ़ेस की अमूर्त विधि के लिए एक ठोस कार्यान्वयन प्रदान करने के लिए किया जा सकता है।

लैम्ब्डा का उपयोग करके नामों की सूची क्रमबद्ध करें
उपरोक्त उदाहरण के आधार पर, आइए लैम्ब्डा का उपयोग करके नामों को अवरोही क्रम में क्रमबद्ध करें।

सूची नाम = Arrays.asList('जॉन', 'मैरी', 'डेविड', 'एमिली', 'टॉम');
Names.stream().sorted((a, b) -> b.compareTo(a)).forEach(System.out::println)); //आउटपुट: टॉम, मैरी, जॉन, एमिली, डेविड

यहां, हमने sorted() विधि के तर्क के रूप में लैम्ब्डा एक्सप्रेशन का उपयोग किया है। यह लैम्ब्डा फ़ंक्शन दो तर्कों (ए और बी) को स्वीकार करता है और उनकी तुलना करता है, तुलना के आधार पर सकारात्मक, नकारात्मक या शून्य मान लौटाता है। यह हमें तत्वों पर CompareTo() विधि का उपयोग करके तत्वों को अवरोही क्रम में क्रमबद्ध करने की अनुमति देता है।

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

सूची फ़िल्टर किए गए नाम = नाम.स्ट्रीम()
.filter(name -> name.length() > 4) //केवल लंबाई वाले नाम रखें > 4
.collect(कलेक्टर.toList()); //फ़िल्टर किए गए नामों की सूची लौटाएं

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

स्ट्रीम पर अन्य ऑपरेशन
सॉर्टिंग और फ़िल्टरिंग के अलावा, अन्य ऑपरेशन भी हैं जो मैपिंग, रिड्यूसिंग और पुनरावृत्ति जैसे स्ट्रीम पर किए जा सकते हैं। ये ऑपरेशन हमें एक स्ट्रीम में तत्वों को क्रमशः रूपांतरित करने, कम करने और पुनरावृत्त करने की अनुमति देते हैं।

संख्याओं की एक धारा को मैप करें और कम करें
मान लीजिए कि हमारे पास संख्याओं की एक सूची है और हम सभी सम संख्याओं का योग ज्ञात करना चाहते हैं। हम इसे मानचित्र() और कम() विधियों का उपयोग करके कर सकते हैं।

सूची संख्याएँ = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
पूर्णांक योग = संख्याएँ.स्ट्रीम()
.filter(num -> num % 2 == 0) //विषम संख्याओं को फ़िल्टर करें
.map(num -> num * 2) // सम संख्याओं को दोगुना करें
.reduce(0, (a, b) -> a b); //सभी संख्याओं को एक साथ जोड़ें

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

स्ट्रीम पर संचालन का पुन: उपयोग करें
कुछ मामलों में, हमें कई स्ट्रीम पर एक ही कार्यात्मक ऑपरेशन का उपयोग करने की आवश्यकता हो सकती है। एक ही कोड को बार-बार लिखने से बचने के लिए, हम एक कार्यात्मक इंटरफ़ेस बना सकते हैं और इसे तरीकों के तर्क के रूप में पास कर सकते हैं।

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

स्थैतिक वर्ग LastNameComparator Comparator को लागू करता है {
@ओवरराइड
सार्वजनिक पूर्णांक तुलना(स्ट्रिंग नाम1, स्ट्रिंग नाम2) {
स्ट्रिंग[] भाग1 = name1.स्प्लिट(" ");
स्ट्रिंग अंतिमनाम1 = भाग1[भाग1.लंबाई - 1];
स्ट्रिंग[] भाग2 = name2.स्प्लिट(" ");
स्ट्रिंग अंतिमनाम2 = भाग2[भाग2.लंबाई - 1];
LastName2.compareTo(lastName1);
पर लौटें }
}

name.stream().sorted(new LastNameComparator()).forEach(System.out::println); //आउटपुट: एमिली, डेविड, जॉन, मैरी, टॉम

यहां, हमने नामों को अंतिम नाम से क्रमबद्ध करने के लिए sorted() विधि के तर्क के रूप में LastNameComparator को पारित किया है।

निष्कर्ष
जावा में स्ट्रीम और लैम्ब्डा संग्रह पर कार्यात्मक संचालन करने के लिए एक शक्तिशाली और कुशल तरीका प्रदान करते हैं। वे डेवलपर्स को ऐसा कोड लिखने में सक्षम बनाते हैं जो साफ़, संक्षिप्त और पुन: प्रयोज्य हो। स्ट्रीम और लैम्ब्डा की अवधारणाओं को समझकर, हम अपने समग्र कोडिंग कौशल में सुधार कर सकते हैं और अधिक कुशल कोड लिख सकते हैं।

अपने जावा कौशल को बेहतर बनाने का एक प्रभावी तरीका नवीनतम जावा प्रमाणन प्राप्त करना और MyExamCloud पर उपलब्ध 1Z0-830 अभ्यास परीक्षणों का उपयोग करना है।