Java Predicate Functional Interface

Predicate<T> ist das funktionale Interface für die Frage „Ist dieser Wert in Ordnung?" — eine Eingabe vom Typ T, eine boolean-Antwort. Es steht im Mittelpunkt von Stream.filter, Collection.removeIf, Optional.filter und jeder JDK-Methode, die bedeutet „behalte die passenden Elemente." Das Interface ist klein — eine einzige test(T)-Methode — enthält aber eine kleine Kombinatoralgebra (and, or, negate, isEqual, not), mit der sich komplexe Bedingungen aus einfachen zusammensetzen lassen, ohne je selbst den booleschen Verbindungscode schreiben zu müssen.

Dieses Kapitel hat dieselbe Struktur wie die übrigen Interface-Vertiefungen in Teil 12: das Interface, seine drei oder vier nützlichen Methoden, die Algebra und ein durchgearbeitetes Beispiel.

Das Interface

Die gesamte Deklaration, vereinfacht:

@FunctionalInterface
public interface Predicate<T> {
  boolean test(T t);                         // the only abstract method

  default Predicate<T> and(Predicate<? super T> other);
  default Predicate<T> or(Predicate<? super T> other);
  default Predicate<T> negate();
  static  <T> Predicate<T> isEqual(Object target);
  static  <T> Predicate<T> not(Predicate<? super T> target);   // Java 11+
}

test ist die einzige abstrakte Methode, die Lambdas und Methodenreferenzen implementieren. Alles andere baut darauf auf. Sie werden test selten direkt aufrufen — stream().filter(...) und list.removeIf(...) erledigen das für Sie — aber der Methodenname ist wichtig, wenn Sie Code schreiben, der ein Predicate<T> entgegennimmt und es aufrufen muss.

Predicate<String> notBlank = s -> !s.isBlank();
boolean ok = notBlank.test("hello");          // true

`and`, `or`, `negate` — boolesche Algebra ohne Verbindungscode

Die drei Default-Methoden kombinieren Predicates auf die gleiche Weise, wie die Operatoren &&, ||, ! Booleans kombinieren:

Predicate<String> notNull  = Objects::nonNull;
Predicate<String> notBlank = s -> !s.isBlank();
Predicate<String> longEnough = s -> s.length() >= 3;

Predicate<String> useful   = notNull.and(notBlank).and(longEnough);
Predicate<String> usableOrShort = useful.or(s -> s.length() == 1);
Predicate<String> bad      = useful.negate();

Zwei Eigenschaften sind wichtig:

Kurzschlussauswertung in Deklarationsreihenfolge. a.and(b) ruft b.test nur auf, wenn a.test true zurückgegeben hat. a.or(b) ruft b.test nur auf, wenn a.test false zurückgegeben hat. Das entspricht der Auswertungsreihenfolge von && und ||, was bedeutet, dass günstige und häufig schlagende Prüfungen zuerst stehen können und die aufwändigen zuletzt.
Jeder Aufruf gibt ein neues Predicate zurück. Die Kombinatoren mutieren this nicht. Verwenden Sie die Originale so oft wie nötig weiter.

negate() kehrt das Ergebnis einfach um. useful.negate() gibt true für Nullwerte, Leerzeilen und Strings kürzer als 3 zurück — jeden Fall, den useful abgelehnt hat.

`Predicate.not` — die lesbare Negation

Java 11 hat eine statische Kurzform hinzugefügt:

list.removeIf(Predicate.not(String::isBlank));    // remove every blank string

Predicate.not(p) liefert dieselbe boolean-Antwort wie p.negate(), lässt sich aber an der Aufrufstelle viel natürlicher zusammensetzen. Die Methodenreferenz String::isBlank ist für sich allein ein Predicate<String> — aber (String::isBlank).negate() können Sie nicht schreiben, weil der Compiler einen Zieltyp benötigt, bevor er die Referenz auflösen kann. Predicate.not(String::isBlank) liefert diesen Zieltyp, und das Ganze liest sich wie „nicht leer" in der englischen Reihenfolge.

Ein statischer import von Predicate.not macht Filter-Chains noch klarer:

import static java.util.function.Predicate.not;
...
var nonBlank = lines.stream().filter(not(String::isBlank)).toList();

`Predicate.isEqual` — null-sichere Gleichheit

Predicate<Object> isFoo = Predicate.isEqual("foo");        // o -> Objects.equals(o, "foo")

