Lernen Prädikat: Datenfilterung

Swipe um das Menü anzuzeigen

Der Hauptzweck von Predicate ist die komfortable Datenfilterung basierend auf einer bestimmten Bedingung. Dieses funktionale Interface enthält eine einzige abstrakte Methode:

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

Zusätzlich stellt es Standardmethoden zur Kombination von Bedingungen bereit, wie and(), or() und negate(), auf die wir später eingehen werden.

Praktische Anwendung

Die Syntax für alle funktionalen Schnittstellen folgt einem ähnlichen Muster und ist recht einfach:

Predicate<T> predicate = t -> condition;

Hierbei steht T für den Typ des Eingabearguments, und condition ist ein Ausdruck, der entweder true oder false zurückgibt.

Angenommen, es soll überprüft werden, ob eine gegebene Zahl gerade ist. Dafür kann ein Predicate wie folgt verwendet werden:

Main.java


              1234567891011121314151617
            
package com.example;

import java.util.function.Predicate;

public class Main {
    public static void main(String[] args) {
        // Condition: Check if a number is even
        Predicate<Integer> isEven = number -> number % 2 == 0;

        int number = 4;
        if (isEven.test(number)) {
            System.out.println(number + " is an even number.");
        } else {
            System.out.println(number + " is an odd number.");
        }
    }
}

Dieser Code verwendet die Methode test() des Predicate-Interfaces, die für Bedingungsprüfungen konzipiert ist. Beim Aufruf von test() wird die im Lambda-Ausdruck number -> number % 2 == 0 definierte Logik ausgeführt, wobei überprüft wird, ob die Zahl ohne Rest durch 2 teilbar ist, was ihre Geradzahligkeit bestimmt.

Hier wird Predicate verwendet, um zu überprüfen, ob eine gegebene Zahl gerade ist, und die Methode test() wendet die Bedingung an.

Bedingungen kombinieren

Predicate bietet die Möglichkeit, Bedingungen zu kombinieren mittels der Methoden and(), or() und negate(). Dadurch sind komplexere Prüfungen möglich. Im Folgenden einige Beispiele:

UND-Bedingung

Angenommen, es soll geprüft werden, ob eine Zahl zwei Kriterien erfüllt: Sie muss größer als 10 und gerade sein.

Hierfür kann die Methode and() verwendet werden, ähnlich wie der Operator && in Java, um sicherzustellen, dass beide Bedingungen true zurückgeben müssen.

Main.java


              1234567891011121314151617181920212223
            
package com.example;

import java.util.function.Predicate;

public class Main {
    public static void main(String[] args) {
        // Condition 1: The number is greater than 10
        Predicate<Integer> isGreaterThanTen = number -> number > 10;

        // Condition 2: The number is even
        Predicate<Integer> isEven = number -> number % 2 == 0;

        // Combined condition: The number is greater than 10 and even
        Predicate<Integer> combinedCondition = isGreaterThanTen.and(isEven);

        int number = 12;
        if (combinedCondition.test(number)) {
            System.out.println(number + " meets both conditions.");
        } else {
            System.out.println(number + " does not meet the conditions.");
        }
    }
}

Die Methode and() verknüpft zwei Bedingungen. Eine Zahl muss beide Kriterien erfüllen, damit das Ergebnis true ist.

ODER-Bedingung

Angenommen, es soll geprüft werden, ob eine Zahl entweder kleiner als 5 oder größer als 15 ist.

Die Methode or() kann wie der Operator || in Java verwendet werden, um sicherzustellen, dass mindestens eine der Bedingungen true zurückgibt.

Main.java


              1234567891011121314151617181920212223
            
package com.example;

import java.util.function.Predicate;

public class Main {
    public static void main(String[] args) {
        // Condition 1: The number is less than 5
        Predicate<Integer> isLessThanFive = number -> number < 5;

        // Condition 2: The number is greater than 15
        Predicate<Integer> isGreaterThanFifteen = number -> number > 15;

        // Combined condition: The number is less than 5 or greater than 15
        Predicate<Integer> combinedCondition = isLessThanFive.or(isGreaterThanFifteen);

        int number = 3;
        if (combinedCondition.test(number)) {
            System.out.println(number + " meets at least one of the conditions.");
        } else {
            System.out.println(number + " does not meet any of the conditions.");
        }
    }
}

Die Methode or() prüft, ob eine Zahl mindestens eine der angegebenen Bedingungen erfüllt. Dies ist nützlich, wenn das Erfüllen eines einzigen Kriteriums ausreichend ist.

NEGATE-Bedingung

Angenommen, es soll überprüft werden, ob eine Zeichenkette nicht leer ist.

Die Methode negate() kann verwendet werden, ähnlich wie der Operator ! in Java, um das Ergebnis einer Bedingung umzukehren.

Main.java


              1234567891011121314151617181920
            
package com.example;

import java.util.function.Predicate;

public class Main {
    public static void main(String[] args) {
        // Condition: The string is empty
        Predicate<String> isEmpty = str -> str == null || str.isEmpty();

        // Condition: The string is not empty
        Predicate<String> isNotEmpty = isEmpty.negate();

        String text = "Hello";
        if (isNotEmpty.test(text)) {
            System.out.println("The string contains text: " + text);
        } else {
            System.out.println("The string is empty.");
        }
    }
}

Die Methode negate() kehrt eine Bedingung um. Gibt die ursprüngliche Bedingung true zurück, liefert die negierte Version false und umgekehrt.