उदाहरण के साथ जावा विधेय

आम तौर पर विधेय का अर्थ एक ऐसा कथन है जो यह निर्धारित करता है कि कोई मान सही या गलत हो सकता है। प्रोग्रामिंग में एक तर्क के साथ औसत कार्य करता है जो एक बूलियन मान लौटाता है। जावा 8 में कार्यात्मक इंटरफ़ेस भविष्यवाणी का एहसास हुआ। "कार्यात्मक" का अर्थ है कि इसमें केवल एक सार विधि शामिल है। यह एक तर्क स्वीकार करता है और एक बूलियन देता है। जावा में, लैंबडा एक्सप्रेशंस, कंस्ट्रक्टर्स और मेथड रेफरेंस को हैंडल करने के लिए फंक्शनल इंटरफेस का इस्तेमाल किया जाता है। आमतौर पर Java 8 Predicate का उपयोग वस्तुओं के संग्रह के लिए फ़िल्टर लागू करने के लिए किया जाता है। आइए इसके मुख्य अनुप्रयोगों और व्यापक रूप से उपयोग की जाने वाली विधियों पर एक नज़र डालें, साथ ही कुछ अभ्यास समस्याओं को हल करें।

डेवलपर्स विधेय का उपयोग क्यों करते हैं

मूल रूप से, डेवलपर्स किसी भी कार्य के लिए विधेय का उपयोग कर सकते हैं जिसमें पूर्वनिर्धारित मानदंडों के आधार पर वस्तुओं का मूल्यांकन करना और बूलियन मान लौटाना शामिल है। यहाँ सरल कार्यों के उदाहरण दिए गए हैं जिन्हें डेवलपर्स विधेय का उपयोग करके संभालते हैं:

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

सॉफ्टवेयर परीक्षण में विधेय एक महत्वपूर्ण विशेषता है। कार्यात्मक इंटरफ़ेस परीक्षण के लिए इकाइयों को अलग करना आसान बनाता है, पठनीयता में सुधार करता है और ऐप कोड की प्रबंधनीयता में सुधार करता है।

जावा में सिंटैक्स की भविष्यवाणी करें

java.util.function.Predicate जावा 8 में लैम्ब्डा में मूल्यांकन छापों को संभालने के वैकल्पिक तरीके के रूप में पेश किया गया था। इंटरफ़ेस का मानक दृश्य 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 । फ़िल्टर() में भविष्यवाणी के साथ एक और उदाहरण । विधेय सभी वयस्कों को उम्र की सूची से फ़िल्टर करने में मदद करता है।

  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;
      }
  }

आउटपुट है:

जावा 8 विधेय तरीके

प्रिडिकेट इंटरफ़ेस में कुछ विधियाँ हैं।

• बूलियन टेस्ट (टी टी) दिए गए तर्क पर विधेय का मूल्यांकन करता है।
• default Predicate<T> and(Predicate<? super T> Other) एक प्रेडिकेट लौटाता है जो शॉर्ट-सर्किटिंग लॉजिकल AND इस प्रेडिकेट और दूसरे का प्रतिनिधित्व करता है।
• डिफ़ॉल्ट विधेय <T> या एक रचित विधेय देता है जो शॉर्ट-सर्किटिंग तार्किक या इस विधेय और अन्य का प्रतिनिधित्व करता है।
• default Predicate<T> negate() एक विधेय देता है जो तार्किक रूप से इस विधेय के विपरीत है।
• डिफ़ॉल्ट Predicate<T> isEqual(Object targetRef) परीक्षण का परिणाम देता है यदि Objects.equals(Object, Object) के अनुसार दो तर्क समान हैं ।

बूलियन टेस्ट (टी टी)

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

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 से कम है, यह असत्य होगा। दूसरे और तीसरे परिदृश्य के लिए, शर्तें पूरी होती हैं इसलिए वापसी सही होगी।

डिफ़ॉल्ट विधेय। और ()

यह विधि "और" ऑपरेटर का प्रतिनिधित्व करती है। इसलिए, यदि दिए गए विधेय में से एक निर्धारित शर्त का अनुपालन नहीं करता है, तो दूसरे का मूल्यांकन नहीं होगा। उदाहरण: जावा में विधेय की रचना करते हैं, उन सभी लोगों को फ़िल्टर करते हैं जो पहले से ही वयस्क हैं लेकिन 65 से कम उम्र के हैं और() का उपयोग कर रहे हैं । आइए predicate.add () का उपयोग करें और इन स्थितियों के लिए लैम्ब्डा के साथ एक जावा विधेय लिखें: यदि स्थिति सही है, तो ऐप निम्नलिखित कथन लौटाएगा:

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 () विधि "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))
  }
   }

आउटपुट है:

स्थैतिक विधेय बराबर है (ऑब्जेक्ट लक्ष्यRef)

यह विधि अत्यधिक उपयोगी है यदि आप यह निर्धारित करना चाहते हैं कि क्या दो ऑब्जेक्ट Objects.equals() के पैरामीटर के रूप में परिभाषित मान के बराबर हैं। यदि आपको समान परीक्षण परिणामों की तुलना करने की आवश्यकता है तो यह विधि विशेष रूप से उपयोगी है। उदाहरण: मान लें कि आप नाशपाती के दो डिब्बों की तुलना कर रहे हैं और यह सुनिश्चित करना चाहते हैं कि दोनों के फल एक मानक वजन और रंग के हैं या नहीं। इस मामले में, स्थिर विधेय isEqual(Object targetRef) बिल्कुल वही तरीका है जिसकी आपको आवश्यकता है। आइए एक नज़र डालते हैं कि कैसे 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 एक कार्यात्मक इंटरफ़ेस है, इसलिए आप इसे लैम्ब्डा अभिव्यक्ति या विधि संदर्भ के लिए असाइनमेंट लक्ष्य के रूप में उपयोग कर सकते हैं। IntPredicate एक पूर्णांक पर काम करता है और एक शर्त के आधार पर एक विधेय मान लौटाता है। जैसे कि Predicate इंटरफ़ेस, IntPredicate में test() , and() , 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 Predicates काम करने के लिए अत्यधिक कार्यात्मक और मज़ेदार हैं। हालाँकि, जब तक आप इस बात से सावधान नहीं होते हैं कि आपके द्वारा लिखे गए लैम्ब्डा एक्सप्रेशन कोड को कैसे प्रभावित करते हैं, तो गन्दा विधेय के साथ कोड की स्थिरता को कम करने का जोखिम होता है। यहां कुछ सरल अभ्यास दिए गए हैं जो यह सुनिश्चित करने में आपकी सहायता करेंगे कि आपके कार्यात्मक इंटरफेस को प्रबंधित करना और पढ़ना आसान है।

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