Die Implementierung lautet buchstäblich t -> Objects.equals(target, t), was bedeutet, dass null auf beiden Seiten sicher verglichen wird. Sie spart selten Zeichen gegenüber s -> s.equals("foo"), schützt aber vor Fehlern, wenn der Stream null enthalten kann — null.equals("foo") würde eine NPE werfen, Objects.equals(null, "foo") gibt false zurück.

Wo `Predicate<T>` im JDK auftaucht

Dasselbe Predicate<T> fließt durch jede „Filter"-API:

Stream<String> kept = stream.filter(notBlank);             // Stream.filter
boolean removed     = list.removeIf(String::isBlank);      // Collection.removeIf
Optional<String> ok = opt.filter(notBlank);                // Optional.filter
boolean any         = stream.anyMatch(notBlank);           // anyMatch / allMatch / noneMatch
map.values().removeIf(String::isBlank);                    // Map view + Collection.removeIf

Jede dieser Methoden hat dieselbe Form, sodass ein einmal erstelltes Predicate<T> in jede Richtung wiederverwendbar ist — und die Zusammensetzung mit and/or/negate ist genau der Weg, den Geruch von „drei leicht unterschiedlichen Filtern, alle fast-Duplikate" zu vermeiden.

Primitive Spezialisierungen — `IntPredicate`, `LongPredicate`, `DoublePredicate`

Predicate<Integer> funktioniert mit int-Werten, boxt aber jeden Eingabewert. Für enge numerische Pipelines liefert das Paket:

IntPredicate    even = n -> n % 2 == 0;
LongPredicate   big  = n -> n > 1_000_000_000L;
DoublePredicate hot  = d -> d > 37.5;

Dieselbe and/or/negate-Algebra, kein Boxing. Diese sind das, was IntStream.filter akzeptiert — Predicate<Integer> dort zu verwenden würde den Stream zwingen, jedes Element beim Eingang per Autoboxing zu konvertieren.

`BiPredicate<T, U>` — Tests mit zwei Argumenten

Wenn die Frage zwei Eingaben nimmt (einen Schlüssel und einen Wert, eine Zeile und eine Spalte, einen alten und einen neuen Wert), verwenden Sie BiPredicate:

BiPredicate<String, Integer> longEnoughFor = (s, n) -> s.length() >= n;
boolean ok = longEnoughFor.test("hello", 4);             // true

Die Kombinatorfläche ist kleiner — and, or, negate sind vorhanden, aber es gibt kein zweiargumentiges isEqual oder not. Map.removeIf((k, v) -> ...) ist genau ein BiPredicate<K, V>.

Ein durchgearbeitetes Beispiel: Predicates, Komposition, die Algebra und wo sie eingebunden werden

Das folgende Programm erstellt drei kleine Predicates über User, kombiniert sie mit and/or/negate, demonstriert die Kurzschlussauswertung durch das Zählen von Aufrufen, verwendet Predicate.not für die Negation an einer removeIf-Aufrufstelle und nutzt ein IntPredicate mit einem IntStream, um die primitive Variante zu zeigen.

java— editable, runs on the server

import java.util.*;
import java.util.function.*;
import java.util.stream.*;
import static java.util.function.Predicate.not;

