Java8 实战学习 方法引用
有时，lambda表达式只会调用现有方法。 在这些情况下，通过名称引用现有方法往往更加清楚。 方法参考使您能够做到这一点; 对于已经有名称的方法，它们是紧凑的，易于阅读的lambda表达式。
方法引用
方法引用让你可以重复使用现有的方法定义，并像Lambda一样传递它们。
书中这么描述方法引用，但是自我感觉方法引用还是蛮难得，至少对我来说。那我们就来看下方法引用到底是什么。
方法引用的一个例子：
(Apple a) -> a.getWeight()
等价于
Apple::getWeight
什么是方法引用
方法引用在书中被称为 Lambda 的语法糖，语法糖大致意思就是一种为了简化代码书写的语法：
语法糖（Syntactic sugar），也译为糖衣语法，是由英国计算机科学家彼得·蘭丁发明的一个术语，指计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用。
什么意思呢？就是只是为了简化某种代码的写法，而定义的一个新的语法，比如我们 for 循环大多情况下可以使用 foreach 来替换，那么foreach 就是 for 循环的语法糖。而我们用 foreach的时候并没有问太多，因为学习的时候就给我们画上了等号。所以学习方法引用我们可以类比这样的写法。
Lambda 的语法糖就是为了在特定情况下简化 Lambda 书写的语法， wfc！ Lambda 看起来都费劲，还要简化，那我写出来的代码是不是就没人能懂了？ 个人经过了一天的挣扎后，还是打算拥抱这个变化，这就是一个转变的过程，思想固化后再去接受新的思想需要经历一个过程。
书中对方法引用做了下面的解释：
方法引用可以被看作仅仅 「调用特定方法」 的 Lambda 的一种快捷写法。
它的基本思想是，如果一个Lambda代表的只是“直接调用这个方法”，那最好还是用名称来调用它，而不是去描述如何调用它。
方法引用看作针对「仅仅涉及单一方法的Lambda」的语法糖。
相信大多数人看到这句话以后都有如下的疑问点：
- 「调用特定方法」的快捷写法，什么方法是特定方法？
- 「只是“直接调用这个方法”」这个方法？
如果 Lambda 表达式的方法体内，只是调用一个已有的方法，如 Apple 的 getWeight() 方法，String 的 length() 方法，那么我们就可以把这类的 Lambda 修改成方法引用的方式书写。
这里举个例子方便理解：
假如我们需要将一筐苹果的重量全部统计出来
-
我们定义一个方法用来提取指定集合中的苹果的重量：
private static List<Integer> coverAppleWeight(List<Apple> apples, CoverConsumer consumer) { List<Integer> list = new ArrayList<>(); for (Apple a : apples) { list.add(consumer.cover(a)); } return list; } -
我们需要一个函数接口来完成转换操作，这里的方法签名为
T -> R，即从一个对象中 选择/提取，我们可以使用 Java 8 提供的Function接口或者自己创建一个函数接口：public interface CoverConsumer { int cover(Apple apple); } -
使用该方法来提取苹果质量：
List<Apple> apples = new ArrayList<>(); apples.add(new Apple(10)); apples.add(new Apple(11)); apples.add(new Apple(12)); apples.add(new Apple(13)); coverAppleWeight(apples, (Apple a) -> a.getWeight());//满足 T->R 的Lambda满足 T->R 的Lambda 作为 CoverConsumer 的实例传递给 coverAppleWeight 来完成提取操作，具体操作内容就是拿到每个苹果的质量。
Lambda 的操作在这个时候仅仅
- 调用
Apple的getWeight()方法。 属于「调用特定方法」的范围 - 仅仅调用了该方法而没有进行任何其他操作。 属于 「直接调用这个方法」 的范围
因此我们可以使用方法引用来简化 Lambda ：
coverAppleWeight(apples, Apple::getWeight);//调用 Apple 的指定方法 getWeight 而不做操作 - 调用
-
如果我们需要给苹果质量造假，比如我们需要在每个苹果现有的质量加 10 存放如集合，那么还能使用方法引用么，答案是否定的。
coverAppleWeight(apples, (Apple a) -> a.getWeight() + 10);//不能简化为方法引用调用
方法引用的类别
方法引用主要有三类：
- 引用「静态方法」 ：
ContainingClass::staticMethodName
- 引用一个特定对象的实例方法：
containingObject::instanceMethodName
- 引用特定类型的任意对象的实例方法：
ContainingType::methodName
- 引用构造函数：
ClassName::new
第一种方法引用「静态方法的方法引用」：
还记得我们第一天学习的时候，比较两个苹果质量将苹果按质量从大到小排列的例子么？当时我们是这样实现的：
apples.sort(new ComparatorApple());//List.sort(Comparator<? super E> c)
// 隐藏了无关的代码，直接跳到实现
public static class ComparatorApple implements Comparator<Apple> {
@Override
public int compare(Apple a, Apple b) {
return a.getWeight().compareTo(b.getWeight());
}
}
现在我们在 Apple 类中添加一个静态方法用来比较两个苹果的重量：
class Apple {
public String name = "Apple";
private String color;
Apple(int weight) {
this.weight = weight;
}
public int weight;
public Integer getWeight() {
return weight;
}
// 用来比较重量的方法
public static int compareByWeight(Apple a,Apple b){
return a.getWeight().compareTo(b.getWeight());
}
public String getColor() {
return color;
}
}
有了这个方法 我们之前的 Lambda 表达式可以修改一下：
// 首先修改 ComparatorApple 接口
public static class ComparatorApple implements Comparator<Apple> {
@Override
public int compare(Apple a, Apple b) {
return Apple.compareByWeight(a,b);//等价于 return a.getWeight().compareTo(b.getWeight());
}
}
// 最终调用的 Lambda 可以就修改如下
apples.sort((Apple a, Apple b) -> Apple.compareByWeight(a, b));
我们知道 compareByWeight() 方法是 Apple 的静态方法，实现的功能跟 Comparator 接口要实现的功能相同，所以 Lambda 表达式的签名也是一致的。
所以我们也可以写为：ContainingClass::staticMethodName 格式。
ContainingClass 为包含这个静态方法的类名，而 :: 后则表示方法名 ，值得注意的是这里不需要参数和（）。
apples.sort(Apple::compareByWeight);
--
引用一个特定对象的方法
接着筛选苹果的例子说，apples.sort(Comparator<Apple> c) 参数是接收一个满足 Comparator 目标类型的 Lambda 表达式，这个 Lambda 表达式应该满足下面的要求：
(Apple a, Apple b) -> a.getWeight().compareTo(b.getWeight())
这时候我们恰好有一个 比较器提供者ComparisonProvider：
public static class ComparisonProvider {
public int compareByColor(Apple a, Apple b) {
return a.getColor().compareTo(b.getColor());
}
public static int compareByWeight(Apple a, Apple b) {
return a.getWeight().compareTo(b.getWeight());
}
}
它可以提供各式各样的比较方法，但是并不是一个函数式接口。我们可以将之前的代码修改为：
ComparisonProvider comparisonProvider = new ComparisonProvider();
apples.sort((Apple a, Apple b) -> {
return comparisonProvider.compareByColor(a, b);
});
在这里 comparisonProvider 就是一个「特定对象」，因为这个对象恰好有比较两个苹果的方法compareByColor，而后者就是这个特定对象的方法。此时我们可以使用方法引用的方式简化 Lambda.
ComparisonProvider comparisonProvider = new ComparisonProvider();
apples.sort(comparisonProvider::compareByColor);// 特定对象 :: 对象的方法
这里虽然没有写任何有关于 Apple 的参数，但 JRE 可以推断方法类型参数。 喲~ 不错喔。
--
特殊的类型的任意对象的实例方法引用：ContainingType::methodName
首先「实例方法」是一个类的实例的方法，而不是静态方法。
其次特定的类的任意对象 ： Lambda表达式的主体中你在引用一个对象的方法，而这个对象恰巧是该 Lambda 的参数的对象。
看下边的例子应该好理解：
// 例子1
String[] stringArray = {"Barbara", "James", "Mary", "John",
"Patricia", "Robert", "Michael", "Linda"};
Arrays.sort(stringArray, String::compareToIgnoreCase);
List<String> list = Arrays.asList(stringArray);
list.sort(String::compareToIgnoreCase);
list.sort((String s, String s1) -> s.compareToIgnoreCase(s1));
// 例子2
ArrayList<Apple> apples1 = new ArrayList<>();
apples1.add(new Apple(10));
apples1.add(new Apple(11));
apples1.add(new Apple(12));
apples1.add(new Apple(13));
apples1.sort((Apple a, Apple b) -> a.compareTo(b));
apples1.sort(Apple::compareTo);//compareTo是 Apple的一个实例方法
// Apple 中的 compareTo 方法 这里并不是 Compator 的重载方法
public int compareTo(Apple apple) {
return this.getWeight().compareTo(apple.getWeight());
}
构造参数的方法引用
现在我们可以通过 ClassName::new 来创建一个构造参数的引用。
如果一个构造函数没有参数它适合Supplier的签名() -> Apple。
```
Supplier<Apple> c1 = Apple::new; Apple a1 = c1.get();
//等价于
Supplier<Apple> c1 = () -> new Apple(); Apple a1 = c1.get();
```
如果构造函数的包含一个参数，如是Apple(Integer weight) 它就适合Function接口的签名。
Function<Integer, Apple> c2 = Apple::new; Apple a2 = c2.apply(110)
//等价于
Function<Integer, Apple> c2 = (weight) -> new Apple(weight); Apple a2 = c2.apply(110);
如果你有一个具有两个参数的构造函数Apple(String color, Integer weight) 那么就可以应用 BiFunction 接口的签名：
BiFunction<String, Integer, Apple> c3 = Apple::new;
Apple c3 = c3.apply("green", 110);
//等价于
BiFunction<String, Integer, Apple> c3 = (color, weight) -> new Apple(color, weight); Apple c3 = c3.apply("green", 110);
如果你需要更多的参数的构造函数，那么你可以自己创建这个函数式接口。
public interface TriFunction<T, U, V, R>{
R apply(T t, U u, V v);
}
TriFunction<Integer, Integer, Integer, Color> colorFactory = Color::new;
关于方法引用的总结：
方法引用是 Lambda 的语法糖，可以进一步简化 Lambda 的书写。
方法引用有四种应用场景： 1. 调用静态方法的情况，2.调用一个满足条件的类对象的实例方法（这个对象通常为局部变量） 3. 满足条件的类的任意对象的实例方法 4. 构造参数
在使用的过程中建议不要直接写出方法引用，通过先写 Lambda 表达式，然后通过编辑器转化为 方法引用的方式。毕竟 IntelliJ（2017.1之后的版本） 这么强大。
