Java-predikat med eksempler

Generelt betyr predikat et utsagn som bestemmer om en verdi kan være sann eller usann. I programmering betyr predikater funksjoner med ett argument som returnerer en boolsk verdi. Functional Interface Predicate ble realisert i Java 8. "Functional" betyr at det bare inneholder én abstrakt metode. Den godtar et argument og returnerer en boolsk. I Java brukes funksjonelle grensesnitt for å håndtere Lambda-uttrykk, konstruktører og metodereferanser. Vanligvis brukes Java 8 Predicate til å bruke et filter for en samling objekter. La oss ta en titt på hovedapplikasjonene og de mye brukte metodene, samt løse noen praksisproblemer.

Hvorfor utviklere bruker Predicate

I utgangspunktet kan utviklere bruke predikater for alle oppgaver som involverer å evaluere elementer basert på forhåndsdefinerte kriterier og returnere en boolsk verdi. Her er eksempler på enkle oppgaver utviklere håndterer ved å bruke predikater:

• Filtrering av et sett med heltall.
• Sortere lister ved å sikre at dataene er i samsvar med flere forhåndsdefinerte betingelser (f.eks. organisere en rekke varer ved å angi pris- og vektbetingelser).
• Bruke verktøypakker i samtidig programmering.

Predikater er en viktig funksjon i programvaretesting. Det funksjonelle grensesnittet gjør det enklere å skille enheter for testing, forbedrer lesbarheten og håndterbarheten til appkoden.

Predikatsyntaks i Java

java.util.function.Predicate ble introdusert i Java 8 som en alternativ måte å håndtere vurderingsinntrykk i Lambda. Standardvisningen av grensesnittet er Predicate<T> , der T er et enkelt argument som returnerer en boolsk verdi. Java Predicates har en funksjonell (abstrakt) metodetest (Object) som evaluerer dette predikatet på et gitt objekt.

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

Her er et eksempel på å skrive et enkelt predikat som filtrerer heltall basert på betingelsene "større enn", "mindre enn".

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

Utgangen vil være sann fordi 10 < 18. Et eksempel til med Predicate i filter() . Predikat hjelper til med å filtrere alle voksne fra listen over aldre.

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

Utgangen er:

Java 8-predikatmetoder

Predikatgrensesnittet har en håndfull metoder.

• boolsk test(T t) evaluerer predikatet på det gitte argumentet.
• default Predicate<T> and(Predicate<? super T> other) returnerer et predikat som representerer en kortsluttende logisk OG av dette predikatet og et annet.
• standard predikat<T> eller returnerer et sammensatt predikat som representerer en kortsluttende logisk ELLER av dette predikatet og et annet.
• default Predicate<T> negate() returnerer et predikat som er motsatt av dette predikatet logisk.
• default Predicate<T> isEqual(Object targetRef) returnerer et resultat av testing hvis to argumenter er like i henhold til Objects.equals(Object, Object) .

boolsk test(T t)

Dette er en funksjonell metode for Java-predikater som evaluerer hvorvidt et gitt argument tilfredsstiller betingelsen til et predikat. Eksempel: her lager vi et predikat voksen for alle som er 18 år eller mer. test()- metoden får en heltallsverdi og sjekker 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));
   }
}

Hva vil utgangen for koden ovenfor være? I det første tilfellet, siden 12 er mindre enn 18, vil det være usant. Når det gjelder det andre og det tredje scenarioet, er betingelsene oppfylt slik at avkastningen vil være sann.

standard Predicate.and()

Denne metoden representerer "og"-operatøren. Det er derfor, hvis ett av de gitte predikatene ikke samsvarer med en fastsatt betingelse, vil et annet ikke få en evaluering. Eksempel: La oss komponere predikater i Java, filtrere alle personer som allerede er voksne, men yngre enn 65 ved å bruke og() . La oss bruke predicate.add () og skrive et java-predikat med lambda for disse forholdene: Hvis betingelsen er sann, vil appen returnere følgende setning:

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

Utgangen er:

standard Predicate.or()

Predicate.or() -metoden representerer "OR"-operatoren. Dette betyr at betingelsen forblir sann selv om ett av to predikater er sant og det andre er usant. Eksempel: la oss evaluere tegnstrenger nå. Prøv å bruke OR-metoden for å sortere gjennom alle fraser som inneholder delstrengen "min" eller "fargestift".

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

Utgangen er:

standard predikat negate()

metoden negate() brukes til å samle alle verdier som ikke samsvarer med forhåndsdefinerte kriterier. Eksempel: hvis du vil sortere gjennom klassen "Tomater" og finne alle oppføringer som ikke er "røde", kan du skrive et predikat og raskt skanne gjennom hele sekvensen. Prøv å skrive koden for denne på egen hånd og sjekk den mot løsningen når du er ferdig.

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

Utgangen er:

statisk predikat er lik(objektmålref.)

Denne metoden er svært nyttig hvis du vil finne ut om to objekter er lik en verdi definert som en parameter for Objects.equals(). Denne metoden er spesielt nyttig hvis du trenger å sammenligne lignende testresultater. Eksempel: la oss si at du sammenligner to vogner med pærer og vil forsikre deg om at begge har frukt med standard vekt og farge. I dette tilfellet er statisk PredicateEqual (Object targetRef) nøyaktig metoden du trenger. La oss ta en titt på hvordan isEqual kontrollerer likheten til to strenger:

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 samsvarer med standardbetingelsene, vil funksjonen returnere sann. Utgangen er:

Java IntPredicate

Java IntPredicate er et funksjonelt grensesnitt, så du kan bruke det som tildelingsmål for et lambda-uttrykk eller metodereferanse. IntPredicate opererer på et heltall og returnerer en predikatverdi basert på en betingelse. Som Predicate Interface, har IntPredicate også test() , og() , negate() , eller()- metoder. Her er et eksempel på IntPredicate. Den 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);
   }
}

Utgangen er:

Skrive rene predikater i Java

Java-predikater er svært funksjonelle og morsomme å jobbe med. Men med mindre du er oppmerksom på hvordan lambda-uttrykk du skriver påvirker koden, er det en risiko for å redusere kodens vedlikeholdbarhet med rotete predikater. Her er noen enkle fremgangsmåter som vil hjelpe deg å sikre at de funksjonelle grensesnittene dine er enkle å administrere og lese.

• Ikke gjenta deg selv – ikke komponer predikater med Java med gjentatte verdier, metoder og betingelser mer enn én gang. På denne måten kaster du bort din produktive tid og gjør koden rotete.
• Skill predikater fra appkoden for å sikre testbarhet. Annet enn det, lag en tidsplan for predikatenhetstesting og hold deg til den.
• Bruk import- og komposisjonsmønstre for å sikre at klassene dine ikke er oppblåste og forblir enkle å administrere.
• Vurder å flytte Java-predikater til Helper-klasser – på denne måten forbedrer du gjenbrukbarheten til koden din og letter vedlikeholdet.
• Lesbarhet – når det er mulig, foretrekk utsagn på én linje fremfor komplekse predikater. Det kan være fristende å vise frem din forståelse av komplekse funksjonelle grensesnitt. Men når det gjelder vedlikehold, er mindre mer.