streamalism.org

1. Oversikt

I denne raske opplæringen, vi vil diskutere forskjellige måter å kjede på Predikater i Java 8.

2. Grunnleggende eksempel

Først, la oss se hvordan du bruker en enkel Predikere å filtrere a Liste av navn:

@Test offentlig ugyldig nårFilterList_thenSuccess () {List names = Arrays.asList ("Adam", "Alexander", "John", "Tom"); Listeresultat = names.stream () .filter (name -> name.startsWith ("A")) .collect (Collectors.toList ()); assertEquals (2, result.size ()); assertThat (resultatet inneholder ("Adam", "Alexander")); }

I dette eksemplet filtrerte vi vår Liste av navn for å bare la navn som starter med "A" bruke Predikere:

name -> name.startsWith ("A")

Men hva om vi ønsket å bruke flere Predikater?

3. Flere filtre

Hvis vi ønsket å bruke flere Predikater, et alternativ er å bare kjede flere filtre:

@Test public void whenFilterListWithMultipleFilters_thenSuccess () {List result = names.stream () .filter (name -> name.startsWith ("A")). Filter (name -> name.length () <5) .collect (Collectors. å liste opp()); assertEquals (1, result.size ()); assertThat (resultat, inneholder ("Adam")); }

Vi har nå oppdatert vårt eksempel for å filtrere listen vår ved å trekke ut navn som starter med "A" og har en lengde som er mindre enn 5.

Vi brukte to filtre - ett for hvert Predikere.

4. Kompleks Predikere

Nå, i stedet for å bruke flere filtre, vi kan bruke ett filter med et kompleks Predikere:

@Test offentlig ugyldig nårFilterListWithComplexPredicate_thenSuccess () {List result = names.stream () .filter (name -> name.startsWith ("A") && name.length () <5) .collect (Collectors.toList ()); assertEquals (1, result.size ()); assertThat (resultat, inneholder ("Adam")); }

Dette alternativet er mer fleksibelt enn det første, som vi kan bruke bitvise operasjoner for å bygge Predikereså komplisert som vi vil.

5. Kombinere Predikater

Neste, hvis vi ikke vil bygge et kompleks Predikere ved hjelp av bitvise operasjoner, Java 8 Predikere har nyttige metoder som vi kan bruke til å kombinere Predikater.

Vi kombinerer Predikater ved hjelp av metodene Predicate.and (), Predicate.or (), og Predikere.negate ().

5.1. Predicate.and ()

I dette eksemplet vil vi definere vår Predikater eksplisitt, og så kombinerer vi dem ved hjelp av Predicate.and ():

@Test public void whenFilterListWithCombinedPredicatesUsingAnd_thenSuccess () {Predicate predicate1 = str -> str.startsWith ("A"); Forutsi predikat2 = str -> str.lengde () <5; Listeresultat = names.stream () .filter (predicate1.and (predicate2)) .collect (Collectors.toList ()); assertEquals (1, result.size ()); assertThat (resultat, inneholder ("Adam")); }

Som vi kan se, er syntaksen ganske intuitiv, og metodenavnene antyder typen operasjon. Ved hjelp av og(), vi har filtrert vår Liste ved å trekke ut bare navn som oppfyller begge vilkårene.

5.2. Predicate.or ()

Vi kan også bruke Predicate.or () Å kombinere Predikater.

La oss trekke ut navn som starter med “J”, i tillegg til navn med en lengde som er mindre enn 4:

@Test offentlig ugyldig nårFilterListWithCombinedPredicatesUsingOr_thenSuccess () {Predicate predicate1 = str -> str.startsWith ("J"); Forutsi predikat2 = str -> str.length () <4; Listeresultat = names.stream () .filter (predicate1.or (predicate2)) .collect (Collectors.toList ()); assertEquals (2, result.size ()); assertThat (resultatet inneholder ("John", "Tom")); }

5.3. Predikere.negate ()

Vi kan bruke Predikere.negate () når du kombinerer vår Predikater også:

@Test offentlig ugyldig nårFilterListWithCombinedPredicatesUsingOrAndNegate_thenSuccess () {Predicate predicate1 = str -> str.startsWith ("J"); Forutsi predikat2 = str -> str.length () <4; Listeresultat = names.stream () .filter (predicate1.or (predicate2.negate ())) .collect (Collectors.toList ()); assertEquals (3, result.size ()); assertThat (resultatet inneholder ("Adam", "Alexander", "John")); }

Her har vi brukt en kombinasjon av eller() og negere () for å filtrere Liste etter navn som starter med “J” eller har en lengde som ikke er mindre enn 4.

5.4. Kombinere Predikater På linje

Vi trenger ikke å eksplisitt definere våre Predikater å bruke og(),eller(), og negere ().

Vi kan også bruke dem innebygd ved å støpe Predikere:

@Test offentlig ugyldig nårFilterListWithCombinedPredicatesInline_thenSuccess () {List result = names.stream () .filter (((Predicate) name -> name.startsWith ("A")). And (name -> name.length () <5)) .collect (Collectors.toList ()); assertEquals (1, result.size ()); assertThat (resultat, inneholder ("Adam")); }

6. Kombinere en samling av Predikater

Endelig, la oss se hvordan du kan kjede en samling av Predikater ved å redusere dem.

I det følgende eksemplet har vi en Liste av Predikater som vi kombinerte med Predicate.and ():

@Test offentlig ugyldig nårFilterListWithCollectionOfPredicatesUsingAnd_thenSuccess () {List allPredicates = ny ArrayList(); allPredicates.add (str -> str.startsWith ("A")); allPredicates.add (str -> str.contains ("d")); allPredicates.add (str -> str.length ()> 4); Listeresultat = names.stream () .filter (allPredicates.stream (). Reduser (x-> true, Predicate :: og)) .collect (Collectors.toList ()); assertEquals (1, result.size ()); assertThat (resultat, inneholder ("Alexander")); }

Merk at vi bruker vår baseidentitet som:

x-> sant

Men det vil være annerledes hvis vi vil kombinere dem ved hjelp av Predicate.or ():

@Test offentlig ugyldig nårFilterListWithCollectionOfPredicatesUsingOr_thenSuccess () {List result = names.stream () .filter (allPredicates.stream (). Reduce (x-> false, Predicate :: or)) .collect (Collectors.toList ()); assertEquals (2, result.size ()); assertThat (resultatet inneholder ("Adam", "Alexander")); }

7. Konklusjon

I denne artikkelen undersøkte vi forskjellige måter å kjede Predicates i Java 8 ved å bruke filter(), bygningskompleks Predikater, og kombinere Predikater.

Hele kildekoden er tilgjengelig på GitHub.