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 接口
public interface Runnable {
void run();
}



// 在以前,我们可能要这样创建一个 Runnable 对象(当然也可以用匿名内部类)
class taskClass implements Runnable {

@Override
public void run() {
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
// 这个接口的特点是,有一个参数,无返回值
public interface Consumer<T> {
void accept(T t);
}

// 用 lambda创建一个 consumer 对象
Consumer<String> consumer = (String item) -> {
System.out.println(item);
};

// 这个接口的特点是,无参数,有返回值
public interface Supplier<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";

  1. 还有我个人感觉做的比较随意的 双冒号 :: 语法糖,这种形式叫做方法引用(method references
引用静态方法Integer::sum
引用某个对象的方法list::add
引用某个类的方法String::length
引用构造方法HashMap::new

比如,原来我们这么写

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
public class MainLambda {
public static void main(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
public class MainLambda {
...
public static void main(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

private static void 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中的数据结构

image.png | left | 747x309

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

接口名Java8新加入的方法
CollectionremoveIf() spliterator() stream() parallelStream() forEach()
ListreplaceAll() sort()
MapgetOrDefault() forEach() replaceAll() putIfAbsent() remove() replace() computeIfAbsent() computeIfPresent() compute() merge()

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(UnaryOperatoroperator)

对数据集合的每个数据执行一个方法。在之前,我们需要遍历,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. 如果Mapkey对应的映射不存在或者为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;
}
return null;

参考资料

深入理解Java函数式编程和Streams API