Java 面向对象（十五）

Java 面向对象（十五）
Lambda表达式

1. 函数式编程思想概述

在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿什么东西做什么事情”。相对而言，面向对象过分强调“必须通过对象的形式来做事情”，而函数式思想则尽量忽略面向对象的复杂语法， 强调做什么，而不是以什么形式做。

面向对象的思想：
- 做一件事情，找一个能解决这个事情的对象，调用对象的方法，完成事情。
函数式编程思想：
- 只要能获取到结果，谁去做的，怎么做的都不重要，重视的是结果，不重视过程。
2. 冗余的代码

【例1】传统写法

当需要启动一个线程去完成任务时，通常会通过 java.lang.Runnable 接口来定义任务内容，并使用 java.lang.Thread 类来启动该线程。代码如下：
```
public class DemoRunnable {
	public static void main(String[] args) {
    	// 匿名内部类
		Runnable task = new Runnable() {
			@Override
			public void run() { // 覆盖重写抽象方法
				System.out.println("多线程任务执行！");
			}
		};
		new Thread(task).start(); // 启动线程
	}
}
```
本着“一切皆对象”的思想，这种做法是无可厚非的：首先创建一个Runnable接口的匿名内部类对象来指定任务内容，再将其交给一个线程来启动。

【例1】代码分析

对于 Runnable 的匿名内部类用法，可以分析出几点内容：
- Thread 类需要 Runnable 接口作为参数，其中的抽象 run 方法是用来指定线程任务内容的核心；
- 为了指定 run 的方法体，不得不需要 Runnable 接口的实现类；
- 为了省去定义一个 RunnableImpl 实现类的麻烦，不得不使用匿名内部类；
- 必须覆盖重写抽象 run 方法，所以方法名称、方法参数、方法返回值不得不再写一遍，且不能写错；
- 而实际上，似乎只有方法体才是关键所在。
【例2】传统写法

当需要自定义排序的TreeSet集合时，通常会通过 jjava.util.Comparator 接口来定义排序方法，并使用 TreeSet(Comparator<? super E> comparator) 这个构造器来调用。代码如下：
```
public class DemoComparator {
	public static void main(String[] args) {
		// 匿名内部类
		Comparator<Integer> comparator = new Comparator<Integer>() {
			@Override
			public int compare(Integer o1, Integer o2) { // 覆盖重写抽象方法
				return Integer.compare(o1, o2);
			}
		};
		
		TreeSet<Integer> set = new TreeSet<>(comparator);
	}
}
```
【例2】代码分析

对于 comparator 的匿名内部类用法，可以分析出几点内容：
- TreeSet 构造器需要 comparator 接口作为参数，其中的抽象 compare 方法是用来指定排序的核心；
- 为了指定 compare 的方法体，不得不需要 comparator 接口的实现类；
- 为了省去定义一个 comparatorImpl 实现类的麻烦，不得不使用匿名内部类；
- 必须覆盖重写抽象 compare 方法，所以方法名称、方法参数、方法返回值不得不再写一遍，且不能写错；
- 而实际上，只有参数和方法体才是关键所在。
3. 编程思想转换

做什么，而不是怎么做

我们真的希望创建一个匿名内部类对象吗？不。我们只是为了做这件事情而不得不创建一个对象。我们真正希望做的事情是：将 run 方法体内的代码传递给 Thread 类知晓。

传递一段代码——这才是我们真正的目的。而创建对象只是受限于面向对象语法而不得不采取的一种手段方式。那，有没有更加简单的办法？如果我们将关注点从“怎么做”回归到“做什么”的本质上，就会发现只要能够更好地达到目的，过程与形式其实并不重要。

生活举例

当我们需要从北京到上海时，可以选择高铁、汽车、骑行或是徒步。我们的真正目的是到达上海，而如何才能到达上海的形式并不重要，所以我们一直在探索有没有比高铁更好的方式——搭乘飞机。

而现在这种飞机（甚至是飞船）已经诞生：2014年3月Oracle所发布的Java 8（JDK 1.8）中，加入了Lambda表达式的重量级新特性，为我们打开了新世界的大门。

