【问题标题】:Meaning and usage of Predicates Java 8谓词的含义和用法 Java 8
【发布时间】:2017-05-25 10:16:54
【问题描述】:

我正在学习函数式接口、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&lt;Employee&gt; 而不是boolean?

2) 第 2 行的 o/p 即变量 'predicate1' 的值是“ lambdaandrelated.EmployeePredicates$$Lambda$1/746292446@4617c264 ”。但是变量“predicate1”的类型是Predicate&lt;Employee&gt;。这里的后台发生了什么?

3) 否定Predicate 是什么意思?如果这意味着否定boolean o/p,那么它不应该应用于test() 方法的o/p,而不是应用于谓词本身(如第3 行中所做的那样)。如果这意味着否定Predicate 对象,那么为什么以及如何否定test() 方法的o/p?在将boolean 值从true 更改为false 的背景中发生了什么。是返回的谓词对象的类型决定了 test() 方法的操作吗?

4) 当negate() 的返回类型也是Predicate&lt;T&gt; 时,Line4 的 o/p 也是“java.util.function.Predicate$$Lambda$2/2055281021@5ca881b5”,这看起来很好。那为什么isMale()/isFemale()的o/p格式不一样呢?

【问题讨论】:

    标签: java lambda java-8 predicate functional-interface


    【解决方案1】:
    1. isMale() 是一个返回Predicate&lt;Employee&gt; 的方法,它是一个功能接口,具有一个接受Employee 并返回boolean 的方法。

      该方法不会返回给定Employee 的布尔值。它返回一个可应用于任何Employee 的函数并返回一个布尔值。

    2. 当您打印引用变量时,您会看到该变量引用的对象的运行时类型,而不是其编译时类型(当然,这是假设运行时类型不会覆盖 toString) . lambda 表达式是一种实现函数式接口的方法。如果您使用某个类Predicate&lt;Employee&gt; predicate1 = new ClassThatImplementsPrdicateEmployee() 显式实现了接口,则打印predicate1 将为您提供该类的名称ClassThatImplementsPrdicateEmployee 而不是Predicate。同样,对于 lambda 表达式,编译器会生成返回的名称,类似于匿名类实例的情况。

    3. 至于negate是做什么的,看默认实现:

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

      它返回一个Predicate,其实现是对给定参数应用原始Predicate的test()方法的否定。

    【讨论】:

    • 关于您的声明“该方法不会返回给定员工的布尔值。它返回一个可应用于任何员工并返回布尔值的函数。” - 它是否返回一个函数或 Predicate 类型的对象,您可以在其上调用 test() 方法,该方法的实现已经通过 lambda 表达式提供?
    • @parul 我的意思是函数,因为该术语用于函数式编程。是的,在 Java 中,函数式编程的底层支持使用函数式接口(例如 Predicate),可以使用 lambda 表达式、方法引用、匿名类实例或常规类实例来实现。
    【解决方案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 = /Your/Path

    所以这是类的来源,名称由编译器生成。

    3人用

    基本上是指!= 用于Predicate 而不是==。如果您查看negate 的实现,这应该很清楚:

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

    应用测试,然后否定结果。

    【讨论】:

    • For 3 - 我可以断定 negate() 创建一个新的谓词,该谓词的 test() 方法的实现等于 negate() 的谓词的 test() 方法的否定叫什么?
    • @parul 我认为在negate() 上创建并返回了一个新谓词,当你返回一个新的 lambda 时会发生这种情况
    【解决方案3】:

    1) 每当您使用 lambda 时,您就是在创建一个 函数。在这种情况下,您指定该函数应为 Predicate 类型。由于接口谓词只有一个方法可以实现,所以'->'后面的部分就是那个函数的实现。

    2) println 将调用该对象上的 toString(),它是 Predicate 对象。 Lamdas 将有一个 toString 方法的默认实现,种类可以帮助您找到它的创建位置。

    3) .negate() 将创建一个 全新 谓词,然后可以对其进行测试。它会返回相反的值。

    【讨论】:

      猜你喜欢
      • 1970-01-01
      • 1970-01-01
      • 2021-10-21
      • 1970-01-01
      • 1970-01-01
      • 1970-01-01
      • 1970-01-01
      • 1970-01-01
      • 2018-07-01
      相关资源
      最近更新 更多