Java中的（双冒号）运算符8

Question

我在探索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;
}

math::max是否类似于方法指针？普通的静态方法如何转换为IntBinaryOperator？

Answer 1

::称为方法引用。它基本上是对单个方法的引用。即。它通过名称引用一个现有的方法。

简短说明:
下面是一个引用静态方法的示例：

class Hey {
     public static double square(double num){
        return Math.pow(num, 2);
    }
}

Function<Double, Double> square = Hey::square;
double ans = square.apply(23d);

square可以像对象引用一样四处传递，并在需要时触发。事实上，它可以像static方法一样，很容易地用作对象的“正常”方法的引用。例如：

class Hey {
    public double square(double num) {
        return Math.pow(num, 2);
    }
}

Hey hey = new Hey();
Function<Double, Double> square = hey::square;
double ans = square.apply(23d);

上面的function是一个功能接口。要充分理解::，理解功能接口也很重要。简单地说，函数接口是一个只有一个抽象方法的接口。

功能接口的示例包括runnable、callable和actionlistener。

上面的function是一个函数接口，只有一个方法:apply。它需要一个参数并产生一个结果。

::之所以令人敬畏，是因为：

方法引用是具有与lambda表达式（...）相同的处理的表达式，但它们不提供方法体，而是按名称引用现有方法。

例如。而不是写lambda体

Function<Double, Double> square = (Double x) -> x * x;

你可以简单地做

Function<Double, Double> square = Hey::square;

在运行时，这两个square方法的行为彼此完全相同。字节码可能是相同的，也可能不是相同的（不过，对于上面的情况，生成的是相同的字节码；编译上面的内容并使用javap-c进行检查）。

要满足的唯一主要标准是：您提供的方法应该具有与您用作对象引用的函数接口的方法相似的签名。

以下是非法的：

Supplier<Boolean> p = Hey::square; // illegal

square需要一个参数，并返回一个double。Supplier中的get方法返回一个值，但不接受参数。因此，这将导致一个错误。

方法引用是指函数接口的方法。（如前所述，功能接口每个只能有一个方法）。

更多的示例：Consumer中的accept方法接受输入但不返回任何内容。

Consumer<Integer> b1 = System::exit;   // void exit(int status)
Consumer<String[]> b2 = Arrays::sort;  // void sort(Object[] a)
Consumer<String> b3 = MyProgram::main; // void main(String... args)

class Hey {
    public double getRandom() {
        return Math.random();
    }
}

Callable<Double> call = hey::getRandom;
Supplier<Double> call2 = hey::getRandom;
DoubleSupplier sup = hey::getRandom;
// Supplier is functional interface that takes no argument and gives a result

在上面，getrandom不接受任何参数，并返回一个double。因此可以使用任何满足以下条件的函数接口：不带参数并返回double。

另一个例子：

Set<String> set = new HashSet<>();
set.addAll(Arrays.asList("leo","bale","hanks"));
Predicate<String> pred = set::contains;
boolean exists = pred.test("leo");

在参数化类型的情况下：

class Param<T> {
    T elem;
    public T get() {
        return elem;
    }

    public void set(T elem) {
        this.elem = elem;
    }

    public static <E> E returnSame(E elem) {
        return elem;
    }
}

Supplier<Param<Integer>> obj = Param<Integer>::new;
Param<Integer> param = obj.get();
Consumer<Integer> c = param::set;
Supplier<Integer> s = param::get;

Function<String, String> func = Param::<String>returnSame;

方法引用可以有不同的样式，但从根本上说，它们都意味着相同的东西，并且可以简单地可视化为lambdas：

1. 静态方法(classname::methname)
2. 特定对象的实例方法(InstanceRef::MethName)
3. 特定对象的超级方法(super::methname)
4. 特定类型(classname::methname)的任意对象的实例方法
5. 类构造函数引用(classname::new)
6. 数组构造函数引用(typename[]::new)

有关进一步的参考，请参见http://cr.openjdk.java.net/~briangoetz/lambda/lambda-state-final.html。

Answer 2

通常，可以使用math.max(int,int)调用reduce方法，如下所示：

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

这需要大量语法，只需调用math.max。这就是lambda表达式发挥作用的地方。自Java八号以来,允许以短得多的方式做同样的事情：

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

这是怎么工作的？Java编译器“检测”到您希望实现一个接受两个int并返回一个int的方法。这等同于接口IntBinaryOperator的one and only方法（您要调用的方法Reduce的参数）的形参。因此，编译器为您完成其余的工作--它只是假设您希望实现IntBinaryOperator。

但是由于math.max(int,int)本身满足了IntBinaryOperator的形式要求，因此可以直接使用它。因为Java 7没有任何语法允许方法本身作为参数传递（您只能传递方法结果，而不能传递方法引用），所以::语法是在Java 8中引入来引用方法的：

reduce(Math::max);

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

（另见Lambda表达式的翻译）