उदाहरणांसह Java Predicate

सामान्यतः predicate म्हणजे एक विधान जे मूल्य सत्य किंवा असत्य असू शकते हे निर्धारित करते. प्रोग्रॅमिंगमध्ये बूलियन व्हॅल्यू मिळवणाऱ्या एका युक्तिवादासह मीन फंक्शन्सचा अंदाज लावला जातो. फंक्शनल इंटरफेस प्रेडीकेट Java 8 मध्ये साकारले गेले. "फंक्शनल" म्हणजे त्यात फक्त एक अमूर्त पद्धत आहे. ते वितर्क स्वीकारते आणि बुलियन परत करते. Java मध्ये, फंक्शनल इंटरफेसचा वापर लॅम्बडा एक्सप्रेशन्स, कन्स्ट्रक्टर आणि मेथड संदर्भ हाताळण्यासाठी केला जातो. सहसा Java 8 Predicate चा वापर ऑब्जेक्ट्सच्या संग्रहासाठी फिल्टर लागू करण्यासाठी केला जातो. चला त्याचे मुख्य अनुप्रयोग आणि मोठ्या प्रमाणावर वापरल्या जाणार्‍या पद्धतींवर एक नजर टाकूया, तसेच काही सराव समस्यांचे निराकरण करूया.

विकसक प्रीडिकेट का वापरतात

मूलभूतपणे, विकासक पूर्वनिर्धारित निकषांवर आधारित आयटमचे मूल्यमापन करणे आणि बुलियन मूल्य परत करणे समाविष्ट असलेल्या कोणत्याही कार्यांसाठी अंदाज वापरू शकतात. विकासक प्रेडिकेट वापरून हाताळत असलेल्या सोप्या कार्यांची उदाहरणे येथे आहेत:

• पूर्णांकांचा संच फिल्टर करणे.
• डेटा अनेक पूर्वनिर्धारित अटींशी सुसंगत आहे याची खात्री करून याद्या क्रमवारी लावणे (उदा. किंमत आणि वजन अटी सेट करून वस्तूंची श्रेणी आयोजित करणे).
• समवर्ती प्रोग्रामिंगमध्ये युटिलिटी पॅकेजेस वापरणे.

सॉफ्टवेअर चाचणीमध्ये प्रेडिकेट हे एक महत्त्वाचे वैशिष्ट्य आहे. कार्यात्मक इंटरफेस चाचणीसाठी युनिट वेगळे करणे सोपे करते, अॅप कोडची वाचनीयता आणि व्यवस्थापनक्षमता सुधारते.

जावा मध्ये प्रेडिकेट सिंटॅक्स

java.util.function.Predicate जावा 8 मध्ये Lambda मधील मूल्यांकन छाप हाताळण्याचा पर्यायी मार्ग म्हणून सादर केला गेला. इंटरफेसचे मानक दृश्य हे Predicate<T> आहे , जेथे T हे बुलियन मूल्य परत करणारे एकल वितर्क आहे. Java Predicates मध्ये फंक्शनल (अमूर्त) पद्धत चाचणी (ऑब्जेक्ट) असते जी दिलेल्या ऑब्जेक्टवर या प्रेडिकेटचे मूल्यांकन करते.

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

येथे एक साधे प्रेडिकेट लिहिण्याचे उदाहरण आहे जे “पेक्षा मोठे”, “पेक्षा कमी” अटींवर आधारित पूर्णांक फिल्टर करते.

// An example of a simple Java predicate
  
import java.util.function.Predicate; 
public class PredicateExample { 
    public static void main(String[] args) 
    { 
        // Creating predicate 
        Predicate<Integer> lesserThan = i -> (i < 18);  
  
        // Calling Predicate method 
        System.out.println(lesserThan.test(10));  
    }
}

आउटपुट सत्य असेल कारण 10 < 18. प्रीडिकेट इन filter() सह आणखी एक उदाहरण . Predicate वयोगटाच्या सूचीमधून सर्व प्रौढांना फिल्टर करण्यात मदत करते.

  import java.util.List;
  import java.util.function.Predicate;

  public class PredicateExample {
      public static void main(String[] args) {
          List<Integer> ages = List.of(17, 18, 19, 28, 18, 28, 46, 7, 8, 9, 21, 12);
          NotLessThan18<Integer> isAdult = new NotLessThan18<>();
          ages.stream().filter(isAdult).forEach(System.out::println);
      }
  }



class NotLessThan18<E> implements Predicate<Integer> {

      @Override
      public boolean test(Integer v) {
          Integer ADULT = 18;
          return v >= ADULT;
      }
  }

आउटपुट आहे:

Java 8 Predicate पद्धती

प्रीडिकेट इंटरफेसमध्ये मूठभर पद्धती आहेत.

