Java中的双冒号运算符(::)：简化方法引用

双冒号运算符

在java中，双冒号::是方法引用的语法。方法引用是简化Lambda表达式的语法结构，使代码更简洁易懂，并且在使用引用方法时，会根据上下文推断参数类型，因此特别适用于直接引用已有方法的情况。

4种方法引用

1. 构造方法引用：ClassName::new
2. 静态方法引用：ClassName::staticMethod
3. 对象方法引用：ClassName::instanceMethod
4. 实例方法引用：instance::instanceMethod

引用名称	方法引用	对应lambda表达式
构造方法引用	ArrayList::new	() -> new ArrayList<>()
静态方法引用	String::valueOf	x -> String.valueOf(x)
对象方法引用	x::toString	() -> x.toString()
实例方法引用	Object::toString	x -> x.toString()

总结：实际为2类，
  * 入参为对象，引用对象本身方法（实例方法）
  * 入参随意， 引用其他类方法（构造方法、对象方法、静态方法）

实例

依次使用构造方法、对象方法、实例方法、静态方法双冒号::简化方法引用.

public class Point {
    int x;
    Point(int x) {
        this.x = x;
    }
    boolean isPositive() {
        return this.x > 0;
    }
}
public class Points {
    public boolean smallThan2(Point point){
        return point.x < 2;
    }
}

public class App {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(0, 1, 2);

        Point pt = new Point(0);
        Points pts = new Points();

        // 依次使用引用: 构造方法、对象方法、实例方法、静态方法
        numbers.stream()
                .map(Point::new)
                .filter(Point::isPositive)
                .filter(pts::smallThan2)
                .forEach(System.out::println);
        // 对应lambda表达式
        numbers.stream()
                .map(x -> new Point(x))
                .filter(point -> point.isPositive())
                .filter(point -> pts.smallThan2(point))
                .forEach(point -> System.out.println(point));
        // 对应方法
        numbers.stream()
                .map(new Function<Integer, Point>() {
                    @Override
                    public Point apply(Integer integer) {
                        return new Point(integer);
                    }
                })
                .filter(new Predicate<Point>() {
                    @Override
                    public boolean test(Point point) {
                        return point.isPositive();
                    }
                })
                .filter(new Predicate<Point>() {
                    @Override
                    public boolean test(Point point) {
                        return pts.smallThan2(point);
                    }
                })
                .forEach(new Consumer<Point>() {
                    @Override
                    public void accept(Point point) {
                        System.out.println(point);
                    }
                });
    }
}