Die Anleitung zu Java Predicate

Predicate
Predicate + Method reference
negate()
and(Predicate other)
or(Predicate other)
isEqual(Object targetRef)

1. Predicate

In Java 8 ist Predicate eine functional interface, die einen Operator darstellt, der einen Eingabeparameter akzeptiert und einen Wert boolean zurückgibt.

Die Anleitung zu Java Functional Interface

Predicate

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

Z.B: Erstellen Sie eine Predicate um zu prüfen, ob die Zahl gerade ist oder nicht.

PredicateEx1.java

package org.o7planning.ex;

import java.util.function.Predicate;

public class PredicateEx1 {

    public static void main(String[] args) {
        
        Predicate<Integer> tester = value -> value % 2 == 1;
        
        int value = 11;
        
        System.out.println(value + " Is an Odd Number? " + tester.test(value));
    }
}

Output:

11 Is an Odd Number? true

Predicate wird auch benutzt um zu prüfen, ob die Elemente in einer Liste eine Bedingung erfüllt oder nicht.

Z.B: Eine Liste der Integer, wir werden eine neue Liste mit der ungeraden Zahlen filtern.

PredicateEx2.java

package org.o7planning.ex;

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class PredicateEx2 {

    public static void main(String[] args) {

        Predicate<Integer> tester = value -> value % 2 == 1;

        List<Integer> list = Arrays.asList(10, 11, 13, 14, 15, 16, 17);

        // @see: stream.filter(Predicate)
        List<Integer> newList = list.stream() //
                .filter(tester).collect(Collectors.toList());
 
        // @see: list.forEach(Consumer)
        newList.forEach(System.out::println);
    }
}

Output:

Z.B: Aus einer Liste der Personennamen drucken Sie nur die Namen aus, die mit der Buchstabe "S" beginnen:

PredicateEx3.java

package org.o7planning.ex;

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

public class PredicateEx3 {

    public static void main(String[] args) {

        Predicate<String> tester = name -> name.startsWith("S");

        List<String> names = Arrays.asList("John", "Smith", "Samueal", "Catley", "Sie");

        // @see: stream.filter(Predicate)
        // @see: stream.forEach(Consumer)
        names.stream().filter(tester).forEach(System.out::println);
    }
}

Output:

Smith
Samueal
Sie

BiPredicate
IntPredicate
LongPredicate
DoublePredicate
Supplier
Consumer
BiConsumer
Function
BiFunction

2. Predicate + Method reference

Als Nächstes werden Beispiel für die Erstellung einer Predicate aus einer Methodenreferenz, die Klassen Employee und EmployeeUtils nehmen an diesen Beispiel teil.

Employee.java

package org.o7planning.ex;

public class Employee {

    private String name;
    private float salary;
    private String gender; // "M", "F"

    public Employee(String name, float salary, String gender) {
        this.name = name;
        this.salary = salary;
        this.gender = gender;
    }

    public String getName() {
        return name;
    }

    public float getSalary() {
        return salary;
    }

    public String getGender() {
        return gender;
    }

    public boolean isFemale() {
        return "F".equals(this.getGender());
    }
}

EmployeeUtils.java

package org.o7planning.ex;

public class EmployeeUtils {
    
    public static boolean isHighSalary(Employee e) {
        return e.getSalary() > 5000;
    }
}

M.ref Example 1:

Wenn ein statische Methode einen Parameter mit dem Typ <T> hat und das Typ boolean zurückgibt, kann seine Referenz als Predicate<T> behandelt werden:

Z.B: die statische Methode EmployeeUtils.isHighSalary(Employee) ist ein Predicate<Employee>:

Predicate<Employee> p = EmployeeUtils::isHighSalary;

// Same as:

Predicate<Employee> p = employee -> EmployeeUtils.isHighSalary(employee);

Predicate_mr_ex1.java

package org.o7planning.ex;

import java.util.function.Predicate;

public class Predicate_mr_ex1 {

    public static void main(String[] args) {
        
        Employee sophia = new Employee("Sophia B.", 7000, "F");
        
        // Create a Predicate from a method reference.
        Predicate<Employee> tester = EmployeeUtils::isHighSalary;
        
        System.out.println("High Salary? " + tester.test(sophia));
    }
}

Output:

High Salary? true

M.ref Example 2:

Employee.isFemale() ist eine unstatische Methode (non-static) ohne Paramter und gibt das Typ boolean zurück. Seine Parameter wird als Predicate<Employee> behandelt:

Predicate<Employee> p = Employee::isFemale;

// Same as:

Predicate<Employee> p = employee -> employee.isFemale();

Predicate_mr_ex2.java

package org.o7planning.ex;

import java.util.function.Predicate;

public class Predicate_mr_ex2 {

    public static void main(String[] args) {
        
        Employee sophia = new Employee("Sophia B.", 7000, "F");
        
        // Create a Predicate from a method reference.
        Predicate<Employee> tester = Employee::isFemale;
        
        System.out.println("High Salary? " + tester.test(sophia));
    }
}

