Java prædikat med eksempler

Generelt betyder prædikat et udsagn, der bestemmer, om en værdi kan være sand eller falsk. I programmering betyder prædikater funktioner med et argument, der returnerer en boolsk værdi. Functional Interface Predicate blev realiseret i Java 8. "Functional" betyder, at det kun indeholder én abstrakt metode. Den accepterer et argument og returnerer en boolean. I Java bruges funktionelle grænseflader til at håndtere Lambda-udtryk, konstruktører og metodereferencer. Normalt bruges Java 8 Predicate til at anvende et filter til en samling af objekter. Lad os tage et kig på dets vigtigste applikationer og udbredte metoder, samt løse nogle praksisproblemer.

Hvorfor udviklere bruger prædikat

Grundlæggende kan udviklere bruge prædikater til alle opgaver, der involverer evaluering af elementer baseret på foruddefinerede kriterier og returnering af en boolesk værdi. Her er eksempler på simple opgaver, som udviklere håndterer ved hjælp af prædikater:

• Filtrering af et sæt heltal.
• Sortering af lister ved at sikre, at dataene er i overensstemmelse med flere foruddefinerede betingelser (f.eks. organisering af en række varer ved at fastsætte pris- og vægtbetingelser).
• Brug af hjælpepakker i samtidig programmering.

Prædikater er en vigtig funktion i softwaretest. Den funktionelle grænseflade gør det nemmere at adskille enheder til test, forbedrer app-kodens læsbarhed og håndterbarhed.

Prædikatsyntaks i Java

java.util.function.Predicate blev introduceret i Java 8 som en alternativ måde at håndtere vurderingsindtryk i Lambda. Standardvisningen af ​​grænsefladen er Predicate<T> , hvor T er et enkelt argument, der returnerer en boolesk værdi. Java-prædikater har en funktionel (abstrakt) metodetest (Objekt) , der evaluerer dette prædikat på et givet objekt.

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

Her er et eksempel på at skrive et simpelt prædikat, der filtrerer heltal baseret på betingelser "større end", "mindre end".

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

Outputtet vil være sandt , fordi 10 < 18. Endnu et eksempel med prædikat i filter() . Prædikat hjælper med at filtrere alle voksne fra listen over aldersgrupper.

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

Udgangen er:

Java 8 prædikatmetoder

Prædikatgrænsefladen har en håndfuld metoder.

• boolsk test(T t) evaluerer prædikatet på det givne argument.
• standardprædikat<T> og(prædikat<? super T> andet) returnerer et prædikat, der repræsenterer en kortsluttende logisk OG af dette prædikat og et andet.
• standardprædikat<T> eller returnerer et sammensat prædikat, der repræsenterer et kortsluttende logisk ELLER for dette prædikat og et andet.
• standardprædikat<T> negate() returnerer et prædikat, der logisk er modsat dette prædikat.
• standardprædikat<T> isEqual(Object targetRef) returnerer et resultat af test, hvis to argumenter er ens i henhold til Objects.equals(Object, Object) .

boolsk test(T t)

Dette er en funktionel metode til Java-prædikater, der evaluerer, hvorvidt et givet argument opfylder betingelsen for et prædikat. Eksempel: her opretter vi et prædikat voksen for alle, der er 18 år eller derover. test()- metoden får en heltalsværdi og tjekker den.

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

Hvad vil outputtet for koden ovenfor være? I det første tilfælde, da 12 er mindre end 18, vil det være falsk. Hvad angår det andet og det tredje scenario, er betingelserne opfyldt, så afkastet vil være sandt.

standard Predicate.and()

Denne metode repræsenterer "og"-operatøren. Det er derfor, hvis et af de givne prædikater ikke overholder en fastsat betingelse, vil et andet ikke få en evaluering. Eksempel: Lad os komponere prædikater i Java og filtrere alle mennesker, der allerede er voksne, men yngre end 65 ved at bruge og() . Lad os bruge predicate.add () og skrive et java-prædikat med lambda for disse betingelser: Hvis betingelsen er sand, vil appen returnere følgende sætning:

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

Udgangen er:

standard Predicate.or()

Predicate.or() -metoden repræsenterer "ELLER"-operatoren. Det betyder, at betingelsen forbliver sand, selvom et af to prædikater er sandt, og det andet er falsk. Eksempel: Lad os evaluere tegnstrenge nu. Prøv at bruge OR-metoden til at sortere gennem alle sætninger, der indeholder understrengen "min" eller "farvet farveblyant".

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

Udgangen er:

standardprædikat negate()

metoden negate() bruges til at samle alle værdier, der ikke overholder foruddefinerede kriterier. Eksempel: hvis du vil sortere gennem klassen "Tomater" og finde alle poster, der ikke er "Røde", kan du skrive et prædikat og hurtigt scanne gennem hele sekvensen. Prøv at skrive koden til denne på egen hånd, og tjek den mod løsningen, når du er færdig.

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

Udgangen er:

statisk prædikat er Lige (Object targetRef)

Denne metode er yderst nyttig, hvis du vil bestemme, om to objekter er lig med en værdi defineret som en parameter for Objects.equals(). Denne metode er især nyttig, hvis du har brug for at sammenligne lignende testresultater. Eksempel: Lad os sige, at du sammenligner to vogne med pærer og vil sikre dig, om begge har frugter af en standardvægt og -farve. I dette tilfælde er statisk prædikat erLige(Object targetRef) præcis den metode, du har brug for. Lad os tage et kig på, hvordan isEqual kontrollerer ligheden af ​​to strenge:

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

Hvis et objekt, du analyserer, overholder standardbetingelserne, vil funktionen returnere sand. Udgangen er:

Java IntPredicate

Java IntPredicate er en funktionel grænseflade, så du kan bruge den som tildelingsmål for et lambda-udtryk eller en metodereference. IntPredicate opererer på et heltal og returnerer en prædikatværdi baseret på en betingelse. Som Predicate Interface har IntPredicate også test() , og() , negate() , eller() metoder. Her er et eksempel på IntPredicate. Det filtrerer også alle voksne (18 eller flere) fra arrayet.

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

Udgangen er:

At skrive rene prædikater i Java

Java-prædikater er yderst funktionelle og sjove at arbejde med. Medmindre du er opmærksom på, hvordan lambda-udtryk, du skriver, påvirker koden, er der en risiko for at reducere kodevedligeholdelse med rodede prædikater. Her er et par enkle fremgangsmåder, der hjælper dig med at sikre, at dine funktionelle grænseflader er nemme at administrere og læse.

• Gentag ikke dig selv — komponer ikke prædikater med Java med gentagne værdier, metoder og betingelser mere end én gang. På denne måde spilder du din produktive tid og gør koden rodet.
• Adskil prædikater fra app-koden for at sikre testbarhed. Bortset fra det, opret en prædikatenhedstestplan og hold dig til den.
• Brug import- og kompositionsmønstre for at sikre, at dine klasser ikke er oppustede og forbliver nemme at administrere.
• Overvej at flytte Java-prædikater til Helper-klasser - på denne måde forbedrer du genbrugbarheden af ​​din kode og letter vedligeholdelsen.
• Læsbarhed – når det er muligt, så foretræk udsagn på én linje frem for komplekse prædikater. Det kan være fristende at vise din forståelse af komplekse funktionelle grænseflader. Men når det kommer til vedligeholdelse, er mindre mere.