• बूलियन चाचणी(T t) दिलेल्या युक्तिवादावर प्रेडिकेटचे मूल्यांकन करते.
• डीफॉल्ट प्रेडिकेट<T> आणि (प्रेडिकेट<? सुपर टी> इतर) एक प्रीडिकेट मिळवते जे शॉर्ट सर्किटिंग लॉजिकल AND या प्रेडिकेटचे आणि दुसरे दर्शवते.
• डीफॉल्ट प्रेडिकेट<T> किंवा एक कंपोज केलेला प्रेडिकेट परत करतो जो शॉर्ट सर्किटिंग लॉजिकल OR या प्रेडिकेटचा आणि दुसरा दर्शवतो.
• डीफॉल्ट Predicate<T> negate() एक predicate मिळवते जे तार्किकदृष्ट्या या predicate च्या विरुद्ध आहे.
• डिफॉल्ट Predicate<T> isEqual(Object targetRef) दोन आर्ग्युमेंट्स Objects.equals(Object, Object) नुसार समान असल्यास चाचणीचा निकाल देते .

बुलियन चाचणी (टी टी)

Java predicates साठी ही एक कार्यात्मक पद्धत आहे जी दिलेल्या युक्तिवादाने प्रेडिकेटची स्थिती पूर्ण करते की नाही याचे मूल्यांकन करते. उदाहरण: येथे आम्ही 18 किंवा त्याहून अधिक वयाच्या प्रत्येकासाठी प्रिडिकेट प्रौढ तयार करतो. test() पद्धतीला पूर्णांक मूल्य मिळते आणि ते तपासले जाते.

import java.util.function.Predicate;
public class PredicateTestTest {
   public static void main(String[] args) {
       Predicate<Integer> adult = i -> i >= 18;
       System.out.println(adult.test(12));
       System.out.println(adult.test(19));
       System.out.println(adult.test(21));
   }
}

वरील कोडचे आउटपुट काय असेल? पहिल्या प्रकरणात, 12 18 पेक्षा कमी असल्याने, ते खोटे असेल. दुसर्‍या आणि तिसर्‍या परिस्थितीसाठी, अटी पूर्ण झाल्या आहेत म्हणून परतावा खरा असेल.

डीफॉल्ट Predicate.and()

ही पद्धत "आणि" ऑपरेटर दर्शवते. म्हणूनच, जर दिलेल्या अंदाजांपैकी एकाने सेट केलेल्या अटींचे पालन केले नाही, तर दुसर्‍याचे मूल्यमापन होणार नाही. उदाहरण: चला Java मध्ये predicates लिहू, आणि() वापरून आधीपासून प्रौढ परंतु 65 वर्षांपेक्षा लहान असलेल्या सर्व लोकांना फिल्टर करू . चला predicate.add () वापरू आणि या अटींसाठी lambda सह java predicate लिहू: जर अट सत्य असेल, तर अॅप खालील विधान परत करेल:

import java.util.function.Predicate;

   public class PredicateDemo {
       public static void main(String[] args) {
           Predicate<Integer> adultYet = i -> i >= 18;
           Predicate<Integer> adultStill = i -> i < 65;
           System.out.println(adultYet.and(adultStill).test(5));
           System.out.println(adultYet.and(adultStill).test(38));
           System.out.println(adultYet.and(adultStill).test(90));
       }
   }

आउटपुट आहे:

डीफॉल्ट Predicate.or()

Predicate.or() पद्धत "OR" ऑपरेटरचे प्रतिनिधित्व करते. याचा अर्थ असा आहे की दोनपैकी एक भविष्यवाणी खरी असली आणि दुसरी खोटी असली तरीही स्थिती खरी राहील. उदाहरण: आता कॅरेक्टर स्ट्रिंग्सचे मूल्यांकन करूया. "माय" किंवा "क्रेयॉन" सबस्ट्रिंग असलेल्या सर्व वाक्यांशांमध्ये क्रमवारी लावण्यासाठी OR पद्धत वापरून पहा.

import java.util.function.Predicate;

  public class PredicateDemo2 {
      public static void main(String[] args) {
          Predicate<String> containsA = t -> t.contains("crayon");
          Predicate<String> containsB = t -> t.contains("my");
          System.out.println(containsA.or(containsB).test("here is my crayon"));
          System.out.println(containsA.or(containsB).test("here is my pencil"));
          System.out.println(containsA.or(containsB).test("here is John's crayon"));
          System.out.println(containsA.or(containsB).test("here is John's pencil"));
      }
  }

आउटपुट आहे:

डीफॉल्ट प्रीडिकेट नकार ()

पूर्वनिर्धारित निकषांचे पालन न करणारी सर्व मूल्ये एकत्रित करण्यासाठी negate() पद्धत वापरली जाते. उदाहरण: जर तुम्हाला "टोमॅटो" वर्गात क्रमवारी लावायची असेल आणि "लाल" नसलेल्या सर्व नोंदी शोधू इच्छित असाल, तर तुम्ही प्रीडिकेट लिहू शकता आणि संपूर्ण क्रम त्वरीत स्कॅन करू शकता. यासाठी कोड स्वतः लिहिण्याचा प्रयत्न करा आणि एकदा तुम्ही पूर्ण केल्यावर ते सोल्यूशनमध्ये तपासा.

import java.util.function.Predicate;