4. 体验Lambda的更优写法

借助Java 8的全新语法，上述例子的匿名内部类写法可以通过更简单的Lambda表达式达到等效：
```
public class DemoLambdaRunnable {
	public static void main(String[] args) {
		new Thread(() -> System.out.println("多线程任务执行！")).start(); // 启动线程
	}
}

public class DemoLambdaComparator {
	public static void main(String[] args) {
		TreeSet<Integer> set = new TreeSet<>((x, y) -> Integer.compare(x, y));
	}
}
```
这段代码和刚才的执行效果是完全一样的，可以在1.8或更高的编译级别下通过。

不再有“不得不创建接口对象”的束缚，不再有“抽象方法覆盖重写”的负担，就是这么简单！

5. 回顾匿名内部类

Lambda是怎样击败面向对象的？在上例中，核心代码其实只是如下所示的内容：
```
() -> System.out.println("多线程任务执行！");

(x, y) -> Integer.compare(x, y);
```
为了理解Lambda的语义，我们需要从传统的代码起步。

使用实现类

要启动一个线程，需要创建一个Thread类的对象并调用start方法。而为了指定线程执行的内容，需要调用Thread类的构造方法：
- public Thread(Runnable target)
为了获取Runnable接口的实现对象，可以为该接口定义一个实现类RunnableImpl：
```
public class RunnableImpl implements Runnable {
	@Override
	public void run() {
		System.out.println("多线程任务执行！");
	}
}
```
然后创建该实现类的对象作为Thread类的构造参数：
```
public class Demo03ThreadInitParam {
	public static void main(String[] args) {
		Runnable task = new RunnableImpl();
		new Thread(task).start();
	}
}
```
【例2】TreeSet的排序也是同理，这里不再阐述。

使用匿名内部类

这个 RunnableImpl 类只是为了实现 Runnable 接口而存在的，而且仅被使用了唯一一次，所以使用匿名内部类的语法即可省去该类的单独定义，即匿名内部类：
```
public class Demo04ThreadNameless {
	public static void main(String[] args) {
		new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("多线程任务执行！");
			}
		}).start();
	}
}
```
匿名内部类的好处与弊端

一方面，匿名内部类可以帮我们省去实现类的定义；另一方面，匿名内部类的语法——确实太复杂了！

语义分析

仔细分析该代码中的语义，Runnable 接口只有一个 run 方法的定义：
- public abstract void run();
即制定了一种做事情的方案（其实就是一个函数）：
- 无参数：不需要任何条件即可执行该方案。
- 无返回值：该方案不产生任何结果。
- 代码块（方法体）：该方案的具体执行步骤。
同样的语义体现在 Lambda 语法中，要更加简单：
```
() -> System.out.println("多线程任务执行！")
```
- 前面的一对小括号即run方法的参数（无），代表不需要任何条件；
- 中间的一个箭头代表将前面的参数传递给后面的代码；
- 后面的输出语句即业务逻辑代码。
6. Lambda标准格式

Lambda省去面向对象的条条框框，格式由3个部分组成：
- 一些参数
- 一个箭头
- 一段代码
Lambda表达式的标准格式为：
```
(参数类型 参数名称) -> { 代码语句 }
```
格式说明：
- 小括号内的语法与传统方法参数列表一致：无参数则留空；多个参数则用逗号分隔。
- -> 是新引入的语法格式，代表指向动作。
- 大括号内的语法与传统方法体要求基本一致。
7. Lambda省略格式

可推导即可省略

Lambda强调的是“做什么”而不是“怎么做”，所以凡是可以根据上下文推导得知的信息，都可以省略。

省略规则

在Lambda标准格式的基础上，使用省略写法的规则为：
1. 小括号内参数的类型可以省略；
2. 如果小括号内有且仅有一个参数，则小括号可以省略；
3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。
8. Lambda的使用前提

Lambda的语法非常简洁，完全没有面向对象复杂的束缚。但是使用时有几个问题需要特别注意：

