Java predikátum példákkal

A predikátum általában olyan állítást jelent, amely meghatározza, hogy egy érték igaz vagy hamis lehet. A programozásban a predikátumok olyan egy argumentummal rendelkező függvényeket jelentenek, amelyek logikai értéket adnak vissza. A Functional Interface Predicate a Java 8-ban valósult meg. A „funkcionális” azt jelenti, hogy csak egy absztrakt metódust tartalmaz. Elfogad egy érvet, és egy logikai értéket ad vissza. A Java-ban funkcionális interfészek használhatók a Lambda-kifejezések, konstruktorok és Method hivatkozások kezelésére. Általában a Java 8 Predicate-ot használják szűrő alkalmazására objektumok gyűjteményére. Vessünk egy pillantást főbb alkalmazási területeire és széles körben használt módszereire, valamint oldjunk meg néhány gyakorlati problémát.

Miért használnak predikátumot a fejlesztők?

Alapvetően a fejlesztők predikátumokat használhatnak minden olyan feladathoz, amely magában foglalja az elemek előre meghatározott kritériumok alapján történő kiértékelését és logikai érték visszaadását. Példák az egyszerű feladatokra, amelyeket a fejlesztők predikátumok használatával kezelnek:

• Egész számok halmazának szűrése.
• Listák rendezése annak biztosításával, hogy az adatok megfeleljenek több előre meghatározott feltételnek (pl. tételsor rendszerezése ár- és súlyfeltételek beállításával).
• Segédcsomagok használata párhuzamos programozásban.

A predikátumok fontos jellemzői a szoftvertesztelésnek. A funkcionális felület megkönnyíti az egységek szétválasztását a teszteléshez, javítja az alkalmazáskód olvashatóságát és kezelhetőségét.

Predikátum szintaxis Java nyelven

A java.util.function.Predicate a Java 8-ban került bevezetésre, mint az értékelési benyomások kezelésének alternatív módja a Lambdában. Az interfész standard nézete Predicate<T> , ahol T egyetlen argumentum, amely logikai értéket ad vissza. A Java-predikátumoknak van egy funkcionális (absztrakt) teszt(Object) módszere , amely kiértékeli ezt a predikátumot egy adott objektumon.

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

Íme egy példa egy egyszerű predikátum megírására, amely szűri az egész számokat „nagyobb, mint”, „kisebb, mint” feltételek alapjá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));  
    }
}

A kimenet igaz lesz , mert 10 < 18. Még egy példa a Predicate-re a filter()- ben . A predikátum segít kiszűrni az összes felnőttet a korosztályok listájáról.

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

A kimenet a következő:

Java 8 predikátum módszerek

Az Predikátum Interfésznek maroknyi módszere van.

• a logikai teszt(T t) kiértékeli az adott argumentum predikátumát.
• alapértelmezett Predicate<T> and(Predicate<? super T> other) egy predikátumot ad vissza, amely ennek a predikátumnak és egy másiknak a rövidzárlati logikai ÉS-ét reprezentálja.
• alapértelmezett Predikátum<T> vagy egy összeállított predikátumot ad vissza, amely ennek és egy másik predikátumnak a logikai VAGY rövidre zárását jelenti.
• alapértelmezett Predicate<T> negate() egy olyan predikátumot ad vissza, amely logikailag ellentétes ezzel a predikátummal.
• alapértelmezett Predicate<T> isEqual(Object targetRef) a teszt eredményét adja vissza, ha két argumentum egyenlő az Objects.equals(Object, Object) szerint .

logikai teszt (T t)

Ez a Java-predikátumok funkcionális módszere, amely kiértékeli, hogy egy adott argumentum megfelel-e egy predikátum feltételének. Példa: itt létrehozunk egy felnőtt predikátumot mindenki számára, aki betöltötte a 18. életévét. A test() metódus egész értéket kap és ellenőrzi.

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

Mi lesz a fenti kód kimenete? Az első esetben, mivel a 12 kisebb, mint 18, hamis lesz. Ami a második és a harmadik forgatókönyvet illeti, a feltételek teljesülnek, így a megtérülés igaz lesz.

alapértelmezett Predicate.and()

