::(双冒号)操作符在Java 8

我在研究Java 8源代码时，发现这部分代码非常令人惊讶:

// Defined in IntPipeline.java
@Override
public final OptionalInt reduce(IntBinaryOperator op) {
    return evaluate(ReduceOps.makeInt(op));
}

@Override
public final OptionalInt max() {
    return reduce(Math::max); // This is the gotcha line
}

// Defined in Math.java
public static int max(int a, int b) {
    return (a >= b) ? a : b;
}

max是一个方法指针吗?一个正常的静态方法如何转换为IntBinaryOperator?

当前回答

所以我在这里看到了大量的答案，坦率地说，它们过于复杂，这是一种保守的说法。

答案很简单:**::被称为方法引用。在Method References中，如果向下滚动到表格，可以找到所有的信息。

现在，让我们来简单了解一下什么是方法引用:

A::b在一定程度上替代了以下内联lambda表达式:(parameters…)-> A.b(parameter…)

要将此与您的问题联系起来，有必要理解Java lambda表达式。这并不难。

内联lambda表达式类似于已定义的函数接口(即具有不多于一个方法的接口)。

让我们来看看我的意思:

InterfaceX f = (x) -> x*x;

InterfaceX必须是功能接口。任何函数接口，对于编译器来说，InterfaceX唯一重要的是你定义了格式:

InterfaceX可以是以下任何一种:

interface InterfaceX
{
    public Integer callMe(Integer x);
}

或:

interface InterfaceX
{
    public Double callMe(Integer x);
}

或者更一般的说法:

interface InterfaceX<T, U>
{
    public T callMe(U x);
}

让我们以第一个例子和前面定义的内联lambda表达式为例。

在Java 8之前，你可以这样定义它:

 InterfaceX o = new InterfaceX(){
                        public int callMe(int x)
                        {
                            return x*x;
                        }
                    };

功能上是一样的。不同之处在于编译器如何感知它。

现在我们已经了解了内联lambda表达式，让我们返回到方法reference(::)。假设你有一个这样的类:

class Q {
    public static int anyFunction(int x)
    {
        return x + 5;
    }
}

由于方法anyFunctions与InterfaceX callMe具有相同的类型，我们可以用一个方法引用来等效这两个方法。

我们可以这样写:

InterfaceX o =  Q::anyFunction;

这就相当于:

InterfaceX o = (x) -> Q.anyFunction(x);

方法引用的一个很酷的优点是，在将它们分配给变量之前，它们都是无类型的。因此，您可以将它们作为参数传递给任何具有相同外观(具有相同定义类型)的函数接口。这正是你的情况。

2018-11-07 16:51:48

其他回答

通常，我们会使用Math调用reduce方法。Max (int, int)如下:

reduce(new IntBinaryOperator() {
    int applyAsInt(int left, int right) {
        return Math.max(left, right);
    }
});

这需要大量的语法来调用Math.max。这就是lambda表达式发挥作用的地方。因为Java 8允许它以更短的方式做同样的事情:

reduce((int left, int right) -> Math.max(left, right));

这是如何工作的呢?java编译器“检测”到你想要实现一个接受两个int型并返回一个int型的方法。这等价于接口IntBinaryOperator的唯一方法的形式参数(要调用的方法reduce的参数)。所以编译器会帮你完成剩下的工作——它只是假设你想要实现IntBinaryOperator。

但作为数学。max(int, int)本身满足IntBinaryOperator的形式要求，它可以直接使用。因为Java 7没有任何允许方法本身作为参数传递的语法(你只能传递方法结果，但不能传递方法引用)，所以Java 8引入了::语法来引用方法:

reduce(Math::max);

注意，这将由编译器解释，而不是由JVM在运行时解释!虽然它为所有三个代码段生成了不同的字节码，但它们在语义上是相等的，因此后两个可以被认为是上面IntBinaryOperator实现的简短(而且可能更有效)版本!

(参见Lambda表达式的翻译)

2013-11-15 13:08:55

由于这里的许多答案都很好地解释了::行为，另外，我想澄清::操作符不需要与引用函数接口具有完全相同的签名，如果它用于实例变量。让我们假设我们需要一个类型为TestObject的BinaryOperator。传统的实现方式是这样的:

BinaryOperator<TestObject> binary = new BinaryOperator<TestObject>() {

        @Override
        public TestObject apply(TestObject t, TestObject u) {

            return t;
        }
    };

正如您在匿名实现中看到的，它需要两个TestObject参数并返回一个TestObject对象。为了通过使用::操作符来满足这个条件，我们可以从一个静态方法开始:

public class TestObject {


    public static final TestObject testStatic(TestObject t, TestObject t2) {
        return t;
    }
}

然后调用:

BinaryOperator<TestObject> binary = TestObject::testStatic;

它编译得很好。如果我们需要实例方法呢?让我们用一个实例方法更新TestObject:

public class TestObject {

    public final TestObject testInstance(TestObject t, TestObject t2) {
        return t;
    }

    public static final TestObject testStatic(TestObject t, TestObject t2) {
        return t;
    }
}

现在我们可以像下面这样访问实例:

TestObject testObject = new TestObject();
BinaryOperator<TestObject> binary = testObject::testInstance;

这段代码编译得很好，但下面的代码不行:

BinaryOperator<TestObject> binary = TestObject::testInstance;

我的Eclipse告诉我“不能从类型TestObject中对非静态方法testInstance(TestObject, TestObject)进行静态引用…”

很好。它是一个实例方法，但如果我们重载testInstance，如下所示:

public class TestObject {

    public final TestObject testInstance(TestObject t) {
        return t;
    }

    public final TestObject testInstance(TestObject t, TestObject t2) {
        return t;
    }

