Java-predikat med exempel

Generellt betyder predikat ett påstående som avgör om ett värde kan vara sant eller falskt. I programmering betyder predikat funktioner med ett argument som returnerar ett booleskt värde. Functional Interface Predicate realiserades i Java 8. "Functional" betyder att det bara innehåller en abstrakt metod. Den accepterar ett argument och returnerar ett booleskt värde. I Java används funktionella gränssnitt för att hantera Lambda-uttryck, konstruktorer och metodreferenser. Vanligtvis används Java 8 Predicate för att tillämpa ett filter för en samling objekt. Låt oss ta en titt på dess huvudsakliga tillämpningar och ofta använda metoder, samt lösa några övningsproblem.

Varför utvecklare använder Predicate

I grund och botten kan utvecklare använda predikat för alla uppgifter som involverar att utvärdera objekt baserat på fördefinierade kriterier och returnera ett booleskt värde. Här är exempel på enkla uppgifter som utvecklare hanterar med hjälp av predikat:

• Filtrera en uppsättning heltal.
• Sortera listor genom att se till att data överensstämmer med flera fördefinierade villkor (t.ex. organisera en rad artiklar genom att sätta pris och viktvillkor).
• Använda verktygspaket i samtidig programmering.

Predikat är en viktig funktion i mjukvarutestning. Det funktionella gränssnittet gör det enklare att separera enheter för testning, förbättrar appkodens läsbarhet och hanterbarhet.

Predikatsyntax i Java

java.util.function.Predicate introducerades i Java 8 som ett alternativt sätt att hantera bedömningsintryck i Lambda. Standardvyn för gränssnittet är Predicate<T> , där T är ett enda argument som returnerar ett booleskt värde. Java Predicates har ett funktionellt (abstrakt) metodtest (Object) som utvärderar detta predikat på ett givet objekt.

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

Här är ett exempel på att skriva ett enkelt predikat som filtrerar heltal baserat på villkoren "större än", "mindre än".

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

Utdata kommer att vara sant eftersom 10 < 18. Ytterligare ett exempel med Predicate i filter() . Predikat hjälper till att filtrera alla vuxna från listan över åldrar.

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

Utgången är:

Java 8 predikatmetoder

Predikatgränssnittet har en handfull metoder.

• boolean test(T t) utvärderar predikatet på det givna argumentet.
• default Predicate<T> and(Predicate<? super T> other) returnerar ett predikat som representerar en kortslutande logisk AND av detta predikat och ett annat.
• default Predicate<T> eller returnerar ett sammansatt predikat som representerar ett kortslutande logiskt ELLER för detta predikat och ett annat.
• default Predicate<T> negate() returnerar ett predikat som logiskt sett är motsatt till detta predikat.
• default Predicate<T> isEqual(Object targetRef) returnerar ett testresultat om två argument är lika enligt Objects.equals(Object, Object) .

booleskt test(T t)

Detta är en funktionell metod för Java-predikat som utvärderar om ett givet argument uppfyller villkoret för ett predikat. Exempel: här skapar vi ett predikat vuxen för alla som är 18 år eller äldre. test() -metoden får ett heltalsvärde och kontrollerar det.

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

Vad blir resultatet för koden ovan? I det första fallet, eftersom 12 är mindre än 18, kommer det att vara falskt. När det gäller det andra och det tredje scenariot är villkoren uppfyllda så att avkastningen blir sann.

standard Predicate.and()

Denna metod representerar "och"-operatören. Det är därför, om ett av de givna predikaten inte uppfyller ett fastställt villkor, kommer ett annat inte att få en utvärdering. Exempel: Låt oss komponera predikat i Java och filtrera alla människor som redan är vuxna men yngre än 65 med och() . Låt oss använda predicate.add () och skriva ett java-predikat med lambda för dessa villkor: Om villkoret är sant kommer appen att returnera följande uttalande:

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

Utgången är:

standard Predicate.or()

Metoden Predicate.or() representerar operatorn "OR". Detta innebär att villkoret förblir sant även om ett av två predikat är sant och det andra är falskt. Exempel: låt oss utvärdera teckensträngar nu. Försök att använda OR-metoden för att sortera igenom alla fraser som innehåller delsträngen "min" eller "krita".

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

Utgången är:

standardpredikat negate()

metoden negate() används för att samla in alla värden som inte överensstämmer med fördefinierade kriterier. Exempel: om du vill sortera genom klassen "Tomater" och hitta alla poster som inte är "röda", kan du skriva ett predikat och snabbt skanna igenom hela sekvensen. Försök att skriva koden för den här på egen hand och kontrollera den mot lösningen när du är klar.

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

Utgången är:

statiskt predikat är Lika(Object targetRef)

Den här metoden är mycket användbar om du vill avgöra om två objekt är lika med ett värde definierat som en parameter för Objects.equals(). Den här metoden är särskilt användbar om du behöver jämföra liknande testresultat. Exempel: låt oss säga att du jämför två vagnar med päron och vill försäkra dig om att båda har frukter med standardvikt och -färg. I det här fallet är statiskt predikat ärEqual(Object targetRef) exakt den metod du behöver. Låt oss ta en titt på hur isEqual kontrollerar likheten mellan två strängar:

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

Om ett objekt du analyserar uppfyller standardvillkoren kommer funktionen att returnera sant. Utgången är:

Java IntPredicate

Java IntPredicate är ett funktionellt gränssnitt, så du kan använda det som tilldelningsmål för ett lambdauttryck eller metodreferens. IntPredicate arbetar på ett heltal och returnerar ett predikatvärde baserat på ett villkor. Som Predicate Interface, IntPredicate har också test() , och() , negate() , eller() metoder. Här är ett exempel på IntPredicate. Det filtrerar också alla vuxna (18 eller fler) från arrayen.

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

Utgången är:

Att skriva rena predikat i Java

Java Predicates är mycket funktionella och roliga att arbeta med. Men om du inte är uppmärksam på hur lambda-uttryck du skriver påverkar koden, finns det en risk att kodens underhållsbarhet minskar med röriga predikat. Här är några enkla metoder som hjälper dig att säkerställa att dina funktionella gränssnitt är lätta att hantera och läsa.

• Upprepa inte dig själv — komponera inte predikat med Java med upprepade värden, metoder och villkor mer än en gång. På så sätt slösar du bort din produktiva tid och gör koden rörig.
• Separera predikat från appkoden för att säkerställa testbarhet. Utöver det, skapa ett testschema för predikatenheter och håll dig till det.
• Använd importer och kompositionsmönster för att säkerställa att dina klasser inte är uppsvällda och förblir enkla att hantera.
• Överväg att flytta Java-predikat till Helper-klasser — på så sätt förbättrar du återanvändbarheten av din kod och underlättar underhållet.
• Läsbarhet – närhelst det är möjligt, föredra påståenden på en rad framför komplexa predikat. Det kan vara frestande att visa upp din förståelse för komplexa funktionella gränssnitt. Men när det kommer till underhåll är mindre mer.