【笔记】Java函数式编程
Lambda表达式
Lambda表达式由三个部分组成：第一部分为一个括号内用逗号分隔的参数列表，参数即函数式接口里面方法的参数；第二部分为一个箭头符号：->；第三部分为方法体，可以是表达式和代码块。
可选的类型声明：你不用去声明参数的类型。编译器可以从参数的值来推断它是什么类型。
可选的参数周围的括号：你可以不用在括号内声明单个参数。但是对于很多参数的情况，括号是必需的。
可选的大括号：如果表达式体里面只有一个语句，那么你不必用大括号括起来。
可选的返回关键字：如果表达式体只有单个表达式用于值的返回，那么编译器会自动完成这一步。若要指示表达式来返回某个值，则需要使用大括号。
为了让现有的功能和 Lambda 表达式友好兼容，于是就有了函数接口这个概念。函数接口是一种只有一个方法的接口，函数接口可以隐式地转换成 Lambda 表达式。
我们能够使用 Lambda 实例化它们，Lambda 表达式让你能够将函数作为方法参数，或者将代码作为数据对待。
Lambda 表达式让匿名类不再需要，这为 Java 增添了简洁但实用的函数式编程能力。
代码示例：
public class NewFeaturesTester {
public static void main(String[] args) {
NewFeaturesTester tester = new NewFeaturesTester();
// 有类型声明
MathOperation addition = (int a, int b) -> a + b;
// 没有类型声明
MathOperation subtraction = (a, b) -> a - b;
// 带有大括号，返回值
MathOperation multiplication = (int a, int b) -> { return a*b; };
// 没有大括号和return
MathOperation division = (int a, int b) -> a / b;
System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));
System.out.println("10 / 5 = " + tester.operate(10, 5, division));
// 没有括号
GreetingService greetingService1 = message -> System.out.println("Hello " + message);
// 有括号
GreetingService greetingService2 = (message) -> System.out.println("Hello " + message);
greetingService1.sayMessage("World");
greetingService1.sayMessage("China");
}
interface MathOperation {
int operation(int a, int b);
}
interface GreetingService {
void sayMessage(String message);
}
private int operate(int a, int b, MathOperation mathOperation) {
return mathOperation.operation(a, b);
}
}
作用域
public class NewFeaturesTester{
final static String salutation = "Hello "; // 正确，不可再次赋值
// static String salutation = "Hello "; // 正确，可再次赋值
// String salutation = "Hello "; // 非静态，报错
// final String salutation = "Hello "; // 非静态，报错
public static void main(String args[]){
// final String salutation = "Hello "; // 正确，不可再次赋值
// String salutation = "Hello "; // 正确，隐性为 final，不可再次赋值
// salution = "welcome to "
GreetingService greetService1 = message ->
System.out.println(salutation + message);
greetService1.sayMessage("World");
}
interface GreetingService{
void sayMessage(String message);
}
}
可访问 static 修饰的成员变量，如果是 final static 修饰，不可再次赋值，只有 static 修饰可再次赋值。
可访问表达式外层的 final 局部变量（不用声明为 final，隐性具有 final 语义），不可再次赋值。
方法引用
方法也是一种对象，可以通过名字来引用。不过方法引用的唯一用途是支持 Lambda 的简写，使用方法名称来表示 Lambda。
方法引用可以通过方法的名字来引用其本身。方法引用是通过双冒号 :: 来描述的。
可以引用以下类型：
构造器引用。语法是 Class::new，或者更一般的 Class< T >::new，要求构造器方法是没有参数。
静态方法引用。语法是 Class::static_method，要求接受一个 Class 类型的参数。
特定类的任意对象方法引用。它的语法是 Class::method，要求方法是没有参数的。
特定对象的方法引用，它的语法是 instance::method。要求方法接受一个参数，与 3 不同的地方在于，3 是在列表元素上分别调用方法，而 4 是在某个对象上调用方法，将列表元素作为参数传入。
代码示例：
import java.util.List;
import java.util.ArrayList;
public class NewFeaturesTester{
public static void main(String args[]){
List<String> names = new ArrayList<>();
names.add("Peter");
names.add("Linda");
names.add("Smith");
names.add("Zack");
names.add("Bob");
// 通过 System.out::println 引用了输出的方法
names.forEach(System.out::println);
}
}
函数式接口
函数式接口通过一个单一的功能来表现。例如，带有单个 compareTo 方法的比较接口，被用于比较的场合。Java 8 开始定义了大量的函数式接口来广泛地用于 Lambda 表达式。
Java 8 引入的一个核心概念是函数式接口（Functional Interfaces）。通过在接口里面添加一个抽象方法，这些方法可以直接从接口中运行。
如果一个接口定义唯一一个抽象方法，那么这个接口就成为函数式接口。
同时，引入了一个新的注解：@FunctionalInterface。可以把他它放在一个接口前，表示这个接口是一个函数式接口。
这个注解是非必须的，只要接口只包含一个方法的接口，虚拟机会自动判断，不过最好在接口上使用注解 @FunctionalInterface 进行声明。
在接口中添加了 @FunctionalInterface 的接口，只允许有一个抽象方法，否则编译器也会报错。
函数式接口列表：
| 接口 | 描述 |
|---|---|
| BitConsumer<T,U> | 该接口代表了接收两个输入参数 T、U，并且没有返回的操作 |
| BiFunction<T,U,R> | 该接口代表提供接收两个参数 T、U，并且产生一个结果 R 的方法 |
| BinaryOperator | 代表了基于两个相同类型的操作数，产生仍然是相同类型结果的操作 |
| BiPredicate<T,U> | 代表了对两个参数的断言操作（基于 Boolean 值的方法） |
| BooleanSupplier | 代表了一个给出 Boolean 值结果的方法 |
| Consumer | 代表了接受单一输入参数并且没有返回值的操作 |
| DoubleBinaryOperator | 代表了基于两个 Double 类型操作数的操作，并且返回一个 Double 类型的返回值 |
| DoubleConsumer | 代表了一个接受单个 Double 类型的参数并且没有返回的操作 |
| DoubleFunction | 代表了一个接受 Double 类型参数并且返回结果的方法 |
| DoublePredicate | 代表了对一个 Double 类型的参数的断言操作 |
| DoubleSupplier | 代表了一个给出 Double 类型值的方法 |
| DoubleToIntFunction | 代表了接受单个 Double 类型参数但返回 Int 类型结果的方法 |
| DoubleToLongFunction | 代表了接受单个 Double 类型参数但返回 Long 类型结果的方法 |
| DoubleUnaryOperator | 代表了基于单个 Double 类型操作数且产生 Double 类型结果的操作 |
| Function<T,R> | 代表了接受一个参数并且产生一个结果的方法 |
| IntBinaryOperator | 代表了对两个 Int 类型操作数的操作，并且产生一个 Int 类型的结果 |
| IntConsumer | 代表了接受单个 Int 类型参数的操作，没有返回结果 |
| IntFunction | 代表了接受 Int 类型参数并且给出返回值的方法 |
| IntPredicate | 代表了对单个 Int 类型参数的断言操作 |
加有 @FunctionalInterface 注解的方法均是此类接口，位于 java.util.Funtion 包中。
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
public class NewFeaturesTester{
public static void main(String args[]){
List<Integer> list = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
System.out.println("All of the numbers:");
eval(list, n->true);
System.out.println("Even numbers:");
eval(list, n-> n%2 == 0 );
System.out.println("Numbers that greater than 5:");
eval(list, n -> n > 5 );
}
public static void eval(List<Integer> list, Predicate<Integer> predicate){
for(Integer n: list){
if(predicate.test(n)){
System.out.println(n);
}
}
}
}
默认方法作为一种向后兼容能力而出现，旧的接口也能用到 Lambda 表达式中。
Java 8 引入默认方式使得 List 和 Collection 接口能够拥有 forEach 方法的默认实现。
