Lambda表达式详解

1. 为什么使用lambda表达式

lambda是一个匿名函数，我们可以吧lambda表达式理解为是一段可以传递的代码。使用它可以写出更简洁，更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。

2. 入门案例

先看一个简单的Java线程中的Runnable接口案例

public void test01(){
        Runnable ri = new Runnable() {
            @Override
            public void run() {
                System.out.println("好好学习，天天向上");
            }
        };
        ri.run();
    }
1
2
3
4
5
6
7
8
9

再看下使用了Lambda表达式的版本

 public void test02(){
        Runnable r2 = ()-> System.out.println("学会lambda，快乐每一天");
        r2.run();
    }
1
2
3
4

相信看到这里，对Lambda表达式的第一印象就是代码怎么这么短，这也就是lambda表达式的特性：简洁。

再看一个案例，比较数的大小

public void test03(){
        Comparator<Integer> comparator = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        };
        int compare = comparator.compare(12, 21);
        System.out.println(compare);
    }
1
2
3
4
5
6
7
8
9
10

因为12是小于21的，所以这里返回的是-1；我们再来看看对应的lambda表达式的写法

 public void test04(){
        Comparator<Integer> comparator = (o1,o2)-> Integer.compare(o1,o2);
        int compare = comparator.compare(32,23);
        System.out.println(compare);
    }
1
2
3
4
5

因为32大于23，所以返回值为1；

3. lambda表达式组成

形如以下：

(o1,o2) -> Integer.compare(o1,o2)

左边 -> 右边

• -> 被称为lambda操作符或箭头操作符
• 左边：lambda形参列表（其实就是接口中的抽象方法的形参列表）
• 右边：lambda体 （其实就是重写的抽象方法的方法体）

4. lambda表达式使用

4.1 语法格式一

无参无返回值

public void test01(){
        Runnable ri = new Runnable() {
            @Override
            public void run() {
                System.out.println("好好学习，天天向上");
            }
        };
        ri.run();
    }
1
2
3
4
5
6
7
8
9

 public void test02(){
        Runnable r2 = ()-> {System.out.println("学会lambda，快乐每一天");}；
        r2.run();
    }
1
2
3
4

4.2 语法格式二

需要一个参数但无返回值

public void test05(){
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        consumer.accept("这一路上走走停停");
    }
1
2
3
4
5
6
7
8
9

public void test06(){
        Consumer<String> consumer = (String s)->{System.out.println(s);}；
        consumer.accept("留下少年漂流的痕迹");
    }
1
2
3
4

4.3 语法格式三

数据类型可以省略，由编译器去推断出，称为“类型推断”

public void test05(){
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        consumer.accept("这一路上走走停停");
    }
1
2
3
4
5
6
7
8
9

public void test06(){
        Consumer<String> consumer = (s)->{System.out.println(s);}；//类型推断
        consumer.accept("留下少年漂流的痕迹");
    }
1
2
3
4

这里有些类似于使用集合类是前面指明过泛型后，后边不需要再次指明

4.4 语法格式四

lambda若只需要一个参数时，参数的小括号可以省略

public void test05(){
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        consumer.accept("这一路上走走停停");
    }
1
2
3
4
5
6
7
8
9

public void test06(){
        Consumer<String> consumer = s->{System.out.println(s);}；//类型推断
        consumer.accept("留下少年漂流的痕迹");
    }
1
2
3
4

4.5 语法格式五

lambda需要两个或以上的参数，多条执行语句，并且可以有返回值

   public void test03(){
        Comparator<Integer> comparator = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                System.out.println(02);
                return Integer.compare(o1,o2);
            }
        };
        int compare = comparator.compare(12, 21);
        System.out.println(compare);
    }
1
2
3
4
5
6
7
8
9
10
11
12

public void test04(){
     Comparator<Integer> comparator = (o1,o2)-> { 
        System.out.println(o1);
        System.out.println(02);
        return Integer.compare(o1,o2);};
    int compare = comparator.compare(32,23);
    System.out.println(compare);
}
1
2
3
4
5
6
7
8

4.6 语法格式六

当lambda体只有一条语句时，return与大括号若有，都可以省略

public void test03(){
        Comparator<Integer> comparator = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        };
        int compare = comparator.compare(12, 21);
        System.out.println(compare);
    }
1
2
3
4
5
6
7
8
9
10

 public void test04(){
        Comparator<Integer> comparator = (o1,o2)-> Integer.compare(o1,o2);
        int compare = comparator.compare(32,23);
        System.out.println(compare);
    }
1
2
3
4
5

5. 总结

lambda接口的实质：作为函数式接口的实例,关键是这个匿名内部类的简化，省略。