Java 8 predikátumlánc
1. Áttekintés
Ebben a gyors bemutatóban megbeszéljük a láncolás különböző módjait Jóslatok a Java 8-ban.
2. Alap példa
Első, nézzük meg, hogyan kell használni az egyszerűt Állítmány szűrni a Lista nevek:
@Test public void whenFilterList_thenSuccess () {List names = Arrays.asList ("Adam", "Alexander", "John", "Tom"); Lista eredménye = names.stream () .filter (név -> név.startsWith ("A")) .collect (Collectors.toList ()); assertEquals (2, eredmény.méret ()); assertThat (az eredmény tartalmazza ("Ádám", "Sándor")); }
Ebben a példában szűrtük a mi Lista nevekből csak az A betűvel kezdődő neveket hagyja a Állítmány:
név -> név.kezdődik ("A")
De mi lenne, ha többször szeretnénk alkalmazni Jóslatok?
3. Több szűrő
Ha többször is szeretnénk alkalmazni Jóslatok, az egyik lehetőség az, hogy egyszerűen több szűrőt láncol:
@Test public void whenFilterListWithMultipleFilters_thenSuccess () {List result = names.stream () .filter (name -> name.startsWith ("A")) .filter (name -> name.length () <5) .collect (Collectors. toList ()); assertEquals (1, eredmény.méret ()); assertThat (eredmény, tartalmazza ("Ádám")); }
Most frissítettük a példánkat, hogy kiszűrje a listánkat az A betűvel kezdődő és 5-nél rövidebb nevek kinyerésével.
Két szűrőt használtunk - mindegyikhez egyet Állítmány.
4. Komplex Állítmány
Most ahelyett, hogy több szűrőt használna, egy szűrőt használhatunk egy komplexummal Állítmány:
@Test public void whenFilterListWithComplexPredicate_thenSuccess () {List result = names.stream () .filter (name -> name.startsWith ("A") && name.length () <5) .collect (Collectors.toList ()); assertEquals (1, eredmény.méret ()); assertThat (eredmény, tartalmazza ("Ádám")); }
Ez az opció rugalmasabb, mint az első, as bitenkénti műveleteket használhatunk a Állítmányamilyen összetett akarunk.
5. Kombinálás Jóslatok
Ezután, ha nem akarunk komplexumot építeni Állítmány bitenkénti műveletek segítségével a Java 8 Állítmány rendelkezik hasznos módszerekkel, amelyeket kombinálhatunk Jóslatok.
Kombináljuk Jóslatok a módszerek felhasználásával Predikátum.és (), Predikál. Vagy (), és Predikáljuk.negate ().
5.1. Predikátum.és ()
Ebben a példában meghatározzuk a sajátunkat Jóslatok kifejezetten, és akkor ezeket kombináljuk a használatával Predikátum.és ():
@Test public void whenFilterListWithCombinedPredicatesUsingAnd_thenSuccess () {predikátum predikátum1 = str -> str.startsWith ("A"); Predikátum predikátum2 = str -> str.hossz () <5; Lista eredménye = nevek.folyam () .szűrő (predikátum1.és (predikátum2)) .collect (Collectors.toList ()); assertEquals (1, eredmény.méret ()); assertThat (eredmény, tartalmazza ("Ádám")); }
Mint láthatjuk, a szintaxis meglehetősen intuitív, és a metódusnevek a művelet típusát sugallják. Használata és(), leszűrtük a Lista csak olyan nevek kinyerésével, amelyek mindkét feltételnek megfelelnek.
5.2. Predikál. Vagy ()
Használhatjuk is Predikál. Vagy () kombinálni Jóslatok.
Vegyük ki a „J” betűvel kezdődő neveket, valamint a 4-nél rövidebb neveket:
@Test public void whenFilterListWithCombinedPredicatesUsingOr_thenSuccess () {predikátum predikátum1 = str -> str.startsWith ("J"); Predikátum predikátum2 = str -> str.hossz () <4; Lista eredménye = nevek.folyam () .szűrő (predikátum1.vagy (állítmány2)) .collect (Gyűjtők.lista ()); assertEquals (2, eredmény.méret ()); assertThat (eredmény, tartalmazza ("John", "Tom")); }
5.3. Predicate.negate ()
Tudjuk használni Predicate.negate () amikor kombináljuk a mi Jóslatok is:
@Test public void whenFilterListWithCombinedPredicatesUsingOrAndNegate_thenSuccess () {predikátum predikátum1 = str -> str.startsWith ("J"); Predikátum predikátum2 = str -> str.hossz () <4; Lista eredménye = nevek.folyam () .szűrő (predikátum1.vagy (predikátum2.negát ())) .gyűjtés (Gyűjtők.Listára ()); assertEquals (3, eredmény.méret ()); assertThat (az eredmény tartalmazza ("Adam", "Alexander", "John")); }
Itt a következők kombinációját használtuk vagy() és tagadás () hogy kiszűrje a Lista olyan nevekkel, amelyek „J” betűvel kezdődnek, vagy amelyek hossza nem kevesebb, mint 4.
5.4. Kombájn Jóslatok Sorban
Nem kell kifejezetten meghatároznunk a sajátjainkat Jóslatok használni és(),vagy(), és tagadni ().
Ezeket inline is felhasználhatjuk a Állítmány:
@Test public void mikor .collect (Collectors.toList ()); assertEquals (1, eredmény.méret ()); assertThat (eredmény, tartalmazza ("Ádám")); }
6. A gyűjtemény összevonása Jóslatok
Végül, nézzük meg, hogyan lehet láncolni egy gyűjteményt Jóslatok csökkentésével.
A következő példában a Lista nak,-nek Jóslatok hogy kombináltuk Predikátum.és ():
@Test public void whenFilterListWithCollectionOfPredicatesUsingAnd_thenSuccess () {List allPredicates = new ArrayList(); allPredicates.add (str -> str.startsWith ("A")); allPredicates.add (str -> str.contains ("d")); allPredicates.add (str -> str.length ()> 4); Lista eredménye = names.stream () .filter (allPredicates.stream (). Reduc (x-> true, Predicate :: and)) .collect (Collectors.toList ()); assertEquals (1, eredmény.méret ()); assertThat (eredmény, tartalmazza ("Sándor")); }
Ne feledje, hogy alapazonosságunkat a következőként használjuk:
x-> igaz
De ez más lesz, ha kombinálni akarjuk őket a használatával Predikál. Vagy ():
@Test public void whenFilterListWithCollectionOfPredicatesUsingOr_thenSuccess () {List result = names.stream () .filter (allPredicates.stream (). Reduc (x-> false, Predicate :: or)) .collect (Collectors.toList ()); assertEquals (2, eredmény.méret ()); assertThat (az eredmény tartalmazza ("Ádám", "Sándor")); }
7. Következtetés
Ebben a cikkben különböző módszereket tártunk fel a predikátumok láncolására a Java 8 alkalmazásban szűrő(), épületegyüttes Jóslatok, és kombinálva Jóslatok.
A teljes forráskód elérhető a GitHubon.