ఉదాహరణలతో జావా ప్రిడికేట్

సాధారణంగా ప్రిడికేట్ అంటే విలువ ఒప్పు లేదా తప్పు కాదా అని నిర్ణయించే స్టేట్‌మెంట్. ప్రోగ్రామింగ్ ప్రిడికేట్స్‌లో బూలియన్ విలువను అందించే ఒక ఆర్గ్యుమెంట్‌తో ఫంక్షన్‌లను సూచిస్తుంది. ఫంక్షనల్ ఇంటర్‌ఫేస్ ప్రిడికేట్ జావా 8లో గ్రహించబడింది. “ఫంక్షనల్” అంటే అది ఒక వియుక్త పద్ధతిని మాత్రమే కలిగి ఉంటుంది. ఇది ఒక వాదనను అంగీకరించి, బూలియన్‌ను అందిస్తుంది. జావాలో, లాంబ్డా వ్యక్తీకరణలు, కన్స్ట్రక్టర్లు మరియు మెథడ్ రిఫరెన్స్‌లను నిర్వహించడానికి ఫంక్షనల్ ఇంటర్‌ఫేస్‌లు ఉపయోగించబడతాయి. సాధారణంగా జావా 8 ప్రిడికేట్ వస్తువుల సేకరణ కోసం ఫిల్టర్‌ని వర్తింపజేయడానికి ఉపయోగించబడుతుంది. దాని ప్రధాన అప్లికేషన్లు మరియు విస్తృతంగా ఉపయోగించే పద్ధతులను పరిశీలిద్దాం, అలాగే కొన్ని అభ్యాస సమస్యలను పరిష్కరిద్దాం.

డెవలపర్లు ప్రిడికేట్‌ను ఎందుకు ఉపయోగిస్తున్నారు

ప్రాథమికంగా, డెవలపర్‌లు ముందే నిర్వచించిన ప్రమాణాల ఆధారంగా అంశాలను మూల్యాంకనం చేయడం మరియు బూలియన్ విలువను తిరిగి ఇవ్వడం వంటి ఏదైనా పనుల కోసం ప్రిడికేట్‌లను ఉపయోగించవచ్చు. సూచనలను ఉపయోగించి డెవలపర్లు నిర్వహించే సాధారణ పనుల ఉదాహరణలు ఇక్కడ ఉన్నాయి:

• పూర్ణాంకాల సమితిని ఫిల్టర్ చేస్తోంది.
• డేటా అనేక ముందే నిర్వచించిన షరతులకు అనుగుణంగా ఉందని నిర్ధారించడం ద్వారా జాబితాలను క్రమబద్ధీకరించడం (ఉదా. ధర మరియు బరువు పరిస్థితులను సెట్ చేయడం ద్వారా వస్తువుల శ్రేణిని నిర్వహించడం).
• ఉమ్మడి ప్రోగ్రామింగ్‌లో యుటిలిటీ ప్యాకేజీలను ఉపయోగించడం.

సాఫ్ట్‌వేర్ టెస్టింగ్‌లో ప్రిడికేట్స్ ఒక ముఖ్యమైన లక్షణం. ఫంక్షనల్ ఇంటర్‌ఫేస్ పరీక్ష కోసం యూనిట్‌లను వేరు చేయడాన్ని సులభతరం చేస్తుంది, యాప్ కోడ్ యొక్క రీడబిలిటీ మరియు నిర్వహణ సామర్థ్యాన్ని మెరుగుపరుస్తుంది.

జావాలో వాక్యనిర్మాణాన్ని అంచనా వేయండి

java.util.function.Predicate లాంబ్డాలో అసెస్‌మెంట్ ఇంప్రెషన్‌లను నిర్వహించడానికి ప్రత్యామ్నాయ మార్గంగా జావా 8లో ప్రవేశపెట్టబడింది. ఇంటర్‌ఫేస్ యొక్క ప్రామాణిక వీక్షణ ప్రిడికేట్<T> , ఇక్కడ T అనేది బూలియన్ విలువను అందించే ఒకే ఆర్గ్యుమెంట్. జావా ప్రిడికేట్‌లు ఫంక్షనల్ (అబ్‌స్ట్రాక్ట్) మెథడ్ టెస్ట్ (ఆబ్జెక్ట్)ని కలిగి ఉంటాయి , ఇది ఇచ్చిన ఆబ్జెక్ట్‌పై ఈ ప్రిడికేట్‌ను అంచనా వేస్తుంది.

