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 表达式的方法体内,只是调用一个已有的方法,如 ApplegetWeight() 方法,Stringlength() 方法,那么我们就可以把这类的 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. 调用 ApplegetWeight() 方法。 属于「调用特定方法」的范围
    2. 仅仅调用了该方法而没有进行任何其他操作。 属于 「直接调用这个方法」 的范围

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

     coverAppleWeight(apples, Apple::getWeight);//调用 Apple 的指定方法 getWeight 而不做操作
    
  4. 如果我们需要给苹果质量造假,比如我们需要在每个苹果现有的质量加 10 存放如集合,那么还能使用方法引用么,答案是否定的。

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

方法引用的类别

方法引用主要有三类:

  1. 引用「静态方法」 : ContainingClass::staticMethodName
  1. 引用一个特定对象的实例方法:containingObject::instanceMethodName
  1. 引用特定类型的任意对象的实例方法:ContainingType::methodName
  1. 引用构造函数: 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之后的版本) 这么强大。

    原文作者:醒着的码者
    原文地址: https://www.jianshu.com/p/511df052fc1c
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