S13L07 - लैम्ब्डा अभिव्यक्ति के साथ प्रेडिकेट्स का अवलोकन

html

Java Predicates में महारत: एक व्यापक मार्गदर्शिका
सामग्री तालिका

परिचय .............................................................. 2
Java में Predicates को समझना ............ 3

2.1 What is a Predicate? ............................................................ 3
2.2 Types of Predicates ............................................................. 4


Lambda Expressions के साथ Predicates को लागू करना ................................................................................................. 5

3.1 Creating an IntPredicate ...................................................... 5
3.2 Simplifying Tests with Lambda Expressions .............................. 6


Advanced Predicate Operations ............... 7

4.1 Logical Operations: AND, OR, and NOT ................................... 7
4.2 Combining Predicates for Complex Conditions ........................... 8


व्यावहारिक उदाहरण और उपयोग के मामले ........... 9

5.1 Validating User Input ............................................................ 9
5.2 Filtering Collections ............................................................... 10


निष्कर्ष ........................................................................ 11
अतिरिक्त संसाधन ...................................... 12

परिचय
"Mastering Java Predicates: A Comprehensive Guide" में आपका स्वागत है। Java प्रोग्रामिंग की दुनिया में, predicates शक्तिशाली उपकरण हैं जो आपके कोड के अंदर स्थितियों का मूल्यांकन करने और निर्णय लेने की प्रक्रिया को सरल बनाते हैं। चाहे आप Java के क्षेत्र में कदम रख रहे एक शुरुआती हों या अपने कौशल को सुधारना चाहते एक अनुभवी डेवलपर, predicates को समझना आपके कोड को साफ, कुशल और पठनीय बनाने की आपकी क्षमता को महत्वपूर्ण रूप से बढ़ा सकता है।
यह eBook Java में predicates की अवधारणा में गहराई से उतरता है, उनके प्रकार, lambda expressions के उपयोग से लागू करने और उन्नत संचालन की खोज करता है। इस मार्गदर्शिका के अंत तक, आपके पास predicates का लाभ उठाने का ठोस ज्ञान होगा ताकि आप अपने प्रोग्रामिंग कार्यों को सरल बना सकें, जिससे आपके अनुप्रयोग अधिक मजबूत और बनाए रखने योग्य बनें।
मुख्य बिंदु:

predicates का परिचय और Java में उनका महत्व
विभिन्न प्रकार के predicates का विस्तृत अन्वेषण
lambda expressions का उपयोग करके predicates का चरण-दर-चरण कार्यान्वयन
predicates के साथ उन्नत तार्किक संचालन
व्यावहारिक उदाहरण और वास्तविक दुनिया के उपयोग के मामले
अधिक सीखने के लिए सर्वश्रेष्ठ प्रथाएँ और अतिरिक्त संसाधन

Java predicates में महारत हासिल करने और अपनी प्रोग्रामिंग कुशलता को उच्च स्तर पर ले जाने के इस यात्रा पर चलें।
Java में Predicates को समझना
Predicate क्या है?
Java में, एक predicate एक functional interface है जो एक एकल तर्क फंक्शन का प्रतिनिधित्व करता है जो एक boolean मान लौटाता है। मूल रूप से, predicates का उपयोग शर्तों का मूल्यांकन करने और यह निर्धारित करने के लिए किया जाता है कि क्या एक दिया गया इनपुट कुछ मानदंडों को संतुष्ट करता है। वे उन परिदृश्यों में एक महत्वपूर्ण भूमिका निभाते हैं जहां आपको विशेष शर्तों के आधार पर डेटा को फिल्टर, परीक्षण, या सत्यापित करना होता है।
Predicate<T> इंटरफेस java.util.function पैकेज में स्थित होता है और इसे निम्नलिखित रूप में परिभाषित किया गया है:




		
		
			
			
Java
			
			
@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}

			
				
					
				
					1
2
3
4
5
6
				
						 
@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}
 
					
				
			
		