public class PredicateShowcase {
  record User(String name, int age, boolean active) {}

public static void main(String[] args) {
    List<User> users = new ArrayList<>(List.of(
        new User("Alice", 30, true),
        new User("Bob",   17, true),
        new User("Carol", 45, false),
        new User("Dan",   22, true),
        new User("",      28, true)));

// --- three building-block predicates ---
    Predicate<User> adult     = u -> u.age() >= 18;
    Predicate<User> active    = User::active;
    Predicate<User> namedWell = u -> !u.name().isBlank();

// --- composition ---
    Predicate<User> eligible = adult.and(active).and(namedWell);
    Predicate<User> minor    = adult.negate();
    Predicate<User> reachable = active.or(adult);   // either active OR an adult

System.out.println("eligible users:");
    users.stream().filter(eligible).forEach(u -> System.out.println("  " + u));
    System.out.println("minors:");
    users.stream().filter(minor).forEach(u -> System.out.println("  " + u));

// --- short-circuit demonstration ---
    int[] cheapCalls    = {0};
    int[] expensiveCalls = {0};
    Predicate<User> cheap     = u -> { cheapCalls[0]++; return u.age() >= 18; };
    Predicate<User> expensive = u -> { expensiveCalls[0]++; return !u.name().isBlank(); };
    Predicate<User> bothChecks = cheap.and(expensive);
    users.forEach(bothChecks::test);
    System.out.println("\nand: short-circuit calls"
        + "\n  cheap (always runs)      = " + cheapCalls[0]
        + "\n  expensive (after cheap)  = " + expensiveCalls[0]
        + "  -- skipped for the minor");

// --- Predicate.not at a removeIf call site ---
    List<String> tokens = new ArrayList<>(List.of("java", "", "  ", "stream", ""));
    tokens.removeIf(not(s -> !s.isBlank()));   // equivalent to: removeIf(String::isBlank)
    System.out.println("\nafter removeIf(not(non-blank)) = " + tokens);

// --- Predicate.isEqual, null-safe ---
    List<String> bag = Arrays.asList("foo", null, "bar", "foo");
    long foos = bag.stream().filter(Predicate.isEqual("foo")).count();
    System.out.println("\nisEqual(\"foo\") count over [foo,null,bar,foo] = " + foos);

// --- IntPredicate: primitive, no boxing ---
    IntPredicate even = n -> n % 2 == 0;
    IntPredicate big  = n -> n > 5;
    int countEvenAndBig = (int) IntStream.rangeClosed(1, 10).filter(even.and(big)).count();
    System.out.println("\neven AND >5 in 1..10 = " + countEvenAndBig);
  }
}

Was der Durchlauf zeigt:

Die drei Bausteine-Predicates (adult, active, namedWell) blieben wiederverwendbar. eligible, minor und reachable wurden durch Komposition erstellt, anstatt drei separate Lambdas mit überlappender Logik zu schreiben.
and hat genau so kurzgeschlossen wie &&: expensive lief seltener als cheap, weil jeder Minderjährige abgelehnt wurde, bevor die aufwändige Prüfung ausgelöst wurde. Das ist der Hebel für die Reihenfolge — günstige, häufig schlagende Prüfungen zuerst.
Predicate.not(...) an der removeIf-Aufrufstelle las sich wie normales Englisch ("remove if not non-blank") und vermied das Bedürfnis nach einem Zieltyp vor der Negation. Der statische import von not ist die kleine abschließende Verbesserung.
Predicate.isEqual("foo") zählte die zwei "foo"-Einträge über einem null hinweg ohne Fehler. s -> s.equals("foo") hätte beim null-Element eine NPE geworfen.
IntPredicate even = n -> n % 2 == 0; wurde direkt in IntStream.filter eingebunden ohne Boxing — und derselbe .and(...)-Kombinator funktioniert auch auf der primitiven Spezialisierung.

Was kommt als Nächstes

Predicate<T> antwortet mit ja oder nein. Das nächste Kapitel, Java Function-Interface, behandelt das Interface für die andere Hälfte der Stream-Arbeit: einen Wert in einen anderen transformieren. Die Form — einzige Methode, Default-Methoden-Komposition (andThen, compose, plus das statische identity()) — ist dieselbe wie bei Predicate, und dieselben Lektionen über Reihenfolge, Wiederverwendung und primitive Spezialisierungen gelten gleichermaßen.

Übungen

Übung

Sie haben `Predicate<String> notNull = Objects::nonNull;` und `Predicate<String> notBlank = s -> !s.isBlank();` und möchten ein Predicate, das `true` nur zurückgibt, wenn der String sowohl nicht-null als auch nicht-leer ist, wobei `notNull` *zuerst* geprüft wird, damit `notBlank` nie auf einem `null` aufgerufen wird. Welcher Ausdruck macht das korrekt?

`notNull.and(notBlank)` — `and` wertet von links nach rechts kurz; wenn `notNull` `false` zurückgibt, wird `notBlank` nicht aufgerufen`notBlank.and(notNull)` — die Reihenfolge bei `and` spielt keine Rolle, weil beide `true` sein müssen`Predicate.not(notNull).or(notBlank)` — kombiniert Null-Sicherheit mit der Leerzeichenprüfung`notNull.or(notBlank)` — `or` stellt die strenge Prüfung zuerst und fügt die lockere hinzu

Das Interface

and, or, negate — boolesche Algebra ohne Verbindungscode

Predicate.not — die lesbare Negation

Predicate.isEqual — null-sichere Gleichheit

Wo Predicate<T> im JDK auftaucht

Primitive Spezialisierungen — IntPredicate, LongPredicate, DoublePredicate

BiPredicate<T, U> — Tests mit zwei Argumenten