（1）使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。无论是JDK内置的 Runnable、Comparator 接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时，才可以使用 Lambda。

（2）使用Lambda必须具有上下文推断。也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。

备注：有且仅有一个抽象方法的接口，称为“函数式接口”。

9. 练习

（1）无参无返回

题目

给定一个厨子 Cook 接口，内含唯一的抽象方法 makeFood，且无参数、无返回值。如下：
```
public interface Cook {
    void makeFood();
}
```
在下面的代码中，请使用Lambda的标准格式调用 invokeCook 方法，打印输出“吃饭啦！”字样：
```
public class DemoInvokeCook {
    public static void main(String[] args) {
        // 请在此使用Lambda【标准格式】调用invokeCook方法
    }

    private static void invokeCook(Cook cook) {
        cook.makeFood();
    }
}
```
解答
```
public static void main(String[] args) {
    invokeCook(() -> {
      	System.out.println("吃饭啦！");
    });
}
```
备注：小括号代表 Cook 接口 makeFood 抽象方法的参数为空，大括号代表makeFood 的方法体。

（2）有参有返回

题目

给定一个计算器Calculator接口，内含抽象方法 calc 可以将两个int数字相加得到和值：
```
public interface Calculator {
    int calc(int a, int b);
}
```
在下面的代码中，请使用Lambda的标准格式调用 invokeCalc 方法，完成120和130的相加计算：
```
public class Demo08InvokeCalc {
    public static void main(String[] args) {
        // 请在此使用Lambda【标准格式】调用invokeCalc方法来计算120+130的结果
    }

    private static void invokeCalc(int a, int b, Calculator calculator) {
        int result = calculator.calc(a, b);
        System.out.println("结果是：" + result);
    }
}
```
解答
```
public static void main(String[] args) {
    invokeCalc(120, 130, (int a, int b) -> {
      	return a + b;
    });
}
```
备注：小括号代表 Calculator 接口 calc 抽象方法的参数，大括号代表 calc 的方法体。

函数式接口

1. 概念

函数式接口在Java中是指：有且仅有一个抽象方法的接口。

函数式接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。

备注：“语法糖” 是指使用更加方便，但是原理不变的代码语法。例如在遍历集合时使用的 for-each语法，其实底层的实现原理仍然是迭代器，这便是“语法糖”。从应用层面来讲，Java中的Lambda可以被当做是匿名内部类的“语法糖”，但是二者在原理上是不同的。

2. 格式

只要确保接口中有且仅有一个抽象方法即可：
```
修饰符 interface 接口名称 {
    public abstract 返回值类型 方法名称(可选参数信息);
    // 其他非抽象方法内容
}
```
由于接口当中抽象方法的 public abstract 是可以省略的，所以定义一个函数式接口很简单：
```
public interface MyFunctionalInterface {
    void myMethod();
}
```
3. @FunctionalInterface注解

与 @Override 注解的作用类似，Java 8中专门为函数式接口引入了一个新的注解： @FunctionalInterface 。该注解可用于一个接口的定义上：
```
@FunctionalInterface
public interface MyFunctionalInterface {
	void myMethod();
}
```
一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错。需要注意的是，即使不使用该注解，只要满足函数式接口的定义，这仍然是一个函数式接口，使用起来都一样。

4. 自定义函数式接口

对于刚刚定义好的 MyFunctionalInterface 函数式接口，典型使用场景就是作为方法的参数：
```
public class Demo09FunctionalInterface {
    // 使用自定义的函数式接口作为方法参数
    private static void doSomething(MyFunctionalInterface inter) {
    	inter.myMethod(); // 调用自定义的函数式接口方法
    }
    
    public static void main(String[] args) {
    // 调用使用函数式接口的方法
    	doSomething(() -> System.out.println("Lambda执行啦！"));
    }
}
```
函数式编程

在兼顾面向对象特性的基础上，Java语言通过Lambda表达式与方法引用等，为开发者打开了函数式编程的大门。下面我们做一个初探。

1. Lambda的延迟执行