Output:

High Salary? true

3. negate()

Die Methode negate() gibt ein neues Objekt Predicate zurück, dessen Ergebnis ist ein Negativ des aktuellen Predicate .

default Predicate<T> negate() {
    return (t) -> !test(t);
}

Z.B: Eine Liste der Integer, wir werden eine Liste mit der lediglich geraden Zahlen filtern.

PredicateEx7.java

package org.o7planning.ex;

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class PredicateEx7 {

    public static void main(String[] args) {

        
        // Checks if a number is odd.
        Predicate<Integer> tester = value -> value % 2 == 1;

        List<Integer> list = Arrays.asList(10, 11, 13, 14, 15, 16, 17);

        // @see: stream.filter(Predicate)
        List<Integer> newList = list.stream() //
                .filter(tester.negate()).collect(Collectors.toList());
 
        // @see: list.forEach(Consumer)
        newList.forEach(System.out::println);
    }
}

Output:

10
14
16

Die Anleitung zu Java Stream

4. and(Predicate other)

Die Methode and(other) erstellt ein neues Objekt Predicate aus der Kombination des aktuellen Objekt Predicate und other. Sie wird als true gewertet wenn beide, das aktuelle Predicate und other als true gewertet werden.

default Predicate<T> and(Predicate<? super T> other) {
    Objects.requireNonNull(other);
    return (t) -> test(t) && other.test(t);
}

Z.B: Eine Liste der Integer, wir werden eine neue Liste herausfiltern, die die ungerade Zahlen und größer als 20 enthältet.

PredicateEx8.java

package org.o7planning.ex;

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class PredicateEx8 {

    public static void main(String[] args) {

        // Test if a number is odd.
        Predicate<Integer> tester1 = value -> value % 2 == 1;
        // Test if anumber > 20
        Predicate<Integer> tester2 = value -> value > 20;

        List<Integer> list = Arrays.asList(10, 11, 13, 14, 15, 16, 17, 25, 27, 26, 28);

        // A List of odd and greater than 20.
        // @see: stream.filter(Predicate)
        List<Integer> newList = list.stream() //
                .filter(tester1.and(tester2)).collect(Collectors.toList());
 
        // @see: list.forEach(Consumer)
        newList.forEach(System.out::println);
    }
}

Output:

25
27

Die Anleitung zu Java Stream

5. or(Predicate other)

Die Methode or(other) gibt ein neues Objekt Predicate aus der Verbindung der aktuellen Objekte Predicate und other. Sie wird true gewertet wenn die beiden, die aktuelle Predicate oder other als true gewertet werden.

default Predicate<T> or(Predicate<? super T> other) {
    Objects.requireNonNull(other);
    return (t) -> test(t) || other.test(t);
}

Z.B: In einer Liste der Personennamen, drucken Sie die Namen aus, die mit der Buchstabe "A" beginnen oder mit dem "p" endet.

PredicateEx9.java

package org.o7planning.ex;

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

public class PredicateEx9 {

    public static void main(String[] args) {

        List<String> names = Arrays.asList("Peter", "Martin", "Alex", "Philip", "Piyush", "Mike");

        Predicate<String> tester1 = name -> name.startsWith("A");
        Predicate<String> tester2 = name -> name.endsWith("p");

        // find a name starts with "A" or ends with "p"
        names.stream().filter(tester1.or(tester2)).forEach(System.out::println);
    }
}

Output:

Alex
Philip

6. isEqual(Object targetRef)

Die statische Methode Predicate.isEqual(targetRef) gibt ein Predicate zurück um zu prüfen, ob 2 Objekte mit der Verwendung von Methode Objects.equals(Object,Object) gleich sind oder nicht sind.

static <T> Predicate<T> isEqual(Object targetRef) {
    return (null == targetRef)
            ? Objects::isNull
            : object -> targetRef.equals(object);
}

PredicateEx10.java

package org.o7planning.ex;

import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.function.Predicate;

public class PredicateEx10 {

    public static void main(String[] args) {

        Predicate<String> test1 = Predicate.isEqual("Mike");
        
        // test1 same as test2:
        Predicate<String> test2 = myIsEqual("Mike");
        
        List<String> names = Arrays.asList(
                "Peter",
                "Martin",
                "Alex",
                "Philip",
                "Piyush",
                "Mike"
               );
             
               
       // Find a name that is equals "Mike"
       names.stream()
            .filter(test1)
            .forEach(System.out::println);
    }

    public static <T> Predicate<T> myIsEqual(Object targetRef) {
        Predicate<T> tester = obj -> Objects.equals(obj, targetRef);
        return tester;
    }
}

Output:

Mike

Die Anleitung zu Java Predicate

1. Predicate

2. Predicate + Method reference

3. negate()

4. and(Predicate other)

5. or(Predicate other)

6. isEqual(Object targetRef)

Java Grundlagen

Java Grundlagen

Neueste Artikel