Java Lambda 解析和使用技巧

lambda 是包着一个函数的对象

lambda 表达式非常简洁优雅。是把动态语言的特性嫁接到静态语言的一个典范。

在 java 中，我更加愿意认为 lambda 实际上是是包着一个函数的对象，我们在使用 lambda 表达式的时候，实际上定义了一个闭包的函数对象，这是 lambda 最大的意义所在。在过去，我们在函数之间传递一个函数，必须手动把它包装成类的对象，并用接口加以规范。现在，我们可以直接用 lambda 自动生成一个这样的对象。

如果你用过 Javascript/Python，你可以把刚刚定义的函数当做对象传给别的函数。现在，你用 lambda 也可以在 java 的里面传参时把函数用 lambda 形式“打包”传给别的函数，并且符合强类型的面向对象要求。

我们先用面向对象的方法理解 lambda 函数，他首先是一个对象，但是不需要我们手动 new，他的类型是 一个接口

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

// 这是 Runnable 接口

publicinterfaceRunnable {

voidrun();

}

// 在以前，我们可能要这样创建一个 Runnable 对象（当然也可以用匿名内部类）

classtaskClassimplementsRunnable {

@Override

publicvoidrun(){

        System.out.println("test");

    }

}

Runnable task = new taskClass();

// 对象可以使用接口的方法

task.run(); // 输出 test

// 现在，有了 lambda，系统用了些黑魔法，自动实例化了类，并且给我们创建好了对象

// 其实，这个task不是内部类而真的是一个私有的函数，是的，编译器就是可以为所欲为

Runnable task = () -> {

    System.out.println("test");

};

// 你可以表面地理解成，系统把 小括号 和 大括号的内容，复制粘贴到上面去了

看到这里，你可能会问，系统依据什么来创建这个函数对象呢？如果一个接口里面有许多方法，我们的 lambda 表达式应该应用到（复制、粘贴到）哪个方法上面呢？lambda 的输出类型怎么定义呢？

答案就是，这种接口，有且只能有一个抽象方法，系统会自动找到这一个方法（虽然这样看起来有些随意）作为创建这个函数对象的模板。

lambda 传参数和返回值

和 Runnable 接口一样，JDK 还给我们带来了几个比较常见的接口：如 Consumer 接口 和 Supplier 接口

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

// 这个接口的特点是，有一个参数，无返回值

publicinterfaceConsumer<T> {

voidaccept(T t);

}

// 用 lambda创建一个 consumer 对象

Consumer<String> consumer = (String item) -> {

    System.out.println(item);

};

// 这个接口的特点是,无参数，有返回值

publicinterfaceSupplier<T> {

T get();

}

// 用 lambda 创建一个 supplier 对象

Supplier<String> supplier = () -> {

return"test";

}

java.util.function 下有大量 JDK8 带来的接口

• Predicate<T> – a boolean-valued property of an object | 输入 T，返回 boolean
  
• Consumer<T> – an action to be performed on an object | 输入 T，返回 void
  
• Function<T,R> – a function transforming a T to a R | 输入 T 返回 R
  
• Supplier<T> – provide an instance of a T (such as a factory) | 输入() 返回 T
  
• UnaryOperator<T> – a function from T to T | 输入 T 返回 T
  
• BinaryOperator<T> – a function from (T, T) to T | 输入 (T,T) 返回 T
  
• IntSupplier 等基础数值非泛型接口
  

我们在使用的时候，只用关心接口下面的唯一抽象方法的输入值和返回值即可，不用太关心名字

lambda 的语法糖

1. 如果函数体只有一行，不需要大括号
   
2. 如果函数的参数只有一个，不需要小括号
   
3. 如果函数的参数可以由上下文推导，则不需要写参数类型
   
4. 如果函数体只有一行，不用写 return
   

这四个比较好理解，比如，这样写是合法的：

1

2

Consumer<String> consumer = item -> System.out.println(item);

Supplier<String> supplier = () -> "test";

5. 还有我个人感觉做的比较随意的 双冒号 :: 语法糖，这种形式叫做方法引用（method references）

比如，原来我们这么写

1

Consumer<String> consumer = item -> System.out.println(item);

现在用双冒号语法可以这么写，这样写也有好处，让你看起来这更像是传了一个方法进去

1

Consumer<String> consumer = System.out::println;

lambda 局部变量使用机制

lambda 中使用上下文定义的局部变量，必须是 final 的，当然，如果你忘了加 final，编译器会帮你自动加上。

当然，如果是类变量则没有这个限制

1

2

3

4

String x = "Hello "; // 如果下文有 lambda 使用了 x，这句等价于 final String x = "Hello "

x = "test"; // 这句非法，无法通过编译

Function<String,String> func1 = y -> y+x;

System.out.println(func1.apply("luan.ma"));

lambda 底层实现

Lambda 表达式通过 invokedynamic 指令实现，书写 Lambda 表达式不会产生新的类。他在 class 文件中是一个私有函数

1

2

3

4

5

6

7

