Using lambdas with collections java in hindi
जावा प्रोग्रामिंग लैंग्वेज में यूजर डिफाइन लैम्ब्डा एक्सप्रेशन का यूज़ कलेक्शन फ्रेमवर्क से प्रोग्राम डेटा को फ़िल्टर करने, मौजूदा प्रोग्राम डाटा को मॉडिफाई करने और अवेलेबल लूप से लैम्ब्डा एक्सप्रेशन पर स्टार्ट टू एन्ड लूपिंग स्टेप्स को इटरेट करने जैसे कई प्रोग्रामिंग टास्क परफॉर्म करने में किया जाता है। इसी तरह जावा स्ट्रीम्स के साथ और प्रेडिकेट के यूज़ से कंज्यूमर और फंक्शन जैसे फंक्शनल प्रोग्राम इंटरफेस को अप्लाई कर किसी प्रोग्राम में लैम्ब्डा कलेक्शन एक्सप्रेशन को इजी कण्ट्रोल और मैनिपुलेट करने में किया जाता है।
So, let’s use lambda expressions in Java programming to handle multiple situations in a program.
Iterating over a collection using the forEach() loop in Java.
जावा प्रोग्राम में डिफाइन कलेक्शन इंटरफेस और स्ट्रीम इंटरफेस में forEach() लूप मेथड जावा यूजर को लैम्ब्डा एक्सप्रेशन का यूज़ करके कलेक्शन पर forEach() लूप के माध्यम से इटरेट करने में हेल्प करता है।
Example of a forEach loop with Java list data.
import java.util.List;
import java.util.ArrayList;
public class LambdaForEachLoopIllustration {
public static void main(String[] args) {
List<String> bikes = new ArrayList<>();
bikes.add(“Royal Enfield”);
bikes.add(“Bajaj Pulsar”);
bikes.add(“Hero Xtreme”);
bikes.add(“Hero Splendor”);
bikes.add(“TVS Apache RTR”);
// here we Using a lambda expression to print each bikes element with for each loop
bikes.forEach(bike -> System.out.println(bike));
}
}
Here in the forEach loop example.
- यहाँ इस एक्साम्प्ल में forEach() लूप एक्सप्रेशन एक लैम्ब्डा से एक्सप्रेशन लेता है, जो बाइक्स लिस्ट के हर एलिमेंट पर अप्लाई होता है।
- इसी तरह लैम्ब्डा एक्सप्रेशन bike -> System.out.println(bike) में हर बाइक्स एलिमेंट के लिए एग्जीक्यूट होता है।
Filtering collection data using the filter() method in Java.
जावा प्रोग्रामिंग लैंग्वेज में स्ट्रीम एपीआई में filter() फंक्शन मेथड का यूज़ यूजर डिफाइन कंडीशन के आधार पर प्रोग्राम डाटा एलिमेंट को फ़िल्टर कर प्रीव्यू करने में किया जाता है। यह एक Predicate फंक्शनल इंटरफ़ेस को प्रोग्राम में एक्सेप्ट करता है. जो की एक बूलियन-वैल्यू वाला रिप्रजेंटेशन फ़ंक्शन होता है।
Example of filtering a list of numbers in Java.
import java.util.List;
import java.util.ArrayList;
import java.util.stream.Collectors;
public class LambdaElementFilterIllustration {
public static void main(String[] args) {
List<Integer> integers = new ArrayList<>();
integers.add(9);
integers.add(8);
integers.add(3);
integers.add(10);
integers.add(7);
integers.add(4);
// Using a lambda to filter even integers numbers
List<Integer> evenIntegers = integers.stream()
.filter(n -> n % 2 == 0) // here it Lambda filters all even integers in this group
.collect(Collectors.toList());
evenIntegers.forEach(System.out::println); // here it Print filtered even integers on console screen
}
}
Here in this filtering a list example.
- यहाँ filter(n -> n % 2 == 0) एक्साम्प्ल में नंबर्स ऑफ़ इन्टिजर की लिस्ट से इवन नंबर्स को फ़िल्टर करने के लिए लैम्ब्डा एक्सप्रेशन को यूज़ करता है।
- इसी प्रकार collect(Collectors.toList()) फंक्शन मेथड फ़िल्टर किए गए नंबर्स एलिमेंट्स को एक नई लिस्ट में ग्रुप कर डिस्प्ले करता है।
Transforming a Collection Using map() in Java.
जावा प्रोग्राम स्ट्रीम एपीआई में map() फंक्शन मेथड का यूज़ स्ट्रीम के हर एलिमेंट को अन्य फॉर्मेट में मॉडिफाई करने में किया जाता है। यह यूजर से एक फ़ंक्शन फ़ंक्शनल इंटरफ़ेस को एक्सेप्ट करता है. जो यह इंडीकेट करता है कि हर लिस्ट एलिमेंट को कैसे मॉडिफाई करना है।
Example of mapping a list of strings to their lengths in Java.
import java.util.List;
import java.util.ArrayList;
import java.util.stream.Collectors;
public class LambdaMapTestIIllustration {
public static void main(String[] args) {
List<String> programmings = new ArrayList<>();
programmings.add(“Java”);
programmings.add(“Python”);
programmings.add(“Javascript”);
programmings.add(“Swift c”);
programmings.add(“Pearl”);
// here we Using lambda expression to map each sentence to its numeric length
List<Integer> programmingLengths = programmings.stream()
.map(programming -> programming.length()) // here Lambda transforms each sentence to its length
.collect(Collectors.toList());
programmingLengths.forEach(System.out::println); // here it Print sentence lengths in console screen
}
}
Here’s the mapping to a list of strings in the example.
- यहाँ इस एक्साम्प्ल में map(programming -> programming.length()) लिस्ट में हर वर्ड को उसकी लेंथ में कन्वर्ट कर देता है।
- रिजल्ट के रूप में टेक्स्ट की लेंथ को डिस्प्ले करने के लिए इंटीजर की एक नई लिस्ट प्रीव्यू करता है।
Sorting collection data using the sort() function in Java.
जावा यूजर किसी प्रोग्राम में एक कस्टम सॉर्टिंग लॉजिक मेथड प्रोवाइड करने के लिए एक लिस्ट इंटरफ़ेस के लिए sort() फंक्शन मेथड या Comparator के साथ लैम्ब्डा एक्सप्रेशन को अप्लाई कर सकते हैं।
Example of sorting a list of strings alphabetically in Java.
import java.util.List;
import java.util.ArrayList;
public class LambdaSortElementIllustration {
public static void main(String[] args) {
List<String> employees = new ArrayList<>();
employees.add(“Siddhi”);
employees.add(“Bhavishi”);
employees.add(“Harry”);
employees.add(“Disha”);
employees.add(“Amit”);
// here we Using a lambda expression to sort the employee list alphabetically order
employees.sort((employeefirst, employeesecond) -> employeefirst.compareTo(employeesecond));
// here it Print the sorted employee list
employees.forEach(System.out::println);
}
}
Here’s an example of sorting a list of strings alphabetically.
- यहाँ लैम्ब्डा एक्सप्रेशन एक्साम्प्ल में (employeefirst, employeesecond) -> employeefirst.compareTo(employeesecond) फंक्शन मेथड का यूज़ दो स्ट्रिंग्स की आपस में तुलना करने और लिस्ट डाटा को अल्फाबेटिकल आर्डर में सॉर्ट करने में किया जाता है।
- इसके बाद सॉर्ट की गई लिस्ट एलिमेंट डाटा को प्रिंट करने के लिए forEach लूप फंक्शन मेथड का यूज़ किया जाता है।
Reducing a collection using the Java reduce() method.
जावा प्रोग्राम में स्ट्रीम एपीआई में reduce() फंक्शन मेथड का यूज़ हर एलिमेंट्स की स्ट्रीम पर रिडक्शन करने में किया जाता है, जावा यूजर इसमें एक एसोसिएटिव एक्युमुलेशन फ़ंक्शन मेथड का यूज़ करके और एक सिंगल रिज़ल्ट डिस्प्ले करने के लिए। यह प्रोग्राम में एक BinaryOperator फ़ंक्शनल इंटरफ़ेस को एक आर्गुमेंट के रूप में एक्सेप्ट करता है।
Example of adding elements to a Java list.
import java.util.List;
import java.util.ArrayList;
import java.util.Optional;
public class LambdaReduceIllustration {
public static void main(String[] args) {
List<Integer> integers = new ArrayList<>();
integers.add(7);
integers.add(9);
integers.add(3);
integers.add(8);
integers.add(2);
integers.add(0);
// here we use a lambda expression to total all numbers in the list
Optional<Integer> total = integers.stream()
.reduce((p, q) -> p + q);
// here it Output the total all integers
total.ifPresent(System.out::println);
}
}
Here in the Reducing a Collection example.
- यहाँ इस एक्साम्प्ल में reduce((p, q) -> p + q) इन्टिजर नंबर लिस्ट में सभी इंटीजर का टोटल करने के लिए एक लैम्ब्डा एक्सप्रेशन का यूज़ करता है।
- रिजल्ट के रूप में यहाँ एक Optional<Integer> डिफाइन है, क्योंकि यदि लिस्ट एम्प्टी है. तो reduce() फंक्शन एक एम्प्टी रिजल्ट डिस्प्ले कर सकता है।
Using Collectors for Complex Operations in Java.
जावा प्रोग्राम में कलेक्टर यूटिलिटी क्लास स्ट्रीम से रिजल्ट कलेक्ट करने के लिए मल्टीप्ल मेथड प्रोवाइड करता है। जावा में कलेक्टर यूटिलिटी क्लास का यूज़ कलेक्शन डाटा एलिमेंट को ग्रुप करने, पार्टीशन करने, या डिटेल समराइज़ करने में किया जाता है।
Example of grouping elements using the groupingBy() method in Java.
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.stream.Collectors;
public class LambdaGroupByCollectIllustration {
public static void main(String[] args) {
List<String> mobiles = new ArrayList<>();
mobiles.add(“Apple iPhone”);
mobiles.add(“Samsung Galaxy”);
mobiles.add(“Google Pixel”);
mobiles.add(“Motorola”);
mobiles.add(“Huawei Pura”);
mobiles.add(“OnePlus”);
// here it Grouping mobiles by their first letter using lambda expression
Map<Character, List<String>> groupedmobiles = mobiles.stream()
.collect(Collectors.groupingBy(mobile -> mobile.charAt(0)));
groupedmobiles.forEach((key, data) -> {
System.out.println(key + “: ” + data);
});
}
}
Here, grouping elements are used in the groupingBy() example.
- यहाँ इस एक्साम्प्ल में groupingBy(mobile -> mobile.charAt(0)) मोबाइल्स को उनके फर्स्ट करैक्टर आर्डर में ग्रुप करता है।
- इसमें Collectors.groupingBy() मेथड एक मैप प्रोवाइड करता है, जिसमे एक फर्स्ट करैक्टर वैल्यू है, और वैल्यू उस करैक्टर से स्टार्ट होने वाले मोबाइल्स की लिस्ट डिस्प्ले करता है।
Using the allMatch(), anyMatch(), and noneMatch() methods in Java.
जावा प्रोग्रामिंग लैंग्वेज में allMatch(), anyMatch(), and noneMatch() में इन फंक्शन मेथड का यूज़ या टेस्ट करने में किया जाता है कि मौजूदा कलेक्शन डाटा एलिमेंट में सभी, कोई भी, या कोई भी एलिमेंट दिए गए प्रेडिकेट को कम्पलीट करता है, या नहीं है।
Example of checking whether all elements are even in a Java program.
import java.util.List;
import java.util.ArrayList;
public class LambdaMatchIllustration {
public static void main(String[] args) {
List<Integer> integers = new ArrayList<>();
integers.add(10);
integers.add(22);
integers.add(44);
integers.add(88);
integers.add(100);
// here we use lambda expression to check if all integers are even or not
boolean groupEven = integers.stream()
.allMatch(number -> number % 2 == 0);
System.out.println(“All given integers is even number – ” + groupEven);
}
}
Here’s checking whether all elements are even in the example.
- यहाँ इस प्रोग्राम में allMatch(num -> num % 2 == 0) यह चेक करता है कि लिस्ट में दिए गए सभी नंबर ईवन हैं, या नहीं है।
- रिज़ल्ट के रूप में एक बूलियन वैल्यू है, जो एक्टिव प्रोग्राम में यह इंडीकेट करता है कि मौजूदा लैम्ब्डा एक्सप्रेशन में सभी एलिमेंट के लिए कंडीशन सही है, या नहीं है।
A detailed summary of lambda expressions and collections operations in the Java language.
- forEach() – यह लूप लैम्ब्डा एक्सप्रेशन में कलेक्शन डाटा एलिमेंट को स्टार्ट टू एन्ड तक इटरेट करता है, और दिए गए हर कलेक्शन एलिमेंट पर एक एक्शन को परफॉर्म करता है।
- filter() – यह लैम्ब्डा एक्सप्रेशन में दिए गए यूजर डिफाइन कंडीशन के आधार पर कलेक्शन एलिमेंट को जरूरत के अनुसार फ़िल्टर करता है।
- map() – यह लैम्ब्डा एक्सप्रेशन में कलेक्शन डाटा में हर एलिमेंट को ट्रांसफ़ॉर्म कर डिस्प्ले करता है।
- sort() – यह लैम्ब्डा एक्सप्रेशन में दिए गए कलेक्शन डाटा में एलिमेंट को एक स्पेसिफिक आर्डर में सॉर्ट कर डिस्प्ले करता है।
- reduce() – यह लैम्ब्डा एक्सप्रेशन में कलेक्शन डाटा को एक सिंगल वैल्यू में रिड्यूस कर डिस्प्ले करता है।
- collect() – यह लैम्ब्डा एक्सप्रेशन में कलेक्शन एलिमेंट के रिज़ल्ट को लिस्ट, सेट्स, मैप्स आदि जैसे अलग-अलग टाइप में कलेक्ट कर डिस्प्ले करता है।
- groupingBy() – यह फंक्शन लैम्ब्डा एक्सप्रेशन में यूजर डिफाइन कंडीशन के आधार पर कलेक्शन एलिमेंट को ग्रुप करता है।
- anyMatch(), allMatch(), noneMatch() – यह लैम्ब्डा एक्सप्रेशन में चेक करता है कि कोई भी, सभी, या कोई भी मौजूदा लिस्ट कलेक्शन एलिमेंट कंडीशन को कम्पलीट करता है, या नहीं है।