@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 ప్రిడికేట్ మెథడ్స్

ప్రిడికేట్ ఇంటర్‌ఫేస్ కొన్ని పద్ధతులను కలిగి ఉంది.

• బూలియన్ పరీక్ష(T t) ఇచ్చిన ఆర్గ్యుమెంట్‌పై ప్రిడికేట్‌ను అంచనా వేస్తుంది.
• డిఫాల్ట్ ప్రిడికేట్ <T> మరియు(ప్రిడికేట్<? సూపర్ T> ఇతర) అనేవి షార్ట్-సర్క్యూటింగ్ లాజికల్ మరియు ఈ ప్రిడికేట్ మరియు మరొకదానిని సూచించే ప్రిడికేట్‌ను అందిస్తుంది.
• డిఫాల్ట్ ప్రిడికేట్<T> లేదా ఈ ప్రిడికేట్ మరియు మరొకదాని యొక్క షార్ట్-సర్క్యూటింగ్ లాజికల్ లేదా మరొకదానిని సూచించే కంపోజ్డ్ ప్రిడికేట్‌ను అందిస్తుంది.
• డిఫాల్ట్ ప్రిడికేట్ <T> negate() అనేది తార్కికంగా ఈ ప్రిడికేట్‌కు వ్యతిరేకమైన ప్రిడికేట్‌ను అందిస్తుంది.
• డిఫాల్ట్ ప్రిడికేట్<T> isEqual(Object targetRef) Objects.equals(Object, Object) ప్రకారం రెండు ఆర్గ్యుమెంట్‌లు సమానంగా ఉంటే పరీక్ష ఫలితాన్ని అందిస్తుంది .

బూలియన్ పరీక్ష (T t)

ఇది జావా ప్రిడికేట్‌ల కోసం ఒక ఫంక్షనల్ పద్ధతి, ఇది ఇచ్చిన ఆర్గ్యుమెంట్ ప్రిడికేట్ యొక్క స్థితిని సంతృప్తి పరుస్తుందో లేదో అంచనా వేస్తుంది. ఉదాహరణ: ఇక్కడ మేము 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()

ఈ పద్ధతి "మరియు" ఆపరేటర్‌ను సూచిస్తుంది. అందుకే, ఇచ్చిన ప్రిడికేట్‌లలో ఒకటి నిర్ణీత షరతుకు అనుగుణంగా లేకపోతే, మరొకటి మూల్యాంకనం పొందదు. ఉదాహరణ: జావాలో ప్రిడికేట్‌లను కంపోజ్ చేద్దాం, ఇప్పటికే వయోజనులు మరియు 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()

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

అవుట్‌పుట్:

స్టాటిక్ ప్రిడికేట్ ఈక్వల్ (ఆబ్జెక్ట్ టార్గెట్ రిఫ్)

Objects.equals() యొక్క పరామితిగా నిర్వచించబడిన విలువకు రెండు వస్తువులు సమానంగా ఉన్నాయో లేదో మీరు గుర్తించాలనుకుంటే ఈ పద్ధతి చాలా ఉపయోగకరంగా ఉంటుంది. మీరు సారూప్య పరీక్ష ఫలితాలను సరిపోల్చాల్సిన అవసరం ఉన్నట్లయితే ఈ పద్ధతి చాలా ఉపయోగకరంగా ఉంటుంది. ఉదాహరణ: మీరు బేరి యొక్క రెండు క్యారేజీలను పోల్చి చూస్తున్నారని అనుకుందాం మరియు రెండింటిలోనూ ప్రామాణిక బరువు మరియు రంగు ఉన్న పండ్లు ఉన్నాయో లేదో నిర్ధారించుకోవాలి. ఈ సందర్భంలో, స్టాటిక్ ప్రిడికేట్ ఈక్వల్ (ఆబ్జెక్ట్ టార్గెట్ రిఫ్) అనేది మీకు అవసరమైన పద్ధతి. 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"));
   }
}

