第九章 Lambda&方法引用

9.1、Lambda表达式

9.1.1、标准格式

(形式参数) -> {代码块}

9.1.2、使用前提

有一个接口并且接口中有且仅有一个抽象方法

9.1.3、常见应用

9.1.3.1、无参无返回值抽象方法练习

interface MyInter {

	void show();

}

public class Main {

	public static void main(String[] args) {

		myInterShow(() -> System.out.println("Hello,World"));

	}

	public static void myInterShow(MyInter mi) {

		mi.show();

	}

}

9.1.3.2、有参无返回值抽象方法练习

interface MyInter {

	void show(String s);

}

public class Main {

	public static void main(String[] args) {

		myInterShow((s) -> System.out.println(s));

	}

	public static void myInterShow(MyInter mi) {

		mi.show("Hello,World");

	}

}

9.1.3.3、有参有返回值抽象方法练习

interface MyInter {

	int show(int x, int y);

}

public class Main {

	public static void main(String[] args) {

		myInterShow((x, y) -> x + y);

	}

	public static void myInterShow(MyInter mi) {

		int show = mi.show(10, 20);

		System.out.println(show);

	}

}

9.1.4、省略模式

参数类型可以省略。但是有多个参数的情况下，不能只省略一个
如果参数有且仅有一个，那么小括号可以省略
如果代码块的语句只有一条，可以省略大括号和分号和return关键字

9.1.5、注意事项

使用Lambda必须要有接口并且要求接口中有且仅有一个抽象方法
必须有上下文环境，才能推导出Lambda对应的接口
- 根据局部变量的赋值得知Lambda对应的接口
```
Runnable r = () -> System.out.println("Hello,World");
```
- 根据调用方法的参数得知Lambda对应的接口
```
new Thread(() -> System.out.println("Hello,World")).start();
```

9.1.6、Lambda表达式和匿名内部类的区别

所需类型不同
- 匿名内部类：可以是接口，也可以是抽象类，还可以是具体类
- Lambda表达式：只能是接口
使用限制不同
- 如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类
- 如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式
实现原理不同
- 匿名内部类：编译之后，产生一个单独的.class字节码文件
- Lambda表达式：编译之后，没有一个单独的.class字节码文件，对应的字节码会在运行的时候动态生成

9.2、方法引用

9.2.1、概述

在使用Lambda表达式的时候，我们实际上传递进去的代码就是一种解决方案，拿参数做操作，如果我们在Lambda中所指定的操作方案，已经有地方存在相同方案，那是否还有必要再写重复逻辑呢？肯定是没必要，那我们又是如何使用已经存在的方案的呢？我们是通过方法引用来使用已经存在的方案

9.2.2、方法引用符

::  该符号为引用运算符，而它所在的表达式被称为方法引用

9.2.3、省略模式

方法引用可以根据上下文进行推导，方法引用是Lambda的孪生兄弟

9.2.4、常见应用

9.2.4.1、引用类方法

使用说明：Lambda表达式被类方法替代的时候，它的形式参数全部传递给静态方法作为参数

interface Converter {

	int convert(String s);

}

public class Main {

	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);

	}

}

9.2.4.2、引用类的实例方法

使用说明：Lambda表达式被类的实例方法替代的时候，第一个参数作为调用者，后面的参数全部传递给该方法作为参数

interface MyString {

	String mySubString(String s, int x, int y);

}

public class Main {

	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);

	}

}

9.2.4.3、引用对象的实例方法

使用说明：Lambda表达式被对象的实例方法替代的时候，它的形式参数全部传递给该方法作为参数

class PrintString {

	public void printUpper(String s) {

		String result = s.toUpperCase();

		System.out.println(result);

	}

}

interface Printer {

	void printUpperCase(String s);

}

public class Main {

	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");

	}

}

9.2.4.4、引用构造器方法

使用说明：Lambda表达式被构造器替代的时候，它的形式参数全部传递给构造器作为参数

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;

	}

}

interface StudentBuilder {

	Student build(String name, int age);

}

public class Main {

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

	}

}

巴特西