有些场景的代码执行后，结果不一定会被使用，从而造成性能浪费。而Lambda表达式是延迟执行的，这正好可以作为解决方案，提升性能。

性能浪费的日志案例

注: 日志可以帮助我们快速的定位问题，记录程序运行过程中的情况，以便项目的监控和优化。

一种典型的场景就是对参数进行有条件使用，例如对日志消息进行拼接后，在满足条件的情况下进行打印输出：
```
public class DemoLogger {
	private static void log(int level, String msg) {
		if (level == 1) {
			System.out.println(msg);
		}
	}

	public static void main(String[] args) {
		String msgA = "Hello";
		String msgB = "World";
		String msgC = "Java";
		log(1, msgA + msgB + msgC);
	}
}
```
这段代码存在问题：无论级别是否满足要求，作为 log 方法的第二个参数，三个字符串一定会首先被拼接并传入方法内，然后才会进行级别判断。如果级别不符合要求，那么字符串的拼接操作就白做了，存在性能浪费。

备注：SLF4J 是应用非常广泛的日志框架，它在记录日志时为了解决这种性能浪费的问题，并不推荐首先进行字符串的拼接，而是将字符串的若干部分作为可变参数传入方法中，仅在日志级别满足要求的情况下才会进行字符串拼接。例如： LOGGER.debug("变量{}的取值为{}。", "os", "macOS") ，其中的大括号 {} 为占位符。如果满足日志级别要求，则会将“os”和“macOS”两个字符串依次拼接到大括号的位置；否则不会进行字符串拼接。这也是一种可行解决方案，但Lambda可以做到更好。

体验Lambda的更优写法

使用 Lambda 必然需要一个函数式接口：
```
@FunctionalInterface
public interface MessageBuilder {
	String buildMessage();
}
```
然后对 log 方法进行改造：
```
public class DemoLoggerLambda {
	private static void log(int level, MessageBuilder builder) {
		if (level == 1) {
			System.out.println(builder.buildMessage());
		}
	}

	public static void main(String[] args) {
		String msgA = "Hello";
		String msgB = "World";
		String msgC = "Java";
		log(1, () -> msgA + msgB + msgC);
	}
}
```
这样一来，只有当级别满足要求的时候，才会进行三个字符串的拼接；否则三个字符串将不会进行拼接。

证明Lambda的延迟

下面的代码可以通过结果进行验证：
```
public class DemoLoggerDelay {
	private static void log(int level, MessageBuilder builder) {
		if (level == 1) {
			System.out.println(builder.buildMessage());
		}
	}

	public static void main(String[] args) {
		String msgA = "Hello";
		String msgB = "World";
		String msgC = "Java";
		log(2, () -> {
			System.out.println("Lambda执行！");
			return msgA + msgB + msgC;
		});
	}
}
```
结果什么也没输出，从结果中可以看出，在不符合级别要求的情况下，Lambda将不会执行。从而达到节省性能的效果。

扩展：实际上使用内部类也可以达到同样的效果，只是将代码操作延迟到了另外一个对象当中通过调用方法来完成。而是否调用其所在方法是在条件判断之后才执行的。

2. 使用Lambda作为参数和返回值

如果抛开实现原理不说，Java中的Lambda表达式可以被当作是匿名内部类的替代品。如果方法的参数是一个函数式接口类型，那么就可以使用Lambda表达式进行替代。使用Lambda表达式作为方法参数，其实就是使用函数式接口作为方法参数。

例如 java.lang.Runnable 接口就是一个函数式接口，假设有一个 startThread 方法使用该接口作为参数，那么就可以使用Lambda进行传参。这种情况其实和 Thread 类的构造方法参数为 Runnable 没有本质区别。
```
public class Demo04Runnable {
	private static void startThread(Runnable task) {
		new Thread(task).start();
	}

	public static void main(String[] args) {
		startThread(() -> System.out.println("线程任务执行！"));
	}
}
```
类似地，如果一个方法的返回值类型是一个函数式接口，那么就可以直接返回一个Lambda表达式。当需要通过一个方法来获取一个 java.util.Comparator 接口类型的对象作为排序器时，就可以调该方法获取。
```
import java.util.Arrays;
import java.util.Comparator;
public class DemoComparator {
	private static Comparator<String> newComparator() {
		return (a, b) -> b.length() - a.length();
	}
	public static void main(String[] args) {
		String[] array = { "abc", "ab", "abcd" };
		System.out.println(Arrays.toString(array));
		Arrays.sort(array, newComparator());
		System.out.println(Arrays.toString(array));
	}
}
```
其中直接return一个Lambda表达式即可。

