Predicates Java 8的含義和用法

Question

我正在學習功能接口，lambda表達式和謂詞的概念。 我可以在互聯網上使用示例編寫程序，但我仍然不清楚某些結構。

這是我的類Employee有3個數據成員，一個構造函數和相應的setter和getter。

package lambdaandrelated;

public class Employee {

    private String name;

    private String gender;

    private int age;

    public Employee(String name, String gender, int age) {
        super();
        this.name = name;
        this.gender = gender;
        this.age = age;
    }



    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

這是另一個有3種方法可以檢查的類：

一種。 員工是否是男性。 灣 員工是否是女性。 C。 員工的年齡是否大於通過的年齡。

package lambdaandrelated;

import java.util.function.Predicate;

    public class EmployeePredicates {

        public static Predicate<Employee> isMale(){
            return emp -> emp.getGender().equalsIgnoreCase("Male");  - **Line 1**
        }

        public static Predicate<Employee> isFemale(){
            return emp -> emp.getGender().equalsIgnoreCase("Female");
        }

        public Predicate<Employee> isGreaterThan(Integer age){
            return emp -> emp.getAge()>age;
        }
    }

這是我的主要課程：

package lambdaandrelated;

import java.util.function.Predicate;

public class EmployeeMain {

    public static void main(String[] args) {
        Employee emp1 = new Employee("Parul", "Female", 24);
        Employee emp2 = new Employee("Kanika", "Female", 24);
        Employee emp3 = new Employee("Sumit", "Male", 27);


        Predicate<Employee> predicate1 = new EmployeePredicates().isGreaterThan(23);
        System.out.println(predicate1);  **Line2**
        boolean value = predicate1.test(emp3);
        System.out.println(value);

        boolean value1 = predicate1.negate().test(emp3);  **Line3**
        System.out.println(value1);

        System.out.println(predicate1.negate()); **Line4**



    }
}

我的疑惑：

1）第1行是Predicate接口的test()方法的實現嗎？ 如果是，為什么返回類型的方法isMale()是Predicate<Employee>而不是boolean ？

2）第2行的o / p即變量'predicate1'的值是“lambdaandrelated.EmployeePredicates $$Lambda $ 1 /746292446@4617c264”。 但變量'predicate1'的類型為Predicate<Employee> 。 背景中發生了什么？

3）否定Predicate是什么意思？ 如果它意味着否定boolean o / p，那么它是否應該應用於test()方法的o / p而不是應用於謂詞本身（如在Line3中所做的那樣）。 如果它意味着否定Predicate對象，那么test()方法的o / p為什么以及如何被否定？ 在后台將boolean值從true更改為false會發生什么。 返回的謂詞對象的類型是否決定了test（）方法的o / p？

4）當negate()的返回類型也是Predicate<T>時，Line4的o / p也是“java.util.function.Predicate$$Lambda$2/2055281021@5ca881b5”。 那么為什么isMale() / isFemale()的o / p不是相同的格式呢？

Answer 1

1. isMale()是一個返回Predicate<Employee> ，它是一個函數接口，具有接受Employee並返回boolean的單個方法。

   該方法不會為給定的Employee返回該布爾值。 它返回一個可以應用於任何Employee並返回一個布爾值的函數。

2. 當您打印引用變量時，您會看到該變量引用的對象的運行時類型，而不是其編譯時類型（當然，這是假設運行時類型不會覆蓋toString ）。 lambda表達式是一種實現功能接口的方法。 如果使用某些類Predicate<Employee> predicate1 = new ClassThatImplementsPrdicateEmployee()顯式實現了接口，則打印predicate1將為您提供該類ClassThatImplementsPrdicateEmployee名稱，而不是Predicate 。 類似地，在lambda表達式的情況下，編譯器生成返回的名稱，類似於匿名類實例。

3. 至於否定的做法，請查看默認實現：

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

   它返回一個Predicate其實現是對給定參數應用原始Predicate的test()方法的否定。

Answer 2

1 ：

你可能寫得略有不同，可能會有意義：

public static Predicate<Employee> isMale() {
    return new Predicate<Employee>() {
        @Override
        public boolean test(Employee emp) {
            return emp.getGender().equalsIgnoreCase("Male");
        }
    };
}

boolean必須是Predicate#test的返回類型。 這個結構：

 return emp -> emp.getGender().equalsIgnoreCase("Male");

實際上返回一個Predicate ，它有一個返回布爾值的測試方法。

2

當編譯器看到lambda函數時，它會將該函數解釋為實際編寫此謂詞的類中的實例方法。

所以在你的EmployeePredicates你會有一些像這樣的方法（你可以反編譯並通過javap看到它們）：

private static boolean lambda$isFemale$0(Employee employee ){
    // your isFemale logic here
}

這時會出現在運行時生成一個類你Predicate ，將調用此方法。 該類名稱為： EmployeePredicates$$Lambda$1 。 您可以通過以下命令運行代碼再次查看此類名稱和代碼：

-Djdk.internal.lambda.dumpProxyClasses = /你/路徑

所以這是類來自的地方，名稱由編譯器生成。

3

基本上就是手段!=對於Predicate而不是== 。 如果你看一下negate的實現，這應該是明確的：

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

應用測試，然后否定結果。

Answer 3

1）每當你使用lambda時，你都在創建一個函數 。 在這種情況下，您指定該函數應為Predicate類型。 由於Interface Predicate只有一種方法可以實現，因此' - >'之后的部分是該函數的實現。

2）println將在該對象上調用toString（），該對象是Predicate對象。 Lamdas將有toString方法哪種幫助您找到在創建它的默認實現。

3）.negate（）將創建一個全新的謂詞，而后者又可以進行測試。 它將返回相反的值。