我在研究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?
当前回答
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 |
+------------------------------------------------------------+--------------------------------------+
其他回答
所以我在这里看到了大量的答案，坦率地说，它们过于复杂，这是一种保守的说法。
答案很简单:**::被称为方法引用。在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);
方法引用的一个很酷的优点是，在将它们分配给变量之前，它们都是无类型的。因此，您可以将它们作为参数传递给任何具有相同外观(具有相同定义类型)的函数接口。这正是你的情况。
::是Java 8中包含的一个新操作符，用于引用现有类的方法。可以引用类的静态方法和非静态方法。
对于引用静态方法，语法为:
ClassName :: methodName
对于引用非静态方法，语法为
objRef :: methodName
And
ClassName :: methodName
引用方法的唯一前提是该方法存在于功能接口中，该接口必须与方法引用兼容。
计算方法引用时，将创建功能接口的实例。
这是在http://www.speakingcs.com/2014/08/method-references-in-java-8.html上找到的
是的，那是真的。操作符用于方法引用。因此，可以使用它从类中提取静态方法，也可以从对象中提取方法。相同的操作符甚至可以用于构造函数。下面的代码示例演示了这里提到的所有情况。
Oracle的官方文档可以在这里找到。
在本文中，您可以更好地概述JDK 8的更改。在方法/构造函数引用部分还提供了一个代码示例:
interface ConstructorReference {
T constructor();
}
interface MethodReference {
void anotherMethod(String input);
}
public class ConstructorClass {
String value;
public ConstructorClass() {
value = "default";
}
public static void method(String input) {
System.out.println(input);
}
public void nextMethod(String input) {
// operations
}
public static void main(String... args) {
// constructor reference
ConstructorReference reference = ConstructorClass::new;
ConstructorClass cc = reference.constructor();
// static method reference
MethodReference mr = cc::method;
// object method reference
MethodReference mr2 = cc::nextMethod;
System.out.println(cc.value);
}
}
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 |
+------------------------------------------------------------+--------------------------------------+
在旧的Java版本中，你可以使用:而不是"::"或lambd:
public interface Action {
void execute();
}
public class ActionImpl implements Action {
@Override
public void execute() {
System.out.println("execute with ActionImpl");
}
}
public static void main(String[] args) {
Action action = new Action() {
@Override
public void execute() {
System.out.println("execute with anonymous class");
}
};
action.execute();
//or
Action actionImpl = new ActionImpl();
actionImpl.execute();
}
或者传递给方法:
public static void doSomething(Action action) {
action.execute();
}