3. 常用函数式接口

JDK提供了大量常用的函数式接口以丰富Lambda的典型使用场景，它们主要在 java.util.function 包中被提供。

下面是最简单的几个接口及使用示例。

（1）Supplier接口

java.util.function.Supplier 接口仅包含一个无参的方法： T get() 。

用来获取一个泛型参数指定类型的对象数据。由于这是一个函数式接口，这也就意味着对应的Lambda表达式需要“对外提供”一个符合泛型类型的对象数据。
```
import java.util.function.Supplier;
public class DemoSupplier {
	private static String getString(Supplier<String> function) {
		return function.get();
	}
	public static void main(String[] args) {
		String msgA = "Hello";
		String msgB = "World";
		System.out.println(getString(() -> msgA + msgB));
	}
}
```
练习：求数组元素最大值

题目

使用 Supplier 接口作为方法参数类型，通过Lambda表达式求出 int 数组中的最大值。提示：接口的泛型请使用 java.lang.Integer 类。

解答
```
public class Test {
	// 定一个方法,方法的参数传递Supplier,泛型使用Integer
	public static int getMax(Supplier<Integer> sup) {
		return sup.get();
	}

	public static void main(String[] args) {
		int arr[] = { 2, 3, 4, 52, 333, 23 };
		// 调用getMax方法,参数传递Lambda
		int maxNum = getMax(() -> {
			// 计算数组的最大值
			int max = arr[0];
			for (int i : arr) {
				if (i > max) {
					max = i;
				}
			}
			return max;
		});
		System.out.println(maxNum);
	}
}
```
（2）Consumer接口

java.util.function.Consumer 接口则正好与Supplier接口相反，它不是生产一个数据，而是消费一个数据，其数据类型由泛型决定。

抽象方法：accept

Consumer 接口中包含抽象方法 void accept(T t) ，意为消费一个指定泛型的数据。基本使用如下：
```
import java.util.function.Consumer;

public class Test {
	private static void consumeString(Consumer<String> function) {
		function.accept("Hello");
	}

	public static void main(String[] args) {
		consumeString(s -> System.out.println(s));
	}
}
```
默认方法：andThen

如果一个方法的参数和返回值全都是 Consumer 类型，那么就可以实现效果：消费数据的时候，首先做一个操作，然后再做一个操作，实现组合。而这个方法就是 Consumer 接口中的default方法 andThen 。下面是JDK的源代码：
```
default Consumer<T> andThen(Consumer<? super T> after) {
    Objects.requireNonNull(after);
    return (T t) -> { accept(t); after.accept(t); };
}
```
备注： java.util.Objects 的 requireNonNull 静态方法将会在参数为null时主动抛出 NullPointerException 异常。这省去了重复编写 if 语句和抛出空指针异常的麻烦。

要想实现组合，需要两个或多个Lambda表达式即可，而 andThen 的语义正是“一步接一步”操作。例如两个步骤组合的情况：
```
private static void consumeString(Consumer<String> one, Consumer<String> two) {
    one.andThen(two).accept("Hello");
}

public static void main(String[] args) {
    consumeString(s -> System.out.println(s.toUpperCase()), s -> System.out.println(s.toLowerCase()));
}
```
练习：格式化打印信息

题目

