参考《Java疯狂讲义》

参考《Java疯狂讲义》
Lambda表达式支持将代码块作为方法参数，Lambda表达式允许使用更简洁的代码来创建只有一个抽象方法的接口（这种接口被称为函数式接口）的实例

1. Lambda表达式入门

下面先使用匿名内部类来改写（6.6介绍的命令模式Command表达式的例子）

public class CommandTest
{
public static void main(String[] args)
{
ProcessArray pa = new ProcessArray();
int[] array = {3, -4, 6, 4};
// 处理数组，具体处理行为取决于匿名内部类
pa.process(array , new Command()
{
public void process(int[] target)
{
int sum = 0;
for (int tmp : target )
{
sum += tmp;
}
System.out.println("数组元素的总和是:" + sum);
}
});
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
程序通过匿名内部类实例来封装处理行为。而Lambda表达式完全可以简化创建匿名内部类对象。

public class CommandTest2
{
public static void main(String[] args)
{
ProcessArray pa = new ProcessArray();
int[] array = {3, -4, 6, 4};
// 处理数组，具体处理行为取决于匿名内部类
pa.process(array , (int[] target)->{
int sum = 0;
for (int tmp : target )
{
sum += tmp;
}
System.out.println("数组元素的总和是:" + sum);
});
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
通过上面的对比可知；Lambda表达式主要就是代替匿名内部类的繁琐语法。不需要new Xxx(){}的语法，不需要指出重写方法的名字，也不需要给出重写方法的返回值类型——只需要给出重写方法的形参列表即可。
当使用Lambda表达式代替匿名内部类创建对象时，Lambda表达式的代码块将会替代实现抽象方法的方法体，Lambda表达式就相当于一个匿名方法。
他由三部分组成；

形参列表。形参列表允许省略形参类型。如果形参列表中只有一个参数，甚至连形参列表的括号都能省略。
箭头。英文划线和大于号组成。
代码块。如果代码块只有一条语句，Lambda表达式允许省略代码块的花括号，那么这条语句就不要用花括号表示语句的结束。Lambda代码块只有一条return语句，甚至可以省略return关键字。Lambda表达式需要返回值，而他的代码块中仅有一条省略了return的语句，Lambda表达式会自动返回该语句的值。
下面示范Lambda表达式的几种简单写法；

interface Eatable
{
void taste();
}
interface Flyable
{
void fly(String weather);
}
interface Addable
{
int add(int a , int b);
}
public class LambdaQs
{
// 调用该方法需要Eatable对象
public void eat(Eatable e)
{
System.out.println(e);
e.taste();
}
// 调用该方法需要Flyable对象
public void drive(Flyable f)
{
System.out.println("我正在驾驶" + f);
f.fly("【碧空如洗的晴日】");
}
// 调用该方法需要Addable对象
public void test(Addable add)
{
System.out.println("5与3的和为" + add.add(5, 3));
}
public static void main(String[] args)
{
LambdaQs lq = new LambdaQs();
// Lambda表达式的代码块只有一条语句，可以省略花括号
lq.eat(()-> System.out.println("苹果的味道不错"));
// Lambda表达式的形参列表只有一个形参，可以省略圆括号
lq.drive(weather ->
{
System.out.println("今天天气是" + weather);
System.out.println("ֱ直升机飞行平稳");
});
//Lambda表达式的代码块只有一条语句，可以省略花括号
// 代码块只有一条语句，即使该表达式需要返回值，也可以省略return关键字
lq.test((a , b)->a + b);
}
}
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
35
36
37
38
39
40
41
42
43
44
45
46
47
2. Lambda表达式与函数式接口
Lambda表达式的类型，也被称为“目标类型(target type)”,Lambda表达式的目标类型必须是“函数式接口(functional interface)”。函数式接口代表只包含一个抽象方法的接口。函数式接口可以有多个默认方法，类方法，但只能声明一个抽象方法。

Java 8 专门为函数式接口提供了@FunctionalInterface注解，该注解通常放在接口定义前面，该注解对程序功能没有任何作用，它用于告诉编译器执行更严格的检查——检查该接口必须是函数式接口，否者编译器报错。

@FunctionalInterface
interface FkTest
{
void run();
}

public class LambdaTest
{
public static void main(String[] args)
{
// Runnable接口中只包含一个无参数的方法
// Lambda表达式代表的匿名方法实现了Runnable接口中唯一的，无参数的方法
// 因此下面的Lambda表达式创建了一个Runnable对象
Runnable r = () -> {
for(int i = 0 ; i < 100 ; i ++)
{
System.out.println();
}
};
// 下面代码将出现错误:Object不是函数式接口
//Object obj = (www.michenggw.com) -> {
// for(int i = www.douniu157.com 0 ; i < 100 ; i ++)
// {
// System.out.println();
// }
//};
//对Lambda表达式进行强制类型转换，这样就可以确定该表达式的目标类型为Runnable函数式接口
Object obj1 = (Runnable)(www.dfgjpt.com) -> {
for(int i = 0 ; i < 100 ; i ++)
{
System.out.println();
}
};
//同样的Lambda表达式可以被当成不同的目标类型，唯一的要求是：
// Lambda表达式的参数列表与函数式接口中唯一抽象方法的形参列表相同ͬ
Object obj2 = (FkTest)() -> {
for(int i = 0 ; i < 100 ; i ++)
{
System.out.println();
}
};

从以上代码可以得出一些结论：
Lambda表达式实现的是匿名方法——因此它只能实现特定的函数接口中唯一的方法。这就意味着Lambda表达式有如下两个限制：（1）Lambda表达式的目标类型只能是明确的函数式接口。（2）Lambda表达式只能为函数式接口创建对象。
为了保证Lambda表达式的目标类型是一个明确的函数式接口，可以有如下三种方式：（1）将Lambda表达式赋值给函数式接口类型的变量（2）将Lambda表达式作为函数式接口类型的参数传给某个方法（3）使用函数式接口对Lambda表达式进行强制类型转换
Java 8 在java.util.function包下预定了大量函数式接口，典型有4类接口：

XxxFunction：这类接口中通常包含一个apply()抽象方法，该方法对参数进行处理（处理逻辑由Lambda表达式决定），然后返回一个新的值
XxxConsumer：这类接口中通常包含一个accept()抽象方法，该方法与上面的方法相似，只是没有返回值
XxxPredicate：这类接口中通常包含一个test()抽象方法，该方法用于对参数进行某种判断（由Lambda表达式决定），然后返回一个Boolean类型的值
XxxSupplier：这类接口中通常包含一个getAsXxx()抽象方法，该方法没有参数，会按某种逻辑算法（由Lambda表达式决定）返回一个数据
3. 方法引用与构造器引用
如果Lambda表达式的代码块只有一条代码，不仅可以省略花括号，还可以在代码块中使用方法引用和构造器引用。
方法引用和构造器引用可以让Lambda表达式的代码块更加简洁，方法引用和代码块引用都要使用两个英文冒号。

引用类方法
@FunctionalInterface
interface Converter{
Integer convert(String from);
}
/下面代码使用Lambda表达式创建Converter对象
Converter converter1 www.dasheng178.com= from -> Integer.valueOf(from);
Integer val =www.meiwanyule.cn converter1.convert("99");
System.out.println(val); // 将输出99

使用一行调用类方法进行替换

// 方法引用代替Lambda表达式：引用类方法
// 函数式接口中被实现的全部参数传给该类方法作为参数
Converter converter1 = Integer::valueOf;
1
2
3
引用特定对象的实例方法
// 下面代码使用Lambda表达式创建Converter对象
Converter converter2 = from -> "fkit.org".indexOf(from);
1
2
Integer value = converter2.convert("it");
System.out.println(value); // 输出2
1
2
// 方法引用代替Lambda表达式，引用特定对象的实例方法
// 函数式接口中被实现的全部参数传给该方法作为参数
Converter converter2 = "fkit.org"::indexOf;
1
2
3
3.引用某类对象的实例方法

@FunctionalInterface
interface MyTest
{
String test(String a , int b , int c);
}
//下面代码使用Lambda表达式创建MyTest对象
MyTest mt = (a , b , c) -> a.substring(b , c);

String str = mt.test("Java I Love you" , 2 , 9);
System.out.println(str); // 输出:va I Lo
// 方法引用代替Lambda表达式，引用某类对象的实例方法
// 函数式接口中被实现的第一个参数作为调用者
//后面的参数全部传递给该方法作为参数
MyTest mt = String::substring;
引用构造器
@FunctionalInterface
interface YourTest
{
JFrame win(String title);
}
// 下面代码使用Lambda表达式创建YourTest对象
YourTest yt = (String a) -> new JFrame(a);

JFrame jf = yt.win("我的窗口");
System.out.println(jf);

//构造器引用代替Lambda表达式
// 函数式接口中被实现的全部参数传给该构造器作为参数
YourTest yt = JFrame::new;

4. Lambda表达式与匿名内部类的联系与区别
Lambda表达式是匿名内部类的一种简化
相同点：

Lambda表达式与匿名内部类一样，都可以直接访问“effectively final”的局部变量，以及外部类的成员变量。
Lambda表达式与匿名内部类创建的对象一样，都可以直接调用从接口中继承的默认方法
不同之处：
匿名内部类可以为任何接口创建实例——不管接口包含多少个抽象方法，只要匿名内部类实现了所有抽象方法即可；但 Lambda表达式只能为函数式接口创建对象
匿名内部类可以为抽象类甚至普通类创建对象
匿名内部类实现的抽象方法的方法体允许调用接口中的默认方法；但 Lambda表达式的代码块不允许调用接口中的默认方法
5. 使用 Lambda表达式调用Arrays的类方法

public class LambdaArrays
{
public static void main(String[] args)
{
String[] arr1 = new String[]{"java" , "fkava" , "fkit", "ios" , "android"};
Arrays.parallelSort(arr1, (o1, o2) -> o1.length() - o2.length());
System.out.println(Arrays.toString(arr1));
int[] arr2 = new int[]{3, -4 , 25, 16, 30, 18};
// left代表素组中前一个索引处的元素，计算第一个元素时，left为1
// right代表素组中当前索引处的元素
Arrays.parallelPrefix(arr2, (left, right)-> left * right);
System.out.println(Arrays.toString(arr2));
long[] arr3 = new long[5];
// operand代表正在计算的元素索引
Arrays.parallelSetAll(arr3 , operand -> operand * 5);
System.out.println(Arrays.toString(arr3));
}