यहाँ, T predicate के इनपुट के प्रकार का प्रतिनिधित्व करता है। मुख्य विधि test(T t) दिए गए तर्क पर predicate का मूल्यांकन करती है और परिभाषित शर्त के आधार पर true या false लौटाती है।
Predicates के प्रकार
Java विभिन्न डेटा प्रकारों के लिए अनुकूलित विभिन्न प्रकार के predicates प्रदान करता है, जो प्रदर्शन और प्रकार सुरक्षा को बढ़ाता है। सबसे सामान्यतः उपयोग किए जाने वाले predicates में शामिल हैं:

Generic Predicate (Predicate<T>): किसी भी ऑब्जेक्ट प्रकार के साथ काम करता है।
IntPredicate (IntPredicate): int प्रिमिटिव्स के लिए विशेषीकृत।
LongPredicate (LongPredicate): long प्रिमिटिव्स के लिए विशेषीकृत।
DoublePredicate (DoublePredicate): double प्रिमिटिव्स के लिए विशेषीकृत।

उपयुक्त predicate प्रकार चुनकर, आप विशेष डेटा प्रकारों के लिए अपने कोड को अनुकूलित कर सकते हैं, जिससे प्रिमिटिव प्रकारों के बॉक्सिंग और अनबॉक्सिंग के ओवरहेड को कम किया जा सके।


Predicate प्रकार
विवरण
विशेषीकृत के लिए


Predicate<T>
किसी भी ऑब्जेक्ट प्रकार के लिए सामान्य predicate
किसी भी ऑब्जेक्ट प्रकार


IntPredicate
int मानों के लिए predicate
int प्रिमिटिव्स


LongPredicate
long मानों के लिए predicate
long प्रिमिटिव्स


DoublePredicate
double मानों के लिए predicate
double प्रिमिटिव्स


इस मार्गदर्शिका में, हम IntPredicate पर ध्यान केंद्रित करेंगे यह दिखाने के लिए कि कैसे predicates प्रिमिटिव डेटा प्रकारों के साथ काम करते हैं, जिससे कुशल और प्रकार-सुरक्षित संचालन सुनिश्चित हो सकें।
Lambda Expressions के साथ Predicates को लागू करना
IntPredicate बनाना
एक predicate को लागू करने में उस शर्त को परिभाषित करना शामिल होता है जिसे इनपुट को संतुष्ट करना होता है। चलिए एक IntPredicate बनाने का पता लगाते हैं जो परीक्षण करता है कि दिया गया integer 18 से कम है या नहीं।




		
		
			
			
Java
			
			
import java.util.function.IntPredicate;