publicclassMainLambda {

publicstaticvoidmain(String[] args){

new Thread(

				() -> System.out.println("Lambda Thread run()")

			).start();;

	}

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

// javap -c -p MainLambda.class

publicclassMainLambda {

  ...

publicstaticvoidmain(java.lang.String[]);

    Code:

       0: new           #2                  // class java/lang/Thread

3: dup

       4: invokedynamic #3,  0              // InvokeDynamic #0:run:()Ljava/lang/Runnable; /*使用invokedynamic指令调用*/

       9: invokespecial #4                  // Method java/lang/Thread."<init>":(Ljava/lang/Runnable;)V

      12: invokevirtual #5                  // Method java/lang/Thread.start:()V

15: return

privatestaticvoid lambda$main$0();  /*Lambda表达式被封装成主类的私有方法*/

    Code:

       0: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;

       3: ldc           #7                  // String Lambda Thread run()

       5: invokevirtual #8                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V

8: return

}

所以，在使用层面，lambda 中的 this 就是主类的 this，和主类的函数没有太大区别。而匿名内部类或者是内部类在使用中则要注意 this 的指向问题。

JDK 数据结构中使用 lambda

JDK 中的数据结构

加入的 支持 lambda 的方法列表：

Collection: stream()方法

这是最强大的支持 lambda 的方法，List 所有 lambda 方法在 stream()中都可以完成，而且支持 set 和 queue

他还有一个可以自动多线程拆分、执行的兄弟 .parallelStream()

Tips: 上下限通配查看方法

看之前，我先说一下方法里面各种上下限通配的查看方法：

<? extends T>用于方法返回，参数类型上界是 T，因此子类不能随意传入，只读

<? super T> 用于方法传入，参数的类型下界是 T，因此若传出只能是 Object 类型

<T> 既要传入，又要返回

? 既不能传入，也不能返回

list: forEach()方法：void forEach(Consumer<? super E> action)

作用是对容器中的每个元素执行 action 指定的动作，其中 Consumer 是个函数接口，里面只有一个待实现方法 void accept(T t)

1

2

3

4

5

ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too"));

list.forEach( str -> {

if(str.length()>3)

            System.out.println(str);

    });

遍历，并对每一项执行一个函数。forEach 方法和原来的 for()遍历，看起来更加简洁

list: removeIf()方法 boolean removeIf(Predicate<? super E> filter)

删除容器中所有满足 filter 指定条件的元素，其中 Predicate 是一个函数接口，里面只有一个待实现方法 boolean test(T t)。传统，我们需要要迭代器来迭代删除数据，现在有了 removeIf 函数，我们可以传入一个 返回值 为 true 或者 false d lambda 表达式，如果 true，那么元素就会被删除

1

list.removeIf(str -> str.length()>3);

list: replaceAll()方法 void replaceAll(UnaryOperator operator)

对数据集合的每个数据执行一个方法。在之前，我们需要遍历，get 出来，转换，再 set 回去，现在我们可以直接用 lambda 实现

1

2

3

4

5

list.replaceAll(str -> {

if(str.length()>3)

return str.toUpperCase();

return str;

});

list: sort()方法 void sort(Comparator<? super E> c)

排序方法，输入两个对象，返回一个 int 值，根据正负来确定排序位置

1

list.sort((str1, str2) -> str1.length()-str2.length());

map: forEach()方法 void forEach(BiConsumer<? super K,? super V> action)

作用是对 Map 中的每个映射执行 action 指定的操作，其中 BiConsumer 是一个函数接口，里面有一个待实现方法 void accept(T t, U u)。

原来的方法非常繁琐，现在变得非常简单

1

map.forEach((k, v) -> System.out.println(k + "=" + v));

map: replaceAll()方法 replaceAll(BiFunction<? super K,? super V,? extends V> function)

作用是对Map中的每个映射执行function指定的操作，并用function的执行结果替换原来的value，其中BiFunction是一个函数接口，里面有一个待实现方法R apply(T t, U u)

1

map.replaceAll((k, v) -> v.toUpperCase());

map: merge()方法 merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)

1. 如果Map中key对应的映射不存在或者为null，则将value（不能是null）关联到key上；
   
2. 否则执行remappingFunction，如果执行结果非null则用该结果跟key关联，否则在Map中删除key的映射．
   

传入的是 key, value，以及一个备选方案：有两个值要如何处理

1

map.merge(key, newMsg, (v1, v2) -> v1+v2);

map: compute() 方法 compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)

把remappingFunction的计算结果关联到key上，如果计算结果为null，则在Map中删除key的映射．

传入 key， value 由旧值的函数计算得到

要实现上述merge()方法中错误信息拼接的例子，使用compute()代码如下：

1

map.compute(key, (k,v) -> v==null ? newMsg : v.concat(newMsg));

map: computeIfAbsent()方法 V computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)

只有在当前Map中不存在key值的映射或映射值为null时，才调用mappingFunction，并在mappingFunction执行结果非null时，将结果跟key关联．

不存在才加，存在直接跳过

Function是一个函数接口，里面有一个待实现方法R apply(T t)．

computeIfAbsent()常用来对Map的某个key值建立初始化映射．比如我们要实现一个多值映射，Map的定义可能是Map<K,Set<V>>，要向Map中放入新值，可通过如下代码实现：

1

2

3

4

5

6

7

8

9

10

11

Map<Integer, Set<String>> map = new HashMap<>();

// Java7及以前的实现方式

if(map.containsKey(1)){

    map.get(1).add("one");

}else{

    Set<String> valueSet = new HashSet<String>();

    valueSet.add("one");

    map.put(1, valueSet);

}

// Java8的实现方式

map.computeIfAbsent(1, v -> new HashSet<String>()).add("yi");

使用computeIfAbsent()将条件判断和添加操作合二为一，使代码更加简洁．

map: computeIfPresent()方法 V computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)

只有在当前Map中存在key值的映射且非null时，才调用remappingFunction，如果remappingFunction执行结果为null，则删除key的映射，否则使用该结果替换key原来的映射．

不存在直接跳过，存在才插进去

这个函数的功能跟如下代码是等效的：

1

2

3

4

5

6

7

8

9

10

11

// Java7及以前跟computeIfPresent()等效的代码

if (map.get(key) != null) {

    V oldValue = map.get(key);

    V newValue = remappingFunction.apply(key, oldValue);

if (newValue != null)

        map.put(key, newValue);

else

        map.remove(key);

return newValue;

}

returnnull;