下面的字符串数组当中存有多条信息，请按照格式“ 姓名：XX。性别：XX。 ”的格式将信息打印出来。要求将打印姓名的动作作为第一个 Consumer 接口的Lambda实例，将打印性别的动作作为第二个 Consumer 接口的Lambda实例，将两个 Consumer 接口按照顺序“拼接”到一起。
```
public static void main(String[] args) {
    String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男" };
}
```
解答
```
import java.util.function.Consumer;

public class Test {
	public static void main(String[] args) {
		String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男" };
		printInfo(s -> System.out.print("姓名：" + s.split(",")[0]),
				s -> System.out.println("。性别：" + s.split(",")[1] + "。"), array);
	}

	private static void printInfo(Consumer<String> one, Consumer<String> two, String[] array) {
		for (String info : array) {
			one.andThen(two).accept(info); // 姓名：迪丽热巴。性别：女。
		}
	}
}
```
（3）Predicate接口

有时候我们需要对某种类型的数据进行判断，从而得到一个boolean值结果。这时可以使用 java.util.function.Predicate 接口。

抽象方法：test

Predicate 接口中包含一个抽象方法： boolean test(T t) 。用于条件判断的场景：
```
import java.util.function.Predicate;

public class Test {
	private static void method(Predicate<String> predicate) {
		boolean veryLong = predicate.test("HelloWorld");
		System.out.println("字符串很长吗：" + veryLong);
	}

	public static void main(String[] args) {
		method(s -> s.length() > 5);
	}
}
```
条件判断的标准是传入的Lambda表达式逻辑，只要字符串长度大于5则认为很长。

默认方法：and

既然是条件判断，就会存在与、或、非三种常见的逻辑关系。其中将两个 Predicate 条件使用“与”逻辑连接起来实现“并且”的效果时，可以使用default方法 and 。其JDK源码为：
```
default Predicate<T> and(Predicate<? super T> other) {
    Objects.requireNonNull(other);
    return (t) -> test(t) && other.test(t);
}
```
如果要判断一个字符串既要包含大写“H”，又要包含大写“W”，那么：
```
import java.util.function.Predicate;

public class Test {
	private static void method(Predicate<String> one, Predicate<String> two) {
		boolean isValid = one.and(two).test("Helloworld");
		System.out.println("字符串符合要求吗：" + isValid);
	}

	public static void main(String[] args) {
		method(s -> s.contains("H"), s -> s.contains("W"));
	}
}
```
默认方法：or

与 and 的“与”类似，默认方法 or 实现逻辑关系中的“或”。JDK源码为：
```
default Predicate<T> or(Predicate<? super T> other) {
    Objects.requireNonNull(other);
    return (t) -> test(t) || other.test(t);
}
```
如果希望实现逻辑“字符串包含大写H 或者包含大写W”，那么代码只需要将“and”修改为“or”名称即可，其他都不变。
```
boolean isValid = one.or(two).test("Helloworld");
```
默认方法：negate

“与”、“或”已经了解了，剩下的“非”（取反）也会简单。默认方法 negate 的JDK源代码为:
```
default Predicate<T> negate() {
    return (t) -> !test(t);
}
```
从实现中很容易看出，它是执行了test方法之后，对结果boolean值进行“!”取反而已。一定要在 test 方法调用之前调用 negate 方法，正如 and 和 or 方法一样：
```
import java.util.function.Predicate;

public class Test {
	private static void method(Predicate<String> predicate) {
		boolean veryLong = predicate.negate().test("HelloWorld");
		System.out.println("字符串很长吗：" + veryLong);
	}

	public static void main(String[] args) {
		method(s -> s.length() < 5);
	}
}
```
练习：集合信息筛选

题目

数组当中有多条“姓名+性别”的信息如下，请通过 Predicate 接口的拼装将符合要求的字符串筛选到集合 ArrayList 中，需要同时满足两个条件：
1. 必须为女生；
2. 姓名为4个字。
```
public class DemoPredicate {
    public static void main(String[] args) {
        String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "赵丽颖,女" };
    }
}
```
解答
```
import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;

public class Test {
	public static void main(String[] args) {
		String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "赵丽颖,女" };
		List<String> list = filter(array, s -> "女".equals(s.split(",")[1]), s -> s.split(",")[0].length() == 4);
		System.out.println(list);
	}

	private static List<String> filter(String[] array, Predicate<String> one, Predicate<String> two) {
		List<String> list = new ArrayList<>();
		for (String info : array) {
			if (one.and(two).test(info)) {
				list.add(info);
			}
		}
		return list;
	}
}
```
（4）Function接口