మీరు విశ్లేషిస్తున్న ఆబ్జెక్ట్ ప్రామాణిక షరతులకు అనుగుణంగా ఉంటే, ఫంక్షన్ నిజమైనదిగా చూపబడుతుంది. అవుట్‌పుట్:

జావా IntPredicate

Java IntPredicate అనేది ఒక ఫంక్షనల్ ఇంటర్‌ఫేస్, కాబట్టి మీరు దీన్ని లాంబ్డా ఎక్స్‌ప్రెషన్ లేదా మెథడ్ రిఫరెన్స్ కోసం అసైన్‌మెంట్ టార్గెట్‌గా ఉపయోగించవచ్చు. IntPredicate పూర్ణాంకంపై పని చేస్తుంది మరియు షరతు ఆధారంగా ప్రిడికేట్ విలువను అందిస్తుంది. ప్రిడికేట్ ఇంటర్‌ఫేస్ వంటివి, 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);
   }
}

అవుట్‌పుట్:

జావాలో క్లీన్ ప్రిడికేట్స్ రాయడం

జావా ప్రిడికేట్స్ చాలా ఫంక్షనల్ మరియు పని చేయడానికి సరదాగా ఉంటాయి. అయితే, మీరు వ్రాసే లాంబ్డా వ్యక్తీకరణలు కోడ్‌ను ఎలా ప్రభావితం చేస్తాయో మీరు గుర్తుంచుకోకపోతే, గజిబిజి ప్రిడికేట్‌లతో కోడ్ నిర్వహణను తగ్గించే ప్రమాదం ఉంది. మీ ఫంక్షనల్ ఇంటర్‌ఫేస్‌లను నిర్వహించడం మరియు చదవడం సులభం అని నిర్ధారించుకోవడంలో మీకు సహాయపడే కొన్ని సాధారణ పద్ధతులు ఇక్కడ ఉన్నాయి.

• మీరే పునరావృతం చేయవద్దు — పదేపదే విలువలు, పద్ధతులు మరియు షరతులతో జావాతో ప్రిడికేట్‌లను కంపోజ్ చేయవద్దు. ఈ విధంగా, మీరు మీ ఉత్పాదక సమయాన్ని వృధా చేస్తారు మరియు కోడ్‌ను గజిబిజిగా చేస్తారు.
• పరీక్ష సామర్థ్యాన్ని నిర్ధారించడానికి యాప్ కోడ్ నుండి ప్రిడికేట్‌లను వేరు చేయండి. అలా కాకుండా, ప్రిడికేట్ యూనిట్ టెస్టింగ్ షెడ్యూల్‌ని రూపొందించి, దానికి కట్టుబడి ఉండండి.
• మీ తరగతులు ఉబ్బినట్లుగా లేవని మరియు సులభంగా నిర్వహించడం కోసం దిగుమతులు మరియు కూర్పు నమూనాలను ఉపయోగించండి.
• జావా ప్రిడికేట్‌లను హెల్పర్ క్లాస్‌లకు తరలించడాన్ని పరిగణించండి - ఈ విధంగా, మీరు మీ కోడ్ పునర్వినియోగాన్ని మెరుగుపరుస్తారు మరియు నిర్వహణను సులభతరం చేస్తారు.
• రీడబిలిటీ — సాధ్యమైనప్పుడల్లా, సంక్లిష్ట అంచనాల కంటే వన్-లైన్ స్టేట్‌మెంట్‌లను ఇష్టపడండి. సంక్లిష్టమైన ఫంక్షనల్ ఇంటర్‌ఫేస్‌ల గురించి మీ అవగాహనను ప్రదర్శించడం ఉత్సాహం కలిగిస్తుంది. అయితే, నిర్వహణ విషయానికి వస్తే, తక్కువ ఎక్కువ.