我在研究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?
当前回答
这是Java 8中的一个方法引用。Oracle文档在这里。
如文件所述……
方法引用Person::compareByAge是对静态对象的引用 方法。 类的实例方法的引用示例 特定对象:
class ComparisonProvider {
public int compareByName(Person a, Person b) {
return a.getName().compareTo(b.getName());
}
public int compareByAge(Person a, Person b) {
return a.getBirthday().compareTo(b.getBirthday());
}
}
ComparisonProvider myComparisonProvider = new ComparisonProvider();
Arrays.sort(rosterAsArray, myComparisonProvider::compareByName);
方法引用myComparisonProvider::compareByName调用方法compareByName 它是对象myComparisonProvider的一部分。JRE会推断 方法类型参数，在本例中为(Person, Person)。
其他回答
::被称为方法引用。假设我们想调用类Purchase的calculatePrice方法。那么我们可以写成:
Purchase::calculatePrice
它也可以被视为lambda表达式的一种简写形式，因为方法引用被转换为lambda表达式。
双冒号，即::操作符，在Java 8中作为方法引用引入。方法引用是lambda表达式的一种形式，用于根据现有方法的名称引用该方法。
类名::methodName
例子:
流。forEach(System.out.println(element))
通过使用双冒号::
顺流而下。forEach(系统。出去::println(元素)
由于这里的许多答案都很好地解释了::行为，另外，我想澄清::操作符不需要与引用函数接口具有完全相同的签名，如果它用于实例变量。让我们假设我们需要一个类型为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;
所以我在这里看到了大量的答案，坦率地说，它们过于复杂，这是一种保守的说法。
答案很简单:**::被称为方法引用。在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);
方法引用的一个很酷的优点是，在将它们分配给变量之前，它们都是无类型的。因此，您可以将它们作为参数传递给任何具有相同外观(具有相同定义类型)的函数接口。这正是你的情况。
关于::方法引用的作用，前面的回答相当完整。总而言之，它提供了一种在不执行方法(或构造函数)的情况下引用方法(或构造函数)的方法，并且在计算时，它创建了提供目标类型上下文的函数接口实例。
下面是两个示例，在使用::方法引用和不使用::方法引用的情况下查找ArrayList中具有最大值的对象。解释见下面的评论。
不使用::
import java.util.*;
class MyClass {
private int val;
MyClass (int v) { val = v; }
int getVal() { return val; }
}
class ByVal implements Comparator<MyClass> {
// no need to create this class when using method reference
public int compare(MyClass source, MyClass ref) {
return source.getVal() - ref.getVal();
}
}
public class FindMaxInCol {
public static void main(String args[]) {
ArrayList<MyClass> myClassList = new ArrayList<MyClass>();
myClassList.add(new MyClass(1));
myClassList.add(new MyClass(0));
myClassList.add(new MyClass(3));
myClassList.add(new MyClass(6));
MyClass maxValObj = Collections.max(myClassList, new ByVal());
}
}
使用::
import java.util.*;
class MyClass {
private int val;
MyClass (int v) { val = v; }
int getVal() { return val; }
}
public class FindMaxInCol {
static int compareMyClass(MyClass source, MyClass ref) {
// This static method is compatible with the compare() method defined by Comparator.
// So there's no need to explicitly implement and create an instance of Comparator like the first example.
return source.getVal() - ref.getVal();
}
public static void main(String args[]) {
ArrayList<MyClass> myClassList = new ArrayList<MyClass>();
myClassList.add(new MyClass(1));
myClassList.add(new MyClass(0));
myClassList.add(new MyClass(3));
myClassList.add(new MyClass(6));
MyClass maxValObj = Collections.max(myClassList, FindMaxInCol::compareMyClass);
}
}