Ez a módszer az „és” operátort képviseli. Éppen ezért, ha az adott predikátumok egyike nem felel meg egy beállított feltételnek, egy másik nem kap értékelést. Példa: Készítsünk predikátumokat Java nyelven, és szűrjünk ki minden olyan személyt, aki már felnőtt, de 65 évnél fiatalabb az and() használatával . Használjuk a predicate.add () függvényt , és írjunk be egy java predikátumot lambdával a következő feltételekhez: Ha a feltétel igaz, az alkalmazás a következő utasítást adja vissza:

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

A kimenet a következő:

alapértelmezett Predicate.or()

A Predicate.or() metódus az „OR” operátort képviseli. Ez azt jelenti, hogy a feltétel akkor is igaz marad, ha két predikátum közül az egyik igaz, a másik pedig hamis. Példa: most értékeljük ki a karakterláncokat. Próbálja meg a VAGY módszerrel rendezni az összes olyan kifejezést, amely tartalmazza az „én” vagy a „kréta” részkarakterláncot.

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

A kimenet a következő:

alapértelmezett predikátum tagadása()

A negate() metódus az összes olyan érték összegyűjtésére szolgál, amely nem felel meg az előre meghatározott feltételeknek. Példa: ha a „Paradicsom” osztályt szeretné rendezni, és minden olyan bejegyzést meg szeretne találni, amely nem „piros”, írhat egy predikátumot, és gyorsan átvizsgálhatja a teljes sorozatot. Próbálja meg saját maga megírni ennek a kódnak a kódját, és ha elkészült, ellenőrizze a megoldással.

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

A kimenet a következő:

statikus predikátum egyenlő (Object targetRef)

Ez a módszer nagyon hasznos, ha meg akarja állapítani, hogy két objektum egyenlő-e az Objects.equals() paramétereként meghatározott értékkel. Ez a módszer különösen hasznos, ha hasonló vizsgálati eredményeket kell összehasonlítani. Példa: tegyük fel, hogy két kocsi körtét hasonlít össze, és meg akar győződni arról, hogy mindkettőnek szabványos súlyú és színű gyümölcse van. Ebben az esetben a statikus predikátum isEqual(Object targetRef) pontosan az a módszer, amire szüksége van. Nézzük meg, hogyan ellenőrzi az isEqual két karakterlánc egyenlőségét:

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

Ha egy elemzett objektum megfelel a szabványos feltételeknek, a függvény true értéket ad vissza. A kimenet a következő:

Java IntPredicate

A Java IntPredicate egy funkcionális interfész, így használható lambda-kifejezések vagy metódushivatkozások hozzárendelési célpontjaként. Az IntPredicate egy egész számmal működik, és egy feltétel alapján predikátumértéket ad vissza. Például a Predicate Interface, az IntPredicate is rendelkezik test() , and() , negate() vagy () metódusokkal. Íme egy példa az IntPredicate-re. Ezenkívül kiszűri az összes felnőttet (18 vagy több) a tömbből.

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

A kimenet a következő:

Tiszta predikátumok írása Java nyelven

A Java-predikátumok rendkívül funkcionálisak és szórakoztatóak velük dolgozni. Mindazonáltal, ha nincs tudatában annak, hogy a lambda-kifejezések milyen hatással vannak a kódra, fennáll a veszélye, hogy a kód karbantarthatósága csökken a rendetlen predikátumokkal. Íme néhány egyszerű gyakorlat, amelyek segítenek abban, hogy a funkcionális felületek könnyen kezelhetők és olvashatóak legyenek.

• Ne ismételje meg magát – ne állítson elő predikátumokat Java-val többször ismétlődő értékekkel, metódusokkal és feltételekkel. Ezzel a produktív idejét vesztegeti, és összezavarja a kódot.
• A tesztelhetőség biztosítása érdekében válassza le a predikátumokat az alkalmazáskódtól. Ettől eltekintve hozzon létre egy predikátumegység-tesztelési ütemtervet, és tartsa be azt.
• Használjon importálási és összetételi mintákat, hogy az osztályok ne legyenek dagadt, és könnyen kezelhetőek maradjanak.
• Fontolja meg a Java predikátumok Helper osztályokba való áthelyezését – így javítja a kód újrafelhasználhatóságát és megkönnyíti a karbantartást.
• Olvashatóság – amikor csak lehetséges, részesítse előnyben az egysoros utasításokat az összetett predikátumokkal szemben. Csábító lehet az összetett funkcionális interfészek ismerete. Ha azonban karbantartásról van szó, a kevesebb több.