Lambda表达式

lambda 表达式是在Java8 中引入的。lambda表达式是一个可以传递的代码块，可以在以后执行一次或者多次。
简洁语法，函数式编程（Java中以对象为基础，如果想要传递一个代码块x，需要在传递的对象中的包含某种方法中囊括这些代码块，解决此问题）避免匿名内部类定义过多，简化代码。

lambda表达式形式

表达式形式: （参数），箭头(->),表达式

exp:

Comparator<String> comparator = (String s1, String s2 )->{
            if (s1.length() > s2.length()) {
                return 1;
            } else if (s1.length() == s2.length()) {
                return 0;
            } else {
                return -1;
            }
        };
1
2
3
4
5
6
7
8
9

• 如果lambda没有参数, 其中的 **()**不能省略

Runnable abc = () -> {
            System.out.println("abc");
        };
1
2
3

• 如果lambda表达式的参数类型可以由编译器推导出，可以忽略参数类型定义。

Comparator<String> comparator = (s1, s2)->{
            if (s1.length() > s2.length()) {
                return 1;
            } else if (s1.length() == s2.length()) {
                return 0;
            } else {
                return -1;
            }
        };

1
2
3
4
5
6
7
8
9
10

• 如果方法只有一个参数，而且这个参数的类型可以推导，还可以省略小括号。

ActionListener listener = event ->{
            System.out.println("Hello");
        };
1
2
3

• 如果方法只有一条语句，{}也可以省略

ActionListener listener = event -> System.out.println("Hello");
1

无需指定lambda表达式的返回类型，lambda表达式的返回类型由上下文推导得出。
如果lambda表达式只在某些条件分支有返回值，是不合法的，也即由上下文推导出的返回值类型必须一致。

• 错误例子如下:

Comparator<String> comparator = (s1, s2 )->{
            if (s1.length() > s2.length()) {
                return 1;
            } else if (s1.length() == s2.length()) {
                return 0;
            }
        };
1
2
3
4
5
6
7

• 使用lambda表达式:

import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.Comparator;
import javax.swing.JOptionPane;
import javax.swing.Timer;

public class LambdaTest {

    public static void main(String[] args) {
        String [] plants = new String[]{
            "Andy","Jacob", "xiaoHong" ,"Bob", "Cindy", "Lucy", "David"
        };
        // 打印原字符串数组
        System.out.println(Arrays.toString(plants));
        System.out.println("字典排序:");
        // 字段排序
        Arrays.sort(plants);
        System.out.println(Arrays.toString(plants));
        // 长度排序
        // Arrays.sort(plants, (first, second) -> first.length() - second.length());
        Arrays.sort(plants, Comparator.comparingInt(String::length));
        System.out.println("长度排序:");
        System.out.println(Arrays.toString(plants));

        Timer timer = new Timer(1000, event ->
            System.out.println("The time is " + LocalDateTime.now())
         );
        timer.start();

        JOptionPane.showMessageDialog(null, "是否退出程序?");
        System.exit(0);
    }
}

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
29
30
31
32
33
34

函数式接口

函数式接口:只有一个抽象方法的接口

为什么函数式接口必须有一个接口？
在Java 8 中，可以在接口中定义默认方法，而这种方式不是抽象的或者接口重新声明Object(万物始祖)中的方法，这些方法都不在是抽象方法。

常用函数式接口:

基本类型的函数式接口:
注:其中p,q为 int,long,double;P,Q为Int,Long,Double

标记注解@FunctionalInterface 用来标记接口为函数式接口，如果增加了一个非抽象方法，编译器会产生一个错误提示，另外javadoc页里也会指出这个接口为函数式接口。

方法引用

使用 :: 操作符分割方法名与对象或类名,使用方法如下:

object::instanceMethod
Class::staticMethod
Class::instanceMethod
前两种情况中，方法引用等价于提供方法参数的lambda表达式，System.out.println 等价于 x ->System.out.println(x)
第三种情况，第一个参数Class会成为方法的目标，如: String::compareToIgnoreCase 等价于 （x. y）-> x.compareToIgnoreCase(y)

如果有多个同名的重载方法，编译器就会尝试从上下文中找出你指定的那个一个方法

如:

Arrays.sort(plants, Comparator.comparingInt(String::length));
1

也可以在方法引用中使用this，例如: this.equlas 等价于 x -> this.equals(x);使用this作为目标，会调用给定方法的超类版本。

在方法引用中还可以使用super,形式如下:

super::instanceMethod

例子如下:

import java.awt.event.ActionEvent;
import javax.swing.Timer;

public class Greeter {
    public void greet(ActionEvent actionEvent){
        System.out.println("Hello world!");
    }

    class TimedGreeter extends Greeter{
        @Override
        public void greet(ActionEvent actionEvent){
            Timer timer = new Timer(1000, super::greet);
            timer.start();
        }
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

构造器引用

构造器引用与方法引用类似，只不过方法名为new。例如： Person::new 是Person的构造器的一个引用，具体使用对象的哪个构造器由上下文决定，例如包含一个name的Person构造器如下:

ArrayList<String> names = ...;
Stream<Person> stream = names.stream.map(Person::new);
1
2

对于构造器引用，无法构造泛型T的数组。

闭包

lambda表达式中可以访问外围方法或类中的变量，但是lambda捕获的变量必须实际上是最终变量，即变量初始化之后就不会在为它赋新值。

import java.awt.Toolkit;
import java.awt.event.ActionListener;
import javax.swing.Timer;

public class Test {

    public static void repeatMessage(String text, int delay){
        ActionListener listener = event -> {
            // 使用了参数text，text为String，使用final修饰，不可变更
            System.out.println(text);
            Toolkit.getDefaultToolkit().beep();
        };
        new Timer(delay, listener).start();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15