public class PredicateDemo3 {
public static void main(String[] args) {
 Predicate<Integer> adult = i -> i >= 18;
System.out.println(adult.negate().test(7));  System.out.println(adult.negate().test(19))
  }
   }

आउटपुट आहे:

स्टॅटिक प्रेडिकेट isEqual(ऑब्जेक्ट टार्गेटरेफ)

दोन ऑब्जेक्ट्स Objects.equals() च्या पॅरामीटर म्हणून परिभाषित केलेल्या मूल्याप्रमाणे आहेत की नाही हे निर्धारित करायचे असल्यास ही पद्धत अत्यंत उपयुक्त आहे. जर तुम्हाला समान चाचणी परिणामांची तुलना करायची असेल तर ही पद्धत विशेषतः उपयुक्त आहे. उदाहरण: समजा तुम्ही नाशपातीच्या दोन कॅरेजची तुलना करत आहात आणि दोघांनाही प्रमाणित वजन आणि रंगाची फळे आहेत की नाही याची खात्री करायची आहे. या प्रकरणात, स्टॅटिक प्रेडिकेट isEqual(ऑब्जेक्ट टारगेटरेफ) ही तुम्हाला आवश्यक असलेली पद्धत आहे. isEqual दोन स्ट्रिंगची समानता कशी तपासते ते पाहू या :

import java.util.function.Predicate;

public class PredicateDemo2 {
   public static void main(String[] args) {
       Predicate<String> i = Predicate.isEqual("here is my crayon");
       System.out.println(i.test("here is my pencil"));
       System.out.println(i.test("here is my crayon"));
   }
}

तुम्ही विश्‍लेषित करत असलेली एखादी वस्तू मानक अटींचे पालन करत असल्यास, फंक्शन खरे होईल. आउटपुट आहे:

Java IntPredicate

Java IntPredicate हा एक फंक्शनल इंटरफेस आहे, त्यामुळे तुम्ही लॅम्बडा अभिव्यक्ती किंवा पद्धती संदर्भासाठी असाइनमेंट लक्ष्य म्हणून वापरू शकता. IntPredicate पूर्णांकावर चालते आणि स्थितीवर आधारित एक पूर्वनिर्धारित मूल्य मिळवते. जसे की Predicate इंटरफेस, IntPredicate मध्ये test() , आणि() , negate() , or() पद्धती आहेत. येथे IntPredicate चे उदाहरण आहे. हे अॅरेमधून सर्व प्रौढांना (18 किंवा अधिक) फिल्टर करते.

import java.util.Arrays;
import java.util.function.IntPredicate;

public class IntPredicateExample {

   public static void main(String[] args) {

       int[] ages = { 18, 28, 18, 46, 90, 45, 2, 3, 1, 5, 7, 21, 12 };

       IntPredicate p = n -> n >= 18;

       Arrays.stream(ages).filter(p).forEach(System.out::println);
   }
}

आउटपुट आहे:

Java मध्ये क्लीन प्रेडिकेट्स लिहिणे

Java Predicates अत्यंत कार्यक्षम आणि काम करण्यास मजेदार आहेत. तथापि, जोपर्यंत तुम्ही लिहीलेल्या लॅम्बडा अभिव्यक्तींचा कोडवर कसा परिणाम होतो हे तुम्ही लक्षात घेत नाही, तोपर्यंत अव्यवस्थित प्रेडिकेट्ससह कोड राखण्याची क्षमता कमी होण्याचा धोका असतो. येथे काही सोप्या पद्धती आहेत ज्या तुम्हाला हे सुनिश्चित करण्यात मदत करतील की तुमचे कार्यात्मक इंटरफेस व्यवस्थापित करणे आणि वाचणे सोपे आहे.

• स्वतःची पुनरावृत्ती करू नका — जावा बरोबर एकापेक्षा जास्त वेळा पुनरावृत्ती केलेली मूल्ये, पद्धती आणि अटींसह भविष्यवाणी तयार करू नका. अशा प्रकारे, तुम्ही तुमचा उत्पादक वेळ वाया घालवता आणि कोड गोंधळात टाकता.
• चाचणीक्षमता सुनिश्चित करण्यासाठी अॅप कोडपासून वेगळे अंदाज. त्या व्यतिरिक्त, एक predicate युनिट चाचणी वेळापत्रक तयार करा आणि त्यास चिकटून रहा.
• तुमचे वर्ग फुगलेले नाहीत याची खात्री करण्यासाठी आयात आणि रचना नमुने वापरा आणि व्यवस्थापित करणे सोपे आहे.
• Java predicates हेल्पर क्लासेसमध्ये हलवण्याचा विचार करा — अशा प्रकारे, तुम्ही तुमच्या कोडची पुन: उपयोगिता सुधारता आणि देखभाल सुलभ करता.
• वाचनीयता - जेव्हा शक्य असेल तेव्हा, जटिल अंदाजापेक्षा एक-रेषीय विधानांना प्राधान्य द्या. जटिल कार्यात्मक इंटरफेसची तुमची समज दर्शविण्यास मोहक वाटू शकते. तथापि, जेव्हा देखभालीचा प्रश्न येतो तेव्हा कमी जास्त असते.