Java8 实战学习 方法引用

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 修改成方法引用的方式书写。

这里举个例子方便理解：

假如我们需要将一筐苹果的重量全部统计出来

1. 我们定义一个方法用来提取指定集合中的苹果的重量：

    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;
       }

2. 我们需要一个函数接口来完成转换操作，这里的方法签名为 T -> R ，即从一个对象中 选择/提取，我们可以使用 Java 8 提供的 Function 接口或者自己创建一个函数接口：

    public interface CoverConsumer {
       int cover(Apple apple);
    }

3. 使用该方法来提取苹果质量：

      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 的操作在这个时候仅仅

   1. 调用 Apple 的 getWeight() 方法。 属于「调用特定方法」的范围
   2. 仅仅调用了该方法而没有进行任何其他操作。 属于 「直接调用这个方法」 的范围

   因此我们可以使用方法引用来简化 Lambda ：

    coverAppleWeight(apples, Apple::getWeight);//调用 Apple 的指定方法 getWeight 而不做操作

4. 如果我们需要给苹果质量造假，比如我们需要在每个苹果现有的质量加 10 存放如集合，那么还能使用方法引用么，答案是否定的。

   coverAppleWeight(apples, (Apple a) -> a.getWeight() + 10);//不能简化为方法引用调用

方法引用的类别

方法引用主要有三类：

1. 引用「静态方法」 ： ContainingClass::staticMethodName

2. 引用一个特定对象的实例方法：containingObject::instanceMethodName

3. 引用特定类型的任意对象的实例方法：ContainingType::methodName

4. 引用构造函数： 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

1. 首先「实例方法」是一个类的实例的方法，而不是静态方法。

2. 其次特定的类的任意对象 ： 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;

---

关于方法引用的总结：

1. 方法引用是 Lambda 的语法糖，可以进一步简化 Lambda 的书写。

2. 方法引用有四种应用场景： 1. 调用静态方法的情况，2.调用一个满足条件的类对象的实例方法（这个对象通常为局部变量） 3. 满足条件的类的任意对象的实例方法 4. 构造参数

3. 在使用的过程中建议不要直接写出方法引用，通过先写 Lambda 表达式，然后通过编辑器转化为 方法引用的方式。毕竟 IntelliJ（2017.1之后的版本） 这么强大。