java.util.function.Function 接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件。

抽象方法：apply

Function 接口中最主要的抽象方法为： R apply(T t) ，根据类型T的参数获取类型R的结果。

使用的场景例如：将 String 类型转换为 Integer 类型。
```
import java.util.function.Function;

public class Test {
	private static void method(Function<String, Integer> function) {
		int num = function.apply("10");
		System.out.println(num + 20);
	}

	public static void main(String[] args) {
		method(s -> Integer.parseInt(s));
	}
}
```
默认方法：andThen

Function 接口中有一个默认的 andThen 方法，用来进行组合操作。JDK源代码如：
```
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
    Objects.requireNonNull(after);
    return (T t) -> after.apply(apply(t));
}
```
该方法同样用于“先做什么，再做什么”的场景，和 Consumer 中的 andThen 差不多：
```
import java.util.function.Function;

public class Test {
	private static void method(Function<String, Integer> one, Function<Integer, Integer> two) {
		int num = one.andThen(two).apply("10");
		System.out.println(num + 20);
	}

	public static void main(String[] args) {
		method(str -> Integer.parseInt(str) + 10, i -> i *= 10);
	}
}
```
第一个操作是将字符串解析成为int数字后加10，第二个操作是乘以10。两个操作通过 andThen 按照前后顺序组合到了一起。

请注意，Function的前置条件泛型和后置条件泛型可以相同。

练习：自定义函数模型拼接

题目

请使用 Function 进行函数模型的拼接，按照顺序需要执行的多个函数操作为：
String str = "赵丽颖,20";
1. 将字符串截取数字年龄部分，得到字符串；
2. 将上一步的字符串转换成为int类型的数字；
3. 将上一步的int数字累加100，得到结果int数字。
解答
```
import java.util.function.Function;

public class Test {
	public static void main(String[] args) {
		String str = "赵丽颖,20";
		int age = getAgeNum(str, s -> s.split(",")[1], s -> Integer.parseInt(s), n -> n += 100);
		System.out.println(age);
	}

	private static int getAgeNum(String str, Function<String, String> one, Function<String, Integer> two,
			Function<Integer, Integer> three) {
		return one.andThen(two).andThen(three).apply(str);
	}
}
```
相关阅读:
delphi 类型转化
 VCL主要框架
 delphi TFileStream.create
delphi常用函数过程
 VMT & DMT
index.jsp报错The superclass "javax.servlet.http.HttpServlet" was not found on the Java Build Path的解决办法
 the selection cannot be run on any server错误解决方法
 从request获取各种路径总结
 A Java Exception has occurred 和 org/apache/juli/logging/LogFactory错误解决方法
 操作系统第5次实验报告：内存管理
原文地址：https://www.cnblogs.com/xzh0717/p/11334866.html

Java 面向对象（十五）

Lambda表达式

1. 函数式编程思想概述

2. 冗余的代码

【例1】传统写法

【例1】代码分析

【例2】传统写法

【例2】代码分析

3. 编程思想转换

做什么，而不是怎么做

生活举例

4. 体验Lambda的更优写法

5. 回顾匿名内部类

使用实现类

使用匿名内部类

匿名内部类的好处与弊端

语义分析

6. Lambda标准格式

7. Lambda省略格式

可推导即可省略

省略规则

8. Lambda的使用前提

9. 练习

（1）无参无返回

（2）有参有返回

函数式接口

1. 概念

2. 格式

3. @FunctionalInterface注解

4. 自定义函数式接口

函数式编程

1. Lambda的延迟执行

性能浪费的日志案例

体验Lambda的更优写法

证明Lambda的延迟

2. 使用Lambda作为参数和返回值

3. 常用函数式接口

（1）Supplier接口

（2）Consumer接口

（3）Predicate接口

（4）Function接口