public class Main {
    public static void main(String[] args) {
        IntPredicate isLessThan18 = new IntPredicate() {
            @Override
            public boolean test(int value) {
                if (value < 18) {
                    return true;
                } else {
                    return false;
                }
            }
        };

        System.out.println(isLessThan18.test(10)); // Output: true
        System.out.println(isLessThan18.test(20)); // Output: false
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
				
						 
import java.util.function.IntPredicate;
 
public class Main {
    public static void main(String[] args) {
        IntPredicate isLessThan18 = new IntPredicate() {
            @Override
            public boolean test(int value) {
                if (value < 18) {
                    return true;
                } else {
                    return false;
                }
            }
        };
 
        System.out.println(isLessThan18.test(10)); // Output: true
        System.out.println(isLessThan18.test(20)); // Output: false
    }
}
 
					
				
			
		


स्पष्टीकरण:

Import Statement: हम IntPredicate को java.util.function से आयात करते हैं।
Creating the Predicate: हम एक IntPredicate का उदाहरण बनाते हैं जिसका नाम isLessThan18 है। यह predicate test मेथड को ओवरराइड करता है ताकि यह जांच सके कि इनपुट value 18 से कम है या नहीं।
Testing the Predicate: हम predicate को मान 10 और 20 के साथ परीक्षण करते हैं, जो क्रमशः true और false लौटाते हैं।

Lambda Expressions के साथ परीक्षणों को सरल बनाना
भले ही ऊपर का कार्यान्वयन काम करता है, Java की lambda expressions predicates को परिभाषित करने के लिए एक अधिक संक्षिप्त और पठनीय तरीका प्रदान करती हैं। चलिए पिछली उदाहरण को एक lambda expression का उपयोग करके पुनर्संयोजित करते हैं।




		
		
			
			
Java
			
			
import java.util.function.IntPredicate;

public class Main {
    public static void main(String[] args) {
        IntPredicate isLessThan18 = value -> value < 18;

        System.out.println(isLessThan18.test(10)); // Output: true
        System.out.println(isLessThan18.test(20)); // Output: false
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						 
import java.util.function.IntPredicate;
 
public class Main {
    public static void main(String[] args) {
        IntPredicate isLessThan18 = value -> value < 18;
 
        System.out.println(isLessThan18.test(10)); // Output: true
        System.out.println(isLessThan18.test(20)); // Output: false
    }
}
 
					
				
			
		


स्पष्टीकरण:

Lambda Expression: एक अज्ञात आंतरिक क्लास बनाने के बजाय, हम predicate को परिभाषित करने के लिए lambda expression value -> value < 18 का उपयोग करते हैं।
Conciseness: यह तरीका boilerplate कोड को कम करता है, जिससे predicate की परिभाषा अधिक संक्षिप्त और पढ़ने में आसान हो जाती है।

Advanced Predicate Operations
Logical Operations: AND, OR, and NOT
Java का Predicate इंटरफेस default methods जैसे and(), or(), और negate() प्रदान करता है ताकि predicates को संयोजित किया जा सके।

and(Predicate other): दो predicates को logical AND के साथ संयोजित करता है।
or(Predicate other): दो predicates को logical OR के साथ संयोजित करता है।
negate(): predicate के परिणाम को उलट देता है।





		
		
			
			
Java
			
			
import java.util.function.IntPredicate;

public class Main {
    public static void main(String[] args) {
        IntPredicate isLessThan18 = value -> value < 18;
        IntPredicate isGreaterThan18 = value -> value > 18;

        // AND operation
        IntPredicate between15And20 = isLessThan18.and(isGreaterThan18);
        System.out.println(between15And20.test(17)); // Output: false

        // OR operation
        IntPredicate isTeenager = isLessThan18.or(isGreaterThan18);
        System.out.println(isTeenager.test(20)); // Output: true

        // NOT operation
        IntPredicate isNotLessThan18 = isLessThan18.negate();
        System.out.println(isNotLessThan18.test(10)); // Output: false
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
				
						 
import java.util.function.IntPredicate;
 
public class Main {
    public static void main(String[] args) {
        IntPredicate isLessThan18 = value -> value < 18;
        IntPredicate isGreaterThan18 = value -> value > 18;
 
        // AND operation
        IntPredicate between15And20 = isLessThan18.and(isGreaterThan18);
        System.out.println(between15And20.test(17)); // Output: false
 
        // OR operation
        IntPredicate isTeenager = isLessThan18.or(isGreaterThan18);
        System.out.println(isTeenager.test(20)); // Output: true
 
        // NOT operation
        IntPredicate isNotLessThan18 = isLessThan18.negate();
        System.out.println(isNotLessThan18.test(10)); // Output: false
    }
}
 
					
				
			
		


स्पष्टीकरण:

AND Operation: between15And20 दो predicates isLessThan18 और isGreaterThan18 को and() का उपयोग करके संयोजित करता है। क्योंकि एक संख्या एक साथ 18 से कम और अधिक हो नहीं सकती, यह हमेशा false लौटाता है।
OR Operation: isTeenager दोनों predicates को or() का उपयोग करके संयोजित करता है। यह true लौटाता है अगर किसी भी शर्त true हो।
NOT Operation: isNotLessThan18 predicate isLessThan18 को उलट देता है, इसके परिणाम को विपरीत कर देता है।

जटिल शर्तों के लिए Predicates को संयोजित करना
predicates को संयोजित करके, आप विशिष्ट आवश्यकताओं के अनुरूप जटिल शर्तें बना सकते हैं। चलिए एक predicate बनाते हैं जो जांचता है कि एक संख्या 10 और 20 के बीच है या नहीं।




		
		
			
			
Java
			
			
import java.util.function.IntPredicate;

public class Main {
    public static void main(String[] args) {
        IntPredicate isGreaterThan10 = value -> value > 10;
        IntPredicate isLessThan20 = value -> value < 20;

        IntPredicate isBetween10And20 = isGreaterThan10.and(isLessThan20);

        System.out.println(isBetween10And20.test(15)); // Output: true
        System.out.println(isBetween10And20.test(25)); // Output: false
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
				
						 
import java.util.function.IntPredicate;
 
public class Main {
    public static void main(String[] args) {
        IntPredicate isGreaterThan10 = value -> value > 10;
        IntPredicate isLessThan20 = value -> value < 20;
 
        IntPredicate isBetween10And20 = isGreaterThan10.and(isLessThan20);
 
        System.out.println(isBetween10And20.test(15)); // Output: true
        System.out.println(isBetween10And20.test(25)); // Output: false
    }
}
 
					
				
			
		


स्पष्टीकरण:

Individually Define Predicates: हम isGreaterThan10 और isLessThan20 को व्यक्तिगत शर्तों की जांच करने के लिए परिभाषित करते हैं।
Combining with AND: and() का उपयोग करके, isBetween10And20 केवल तभी true होता है जब दोनों शर्तें पूरी हो।

व्यावहारिक उदाहरण और उपयोग के मामले
predicates को समझना सिर्फ थ्योरी तक सीमित नहीं है; उन्हें वास्तविक दुनिया की परिदृश्यों में लागू करना उनकी उपयोगिता और प्रभावशीलता को दर्शाता है। चलिए कुछ व्यावहारिक उपयोग के मामलों की खोज करते हैं जहां predicates अद्वितीय होते हैं।
यूजर इनपुट को वैध करना (Validating User Input)
कल्पना करें कि आप एक ऐसा एप्लिकेशन विकसित कर रहे हैं जिसमें यूजर इनपुट को विशिष्ट मानदंडों के आधार पर सत्यापित करने की आवश्यकता होती है। predicates इस सत्यापन प्रक्रिया को सरल बना सकते हैं।




		
		
			
			
Java
			
			
import java.util.function.Predicate;

public class InputValidator {
    public static void main(String[] args) {
        Predicate<String> isNotEmpty = input -> !input.isEmpty();
        Predicate<String> hasMinimumLength = input -> input.length() >= 5;
        Predicate<String> containsSpecialCharacter = input -> input.matches(".*[!@#$%^&*()].*");

        Predicate<String> isValid = isNotEmpty.and(hasMinimumLength).and(containsSpecialCharacter);

        String userInput1 = "Passw@rd";
        String userInput2 = "1234";

        System.out.println(isValid.test(userInput1)); // Output: true
        System.out.println(isValid.test(userInput2)); // Output: false
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
				
						 
import java.util.function.Predicate;
 
public class InputValidator {
    public static void main(String[] args) {
        Predicate<String> isNotEmpty = input -> !input.isEmpty();
        Predicate<String> hasMinimumLength = input -> input.length() >= 5;
        Predicate<String> containsSpecialCharacter = input -> input.matches(".*[!@#$%^&*()].*");
 
        Predicate<String> isValid = isNotEmpty.and(hasMinimumLength).and(containsSpecialCharacter);
 
        String userInput1 = "Passw@rd";
        String userInput2 = "1234";
 
        System.out.println(isValid.test(userInput1)); // Output: true
        System.out.println(isValid.test(userInput2)); // Output: false
    }
}
 
					
				
			
		


स्पष्टीकरण:

पिधान करने वाले Predicates: हम predicates को परिभाषित करते हैं जो जांचते हैं कि इनपुट खाली नहीं है, कम से कम 5 वर्ण लंबा है, और इसमें कम से कम एक विशेष वर्ण है।
Predicates को संयोजित करना: isValid predicate इन शर्तों को and() का उपयोग करके संयोजित करता है।
यूजर इनपुट का परीक्षण करना:

userInput1 = "Passw@rd" सभी शर्तों को पूरा करता है, इसलिए isValid.test(userInput1) true लौटाता है।
userInput2 = "1234" न्यूनतम लंबाई और विशेष वर्ण शर्तों को पूरा नहीं करता है, जिससे false प्राप्त होता है।



कलेक्शंस को फिल्टर करना (Filtering Collections)
cOllections के साथ काम करते समय predicates अमूल्य होते हैं, विशिष्ट मानदंडों के आधार पर कुशल filtrations की अनुमति देते हैं।




		
		
			
			
Java
			
			
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class CollectionFilter {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(5, 12, 17, 22, 29, 10, 15);

        Predicate<Integer> isEven = number -> number % 2 == 0;
        Predicate<Integer> isGreaterThan15 = number -> number > 15;

        List<Integer> filteredNumbers = numbers.stream()
                .filter(isEven.and(isGreaterThan15))
                .collect(Collectors.toList());

        System.out.println(filteredNumbers); // Output: [22]
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
				
						 
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;
 
public class CollectionFilter {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(5, 12, 17, 22, 29, 10, 15);
 
        Predicate<Integer> isEven = number -> number % 2 == 0;
        Predicate<Integer> isGreaterThan15 = number -> number > 15;
 
        List<Integer> filteredNumbers = numbers.stream()
                .filter(isEven.and(isGreaterThan15))
                .collect(Collectors.toList());
 
        System.out.println(filteredNumbers); // Output: [22]
    }
}
 
					
				
			
		


स्पष्टीकरण:

पिधान करने वाले Predicates: हम predicates को परिभाषित करते हैं जो जांचते हैं कि कोई संख्या जुद्ध है और 15 से बड़ी है।
कलेक्शन को फिल्टर करना: Java Streams का उपयोग करके, हम numbers सूची को isEven.and(isGreaterThan15) को लागू करते हुए फिल्टर करते हैं।
परिणाम: केवल 22 दोनों शर्तों को पूरा करता है, जिससे [22] वाली सूची बनती है।

निष्कर्ष
predicates Java के functional programming paradigm में एक मौलिक घटक हैं, जो आपके कोड के अंदर स्थितियों का मूल्यांकन करने और निर्णय लेने के लिए एक संक्षिप्त और शक्तिशाली तरीका प्रदान करते हैं। predicates का लाभ उठाकर, विशेषकर lambda expressions के साथ, डेवलपर्स अधिक पठनीय, कुशल, और बनाए रखने योग्य कोड लिख सकते हैं।
मुख्य बातें:

लचीलापन (Flexibility): predicates को logical operators (and, or, negate) का उपयोग करके संयोजित किया जा सकता है ताकि जटिल शर्तें बन सकें।
प्रकार सुरक्षा (Type Safety): IntPredicate जैसे विशेष predicates प्रिमिटिव डेटा प्रकारों के साथ काम करते समय प्रकार सुरक्षा और प्रदर्शन को बढ़ाते हैं।
संक्षिप्तता (Conciseness): lambda expressions predicates को परिभाषित करने में सरलता प्रदान करती हैं, boilerplate कोड को कम करती हैं और पठनीयता बढ़ाती हैं।
व्यावहारिकता (Practicality): यूजर इनपुट को वैध करने से लेकर कलेक्शंस को फिल्टर करने तक, predicates विभिन्न प्रोग्रामिंग परिदृश्यों में उपयोग किए जाते हैं।

जैसे-जैसे आप अपनी Java कुशलताओं को विकसित करना जारी रखते हैं, predicates को अपने कोडिंग प्रथाओं में शामिल करने से निस्संदेह अधिक साफ और कुशल कोड लिखने में योगदान मिलेगा। predicates की शक्ति को अपनाएं और प्रोग्रामिंग दक्षता के नए स्तरों का अनलॉक करें।
अतिरिक्त संसाधन

Official Java Documentation on Predicate
Java Lambda Expressions Tutorial
Functional Programming in Java
Stream API and Predicates
Effective Java by Joshua Bloch

Note: यह लेख AI द्वारा उत्पन्न किया गया है।
Predicate प्रकार	विवरण	विशेषीकृत के लिए
Predicate<T>	किसी भी ऑब्जेक्ट प्रकार के लिए सामान्य predicate	किसी भी ऑब्जेक्ट प्रकार
IntPredicate	int मानों के लिए predicate	int प्रिमिटिव्स
LongPredicate	long मानों के लिए predicate	long प्रिमिटिव्स
DoublePredicate	double मानों के लिए predicate	double प्रिमिटिव्स