Item43: Prefer method references

Item43: Prefer method references to lambdas

方法引用 优于 lambda

概述

• lambda相对匿名类的优势就是简略，那么方法引用
• 有下面一个例子，这个例子实现了一个multiset(mine: multiset是指一个key对应多个value的数据结果，guava里有相应的集合可以参考)：

    // 用户指定key和incr：如果key在map中不存在对应的value，则put(key, 1)；否则将value取出后加上incr作为最终值覆盖当前值
    map.merge(key, 1, (count, incr)-> count + incr);

代码nice，但是仍然可做得更有型(boilerplate)些。

    map.merge(key, 1, Integer::sum);

mine: merge的方法在Map中是一个default方法，定义如下(但是HashMapoverride了这个方法)

    default V merge(K key, V value,BiFunction<? super V, ? super V, ?extends V> remappingFunction) {
        Objects.requireNonNull(remappingFunction);
        Objects.requireNonNull(value);
        V oldValue = get(key);
        V newValue = (oldValue == null) ? value :
                   remappingFunction.apply(oldValue, value);
        if(newValue == null) {
            remove(key);
        } else {
            put(key, newValue);
        }
        return newValue;
    }

lambda VS method reference

• method reference能做的，lambda都能做到
• 所以method reference多为了让代码更清晰简短
• 为了不让lambda看起来很长很繁琐，可以将其提取为一个方法，而在原处使用method reference；这样还有一个好处就是可以针对这个方法写文档，而lambda中写文档是很棘手的事情(有趣
• 如果IDE提示让你从lambda转换为method reference那么大多数情况下都是没毛病的。

某些情况下，lambda更精简，这会出现在：

例子一：

这个方法和lambda在同一个类中（？？）

例子二：使用Fuction.identity()静态方法不如直接用t -> t代替

mine：Fuction.identity()的作用是返回一个Function实例，这个实例执行后总是返回它自己的入参。即 t -> t例子：

    @Test
    public void testIdentity() {
        Function<String, String> identity = Function.identity();
        final String str = "hahaha";
        String applyResult = identity.apply(str);
        Assert.assertEquals(applyResult, str);
    }

method references可以指代什么样的方法？

大多数都是static method，除了以下4类

前2类(光看文字定义，不是很好懂, 后一章写出我的理解)：

有界和无界实例方法引用(bound and unbound instance method references)

• bound:

Instant.now()::isAfter  // 
// 等同于=====> 
Instant then = Instant.now();
Function<Intant, Boolean> function = t -> then.isAfter(t)

• unbound:
  当这个方法真正执行的时候，入参才会使用，unbound经常在stream中被用于mapping和filter

String::toLowerCase
// 等同于=====> 
str -> str.toLowerCase()

bound and unbound instance method references 我的理解:

google了一些相关问题，做一个总结,非最终选择的那个可能是一个比较好的显示

首先，基于上面那个map.merge()方法的例子，你认为Integer::sum所转换成的lambda表达式的函数式接口是什么呢？首先思考Integer::sum的含义：它表达了这样一个函数——两个Integer的数字作为入参，相加后得到另外一个Integer作为出参，所以，它的对应的函数式接口是？
BiFunction<Integer, Integer, Integer>

为什么呢?请看jdk中的定义：

@FunctionalInterface
public interface BiFunction<T, U, R> {

    /**
     * Applies this function to the given arguments.
     *
     * @param t the first function argument
     * @param u the second function argument
     * @return the function result
     */
    R apply(T t, U u);
}

BiFunction表示这样一个二元函数：使用T类型的t，U类型的u作为入参，返回R类型的结果。

然而，当你在IDE中输入Integer::sum，使用自动补全功能时发现这个结果不是完全正确(为什么是错的呢？稍后再写个文章想想吧。。。)
Comparator<Integer> c = Integer::sum;

1. 首先参考了下这个sf问题中的回答,先从非最终选中的那个答案看起：https://stackoverflow.com/questions/35914775/java-8-difference-between-method-reference-bound-receiver-and-unbound-receiver

后两类：

两种构造方法的引用：

• TreeMap<K, V>::new
• int[]::new

总结

如果method reference更精简、更清晰明了，那么用它替代lambda是什么意思，是需要我们反推的。
由于从lambda到method reference丢失了相关信息，一个method reference反推回lambda可能多重结果