金山老师的笔记25 深入浅出Java 8 Lambda表达式
1、初识 Lambda
Lambda 表达式描述了一个代码块（或者叫匿名方法），可以将其作为参数传递给构造方法或者普通方法以便后续执行。考虑下面这段代码：
() -> System.out.println("金山老师")来从左到右解释一下，() 为 Lambda 表达式的参数列表（本例中没有参数），-> 标识这串代码为 Lambda 表达式（也就是说，看到 -> 就知道这是 Lambda），System.out.println("金山老师") 为要执行的代码，即将“金山老师”打印到标准输出流。
有点 Java 基础的同学应该不会对 Runnable 接口感到陌生，这是多线程的一个基础接口，它的定义如下：
@FunctionalInterface
public interface Runnable
{
public abstract void run();
}Runnable 接口非常简单，仅有一个抽象方法 run()；细心的同学会发现一个陌生的注解 @FunctionalInterface，这个注解是什么意思呢？
我看了它的源码，里面有这样一段注释：
Note that instances of functional interfaces can be created with lambda expressions, method references, or constructor references.
大致的意思就是说，通过 @FunctionalInterface 标记的接口可以通过 Lambda 表达式创建实例。具体怎么表现呢？
原来我们创建一个线程并启动它是这样的：
public class LamadaTest {
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("金山老师");
}
}).start();
}
}通过 Lambda 表达式呢？只需要下面这样：
public class LamadaTest {
public static void main(String[] args) {
new Thread(() -> System.out.println("金山老师")).start();
}
}是不是很妙！比起匿名内部类，Lambda 表达式不仅易于理解，更大大简化了必须编写的代码数量。
2、Lambda 语法
每个 Lambda 表达式都遵循以下法则：
( parameter-list ) -> { expression-or-statements }() 中的 parameter-list 是以逗号分隔的参数。你可以指定参数的类型，也可以不指定（编译器会根据上下文进行推断）。Java 11 后，还可以使用 var 关键字作为参数类型，有点 JavaScript 的味道。
-> 相当于 Lambda 的标识符，就好像见到圣旨就见到了皇上。
{} 中的 expression-or-statements 为 Lambda 的主体，可以是一行语句，也可以多行。
可以通过 Lambda 表达式干很多事情，比如说
1）为变量赋值，示例如下：
Runnable r = () -> { System.out.println("金山老师"); };
r.run();2）作为 return 结果，示例如下：
static FileFilter getFilter(String ext)
{
return (pathname) -> pathname.toString().endsWith(ext);
}3）作为数组元素，示例如下：
final PathMatcher matchers[] =
{
(path) -> path.toString().endsWith("txt"),
(path) -> path.toString().endsWith("java")
};4）作为普通方法或者构造方法的参数，示例如下：
new Thread(() -> System.out.println("金山老师")).start();需要注意 Lambda 表达式的作用域范围。
public static void main(String[] args) {
int limit = 10;
Runnable r = () -> {
int limit = 5;
for (int i = 0; i < limit; i++)
System.out.println(i);
};
}上面这段代码在编译的时候会提示错误：变量 limit 已经定义过了。
和匿名内部类一样，不要在 Lambda 表达式主体内对方法内的局部变量进行修改，否则编译也不会通过：Lambda 表达式中使用的变量必须是 final 的。
这个问题发生的原因是因为 Java 规范中是这样规定的：
Any local variable, formal parameter, or exception parameter used but not declared in a lambda expression must either be declared final or be effectively final (§4.12.4), or a compile-time error occurs where the use is attempted.
大致的意思就是说，Lambda 表达式中要用到的，但又未在 Lambda 表达式中声明的变量，必须声明为 final 或者是 effectively final，否则就会出现编译错误。
关于 final 和 effectively final 的区别，可能有些小伙伴不太清楚，这里多说两句。
final int a;
a = 1;
// a = 2;
// 由于 a 是 final 的，所以不能被重新赋值
int b;
b = 1;
// b 此后再未更改
// b 就是 effectively final
int c;
c = 1;
// c 先被赋值为 1，随后又被重新赋值为 2
c = 2;
// c 就不是 effectively final明白了 final 和 effectively final 的区别后，我们了解到，如果把 limit 定义为 final，那就无法在 Lambda 表达式中修改变量的值。那有什么好的解决办法呢？既能让编译器不发出警告，又能修改变量的值。
思前想后，试来试去，我终于找到了 3 个可行的解决方案：
1）把 limit 变量声明为 static。
2）把 limit 变量声明为 AtomicInteger。
3）使用数组。
下面我们来详细地一一介绍下。
2.1、把 limit 变量声明为 static
要想把 limit 变量声明为 static，就必须将 limit 变量放在 main() 方法外部，因为 main() 方法本身是 static 的。完整的代码示例如下所示。
public class ModifyVariable2StaticInsideLambda {
static int limit = 10;
public static void main(String[] args) {
Runnable r = () -> {
limit = 5;
for (int i = 0; i < limit; i++) {
System.out.println(i);
}
};
new Thread(r).start();
}
}来看一下程序输出的结果：
0
1
2
3
4OK，该方案是可行的。
2.2 把 limit 变量声明为 AtomicInteger
AtomicInteger 可以确保 int 值的修改是原子性的，可以使用 set() 方法设置一个新的 int 值，get() 方法获取当前的 int 值。
public class ModifyVariable2AtomicInsideLambda {
public static void main(String[] args) {
final AtomicInteger limit = new AtomicInteger(10);
Runnable r = () -> {
limit.set(5);
for (int i = 0; i < limit.get(); i++) {
System.out.println(i);
}
};
new Thread(r).start();
}
}来看一下程序输出的结果：
0
1
2
3
4OK，该方案也是可行的。
2.3 使用数组
使用数组的方式略带一些欺骗的性质，在声明数组的时候设置为 final，但更改 int 的值时却修改的是数组的一个元素。
public class ModifyVariable2ArrayInsideLambda {
public static void main(String[] args) {
final int [] limits = {10};
Runnable r = () -> {
limits[0] = 5;
for (int i = 0; i < limits[0]; i++) {
System.out.println(i);
}
};
new Thread(r).start();
}
}来看一下程序输出的结果：
0
1
2
3
4OK，该方案也是可行的。
3、六种语法格式
语法格式一：无参，无返回值
Runnable r1 = () -> {System.out.println("hello lambda!");};语法格式二：Lambda需要一个参数，但是没有返回值
Consumer<String> con = (String str) -> {System.out.println(str);};
// 例如
List<Integer> list = Arrays.asList(100, 200, 300, 400);
list.stream().forEach(
(Integer item) -> { System.out.println(item); }
);语法格式三：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”
Consumer<String> con = (str) -> {System.out.println(str);};
// 例如
List<Integer> list = Arrays.asList(100, 200, 300, 400);
list.stream().forEach(
(item) -> { System.out.println(item); }
);语法格式四：Lambda若只需要一个参数时，参数的小括号可以省略
Consumer<String> con = str -> {System.out.println(str);};
// 例如
List<Integer> list = Arrays.asList(100, 200, 300, 400);
list.stream().forEach(
item -> { System.out.println(item); }
);语法格式五：Lambda若只需要两个或以上的参数，多条执行语句，并且可以有返回值
Consumer<Integer> con = (x,y) -> {
System.out.println("实现函数式接口方法!");
return Integer.compare(x,y);
};
// 例如
List<Integer> list = Arrays.asList(30, 900, 20, 100);
// 没有使用 Lambda可以使用匿名内部类 实现排序规则,代码比较长
Collections.sort(list, new Comparator<Integer>() {
@Override
public int compare(Integer num1, Integer num2) {
return num1.compareTo(num2);
}
});
// 方法排序需要一个比较接口 可以换成Lambda表达式
Collections.sort(list, (Integer num1, Integer num2) -> {
return num1.compareTo(num2);
});
// 排序之后的结果
list.forEach(System.out::println);语法格式六：当Lambda体只有一条语句时，return与大括号若有，都可以省略
Consumer<Integer> con = (x,y) -> Integer.compare(x,y);
// 例如 定义一个集合 后面进行排序输出
List<Integer> list = Arrays.asList(30, 900, 20, 100);
Collections.sort(list, new Comparator<Integer>() {
@Override
public int compare(Integer num1, Integer num2) {
return num1.compareTo(num2);
}
});
// 方法排序需要一个比较接口 Lambda若只需要两个或以上的参数，多条执行语句，并且可以有返回值
//Collections.sort(list, (Integer num1, Integer num2) -> {
//
// return num1.compareTo(num2);
//});
// 方法排序需要一个比较接口 简化类型声明Lambda若只需要一个参数时，参数的小括号可以省略
//Collections.sort(list, (num1, num2) -> {
// return num1.compareTo(num2);
//});
// 方法排序需要一个比较接口 当Lambda体只有一条语句时，return与大括号若有，都可以省略
Collections.sort(list,
(num1, num2) -> num1.compareTo(num2)
);
// 排序之后的结果
list.forEach(System.out::println);总结六种情况： 左边：lambda形参列表的参数类型可以省略（类型推断）；如果lambda形参列表只有一个参数，其一对()也可以省略 右边：lambda体应该使用一对{}包裹；如果lambda体只有一条执行语句（可能是return语句，省略这对{}和return关键字）
4、Lambda 和 this 关键字
Lambda 表达式并不会引入新的作用域，这一点和匿名内部类是不同的。也就是说，Lambda 表达式主体内使用的 this 关键字和其所在的类实例相同。
来看下面这个示例。
public class LamadaTest {
public static void main(String[] args) {
new LamadaTest().work();
}
public void work() {
System.out.printf("this = %s%n", this);
Runnable r = new Runnable()
{
@Override
public void run()
{
System.out.printf("this = %s%n", this);
}
};
new Thread(r).start();
new Thread(() -> System.out.printf("this = %s%n", this)).start();
}
}Tips：%s 代表当前位置输出字符串，%n 代表换行符，也可以使用 \n 代替，但 %n 是跨平台的。
work() 方法中的代码可以分为 3 个部分：
1）单独的 this 关键字
System.out.printf("this = %s%n", this);其中 this 为 main() 方法中通过 new 关键字创建的 LamadaTest 对象——new LamadaTest()。
2）匿名内部类中的 this 关键字
Runnable r = new Runnable()
{
@Override
public void run()
{
System.out.printf("this = %s%n", this);
}
};其中 this 为 work() 方法中通过 new 关键字创建的 Runnable 对象——new Runnable(){...}。
3）Lambda 表达式中的 this 关键字
其中 this 关键字和 1）中的相同。
我们来看一下程序的输出结果：
this = org.jshand.java_demo.journal.LamadaTest@3feba861
this = org.jshand.java_demo.journal.LamadaTest$1@64f033cb
this = org.jshand.java_demo.journal.LamadaTest@3feba861符合我们分析的预期。
5、关于Lambda
尽管 Lambda 表达式在简化 Java 编程方面做了很多令人惊讶的努力，但在某些情况下，不当的使用仍然会导致不必要的混乱，大家伙慎用。
6、方法引用
6.1 体验方法引用
方法引用的出现原因
在使用Lambda表达式的时候，我们实际上传递进去的代码就是一种解决方案：拿参数做操作
那么考虑一种情况：如果我们在Lambda中所指定的操作方案，已经有地方存在相同方案，那是否还有必要再写重复逻辑呢？答案肯定是没有必要
那我们又是如何使用已经存在的方案的呢？
这就是我们要讲解的方法引用，我们是通过方法引用来使用已经存在的方案
代码演示
javapublic interface Printable { void printString(String s); } public class PrintableDemo { public static void main(String[] args) { //在主方法中调用usePrintable方法 // usePrintable((String s) -> { // System.out.println(s); // }); //Lambda简化写法 usePrintable(s -> System.out.println(s)); //方法引用 usePrintable(System.out::println); } private static void usePrintable(Printable p) { p.printString("好好学习"); } }
6.2 方法引用符
方法引用符
:: 该符号为引用运算符，而它所在的表达式被称为方法引用
推导与省略
- 如果使用Lambda，那么根据“可推导就是可省略”的原则，无需指定参数类型，也无需指定的重载形式，它们都将被自动推导
- 如果使用方法引用，也是同样可以根据上下文进行推导
- 方法引用是Lambda的孪生兄弟
6.3 引用类方法
引用类方法，其实就是引用类的静态方法
格式
类名::静态方法
范例
Integer::parseInt
Integer类的方法：public static int parseInt(String s) 将此String转换为int类型数据
练习描述
- 定义一个接口(Converter)，里面定义一个抽象方法 int convert(String s);
- 定义一个测试类(ConverterDemo)，在测试类中提供两个方法
- 一个方法是：useConverter(Converter c)
- 一个方法是主方法，在主方法中调用useConverter方法
代码演示
javapublic interface Converter { int convert(String s); } public class ConverterDemo { public static void main(String[] args) { //Lambda写法 useConverter(s -> Integer.parseInt(s)); //引用类方法 useConverter(Integer::parseInt); } private static void useConverter(Converter c) { int number = c.convert("666"); System.out.println(number); } }使用说明
Lambda表达式被类方法替代的时候，它的形式参数全部传递给静态方法作为参数
6.4 引用对象的实例方法
引用对象的实例方法，其实就引用类中的成员方法
格式
对象::成员方法
范例
"HelloWorld"::toUpperCase
String类中的方法：public String toUpperCase() 将此String所有字符转换为大写
练习描述
定义一个类(PrintString)，里面定义一个方法
public void printUpper(String s)：把字符串参数变成大写的数据，然后在控制台输出
定义一个接口(Printer)，里面定义一个抽象方法
void printUpperCase(String s)
定义一个测试类(PrinterDemo)，在测试类中提供两个方法
- 一个方法是：usePrinter(Printer p)
- 一个方法是主方法，在主方法中调用usePrinter方法
代码演示
javapublic class PrintString { //把字符串参数变成大写的数据，然后在控制台输出 public void printUpper(String s) { String result = s.toUpperCase(); System.out.println(result); } } public interface Printer { void printUpperCase(String s); } public class PrinterDemo { public static void main(String[] args) { //Lambda简化写法 usePrinter(s -> System.out.println(s.toUpperCase())); //引用对象的实例方法 PrintString ps = new PrintString(); usePrinter(ps::printUpper); } private static void usePrinter(Printer p) { p.printUpperCase("HelloWorld"); } }使用说明
Lambda表达式被对象的实例方法替代的时候，它的形式参数全部传递给该方法作为参数
6.5 引用类的实例方法
引用类的实例方法，其实就是引用类中的成员方法
格式
类名::成员方法
范例
String::substring
public String substring(int beginIndex,int endIndex)
从beginIndex开始到endIndex结束，截取字符串。返回一个子串，子串的长度为endIndex-beginIndex
练习描述
定义一个接口(MyString)，里面定义一个抽象方法：
String mySubString(String s,int x,int y);
定义一个测试类(MyStringDemo)，在测试类中提供两个方法
- 一个方法是：useMyString(MyString my)
- 一个方法是主方法，在主方法中调用useMyString方法
代码演示
javapublic interface MyString { String mySubString(String s,int x,int y); } public class MyStringDemo { public static void main(String[] args) { //Lambda简化写法 useMyString((s,x,y) -> s.substring(x,y)); //引用类的实例方法 useMyString(String::substring); } private static void useMyString(MyString my) { String s = my.mySubString("HelloWorld", 2, 5); System.out.println(s); } }使用说明
Lambda表达式被类的实例方法替代的时候 第一个参数作为调用者 后面的参数全部传递给该方法作为参数
6.6 引用构造器
引用构造器，其实就是引用构造方法
格式
类名::new
范例
Student::new
练习描述
定义一个类(Student)，里面有两个成员变量(name,age)
并提供无参构造方法和带参构造方法，以及成员变量对应的get和set方法
定义一个接口(StudentBuilder)，里面定义一个抽象方法
Student build(String name,int age);
定义一个测试类(StudentDemo)，在测试类中提供两个方法
- 一个方法是：useStudentBuilder(StudentBuilder s)
- 一个方法是主方法，在主方法中调用useStudentBuilder方法
代码演示
javapublic class Student { private String name; private int age; public Student() { } public Student(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } } public interface StudentBuilder { Student build(String name,int age); } public class StudentDemo { public static void main(String[] args) { //Lambda简化写法 useStudentBuilder((name,age) -> new Student(name,age)); //引用构造器 useStudentBuilder(Student::new); } private static void useStudentBuilder(StudentBuilder sb) { Student s = sb.build("张三", 30); System.out.println(s.getName() + "," + s.getAge()); } }使用说明
Lambda表达式被构造器替代的时候，它的形式参数全部传递给构造器作为参数