    public static final TestObject testStatic(TestObject t, TestObject t2) {
        return t;
    }
}

和电话:

BinaryOperator<TestObject> binary = TestObject::testInstance;

代码将正常编译。因为它将用一个参数而不是双参数调用testInstance。好的，那么两个参数发生了什么?让我们打印出来看看:

public class TestObject {

    public TestObject() {
        System.out.println(this.hashCode());
    }

    public final TestObject testInstance(TestObject t) {
        System.out.println("Test instance called. this.hashCode:" +
                            this.hashCode());
        System.out.println("Given parameter hashCode:" + t.hashCode());
        return t;
    }

    public final TestObject testInstance(TestObject t, TestObject t2) {
        return t;
    }

    public static final TestObject testStatic(TestObject t, TestObject t2) {
        return t;
    }
}

它将输出:

 1418481495
 303563356
 Test instance called. this.hashCode:1418481495
 Given parameter hashCode:303563356

好，JVM足够聪明，可以调用param1.testInstance(param2)。我们可以从其他资源中使用testInstance而不是TestObject吗?例如:

public class TestUtil {

    public final TestObject testInstance(TestObject t) {
        return t;
    }
}

和电话:

BinaryOperator<TestObject> binary = TestUtil::testInstance;

它只是不编译，编译器会说:“类型TestUtil没有定义testInstance(TestObject, TestObject)”。

因此，如果静态引用不是同一类型，编译器将查找它。那么多态性呢?如果我们删除最后的修饰符，并添加SubTestObject类:

public class SubTestObject extends TestObject {

    public final TestObject testInstance(TestObject t) {
        return t;
    }

}

和电话:

BinaryOperator<TestObject> binary = SubTestObject::testInstance;

它也不会编译。编译器仍然会查找静态引用。但是下面的代码可以很好地编译，因为它通过了is-a测试:

public class TestObject {

    public SubTestObject testInstance(Object t) {
        return (SubTestObject) t;
    }

}

BinaryOperator<TestObject> binary = TestObject::testInstance;

2017-03-06 13:33:48

::操作符是在Java 8中引入的，用于方法引用。方法引用是只执行一个方法的lambda表达式的简写语法。下面是方法引用的一般语法:

Object :: methodName

我们知道可以使用lambda表达式，而不是使用匿名类。但有时，lambda表达式实际上只是对某些方法的调用，例如:

Consumer<String> c = s -> System.out.println(s);

为了使代码更清晰，你可以将lambda表达式转换为方法引用:

Consumer<String> c = System.out::println;

2017-03-22 06:18:21

lambda表达式用于创建匿名方法。它什么也不做，只是调用一个现有的方法，但是直接引用方法的名称会更清楚。方法引用允许我们使用方法引用操作符::来实现。

考虑下面的简单类，其中每个员工都有姓名和级别。

public class Employee {
    private String name;
    private String grade;

    public Employee(String name, String grade) {
        this.name = name;
        this.grade = grade;
    }

    public String getName() {
        return name;
    }

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

    public String getGrade() {
        return grade;
    }

    public void setGrade(String grade) {
        this.grade = grade;
    }
}

假设我们有一个由某个方法返回的员工列表，并且我们希望根据员工的等级对其进行排序。我们知道我们可以使用匿名类作为:

    List<Employee> employeeList = getDummyEmployees();

    // Using anonymous class
    employeeList.sort(new Comparator<Employee>() {
           @Override
           public int compare(Employee e1, Employee e2) {
               return e1.getGrade().compareTo(e2.getGrade());
           }
    });

其中getDummyEmployee()是一个方法，如下:

private static List<Employee> getDummyEmployees() {
        return Arrays.asList(new Employee("Carrie", "C"),
                new Employee("Fanishwar", "F"),
                new Employee("Brian", "B"),
                new Employee("Donald", "D"),
                new Employee("Adam", "A"),
                new Employee("Evan", "E")
                );
    }

现在我们知道Comparator是一个功能接口。函数式接口是只有一个抽象方法的接口(尽管它可能包含一个或多个默认方法或静态方法)。Lambda表达式提供了@FunctionalInterface的实现，因此函数接口只能有一个抽象方法。我们可以这样使用lambda表达式:

employeeList.sort((e1,e2) -> e1.getGrade().compareTo(e2.getGrade())); // Lambda expression

看起来一切都很好，但是如果Employee类也提供类似的方法呢?

public class Employee {
    private String name;
    private String grade;
    // getter and setter
    public static int compareByGrade(Employee e1, Employee e2) {
        return e1.grade.compareTo(e2.grade);
    }
}

在这种情况下，使用方法名本身会更清楚。因此，我们可以通过使用方法引用直接引用该方法: employeeList.sort(员工::compareByGrade);//方法引用

根据文档，有四种方法引用:

+----+-------------------------------------------------------+--------------------------------------+
|    | Kind                                                  | Example                              |
+----+-------------------------------------------------------+--------------------------------------+
| 1  | Reference to a static method                          | ContainingClass::staticMethodName    |
+----+-------------------------------------------------------+--------------------------------------+
| 2  |Reference to an instance method of a particular object | containingObject::instanceMethodName |
+----+-------------------------------------------------------+--------------------------------------+
| 3  | Reference to an instance method of an arbitrary object| ContainingType::methodName           |
|    | of a particular type                                  |                                      |
+----+-------------------------------------------------------+--------------------------------------+
| 4  |Reference to a constructor                             | ClassName::new                       |
+------------------------------------------------------------+--------------------------------------+

2017-04-21 06:09:59

::是Java 8中包含的一个新操作符，用于引用现有类的方法。可以引用类的静态方法和非静态方法。

对于引用静态方法，语法为: