一、函数式编程思想概述
函数式编程看重的是拿什么东西做什么事，目的是得到结果。相对而言，面向对象指的是，找一个能解决这个事情的对象，调用对象的方法，来完成事情。
二、lambda表达式的标准格式：
组成：
- 一些参数
- 一个箭头
- 一段代码
格式：
(参数列表) -> {一些重写方法的代码};
() : 接口中抽象方法的参数列表，没有参数，就空着；有参数就写出参数，多个参数用逗号分隔。
-> : 传递的意思，把参数传递给方法体{}
{} : 重写接口的抽象方法的方法体
三、Lambda的使用前提
Lambda的语法非常简洁，完全没有面向对象复杂的束缚。但是使用时有几个问题需要特别注意：
- 使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。
无论是JDK内置的Runnable、Comparator接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时，才可以使用Lambda。 - 使用Lambda必须具有上下文推断。
也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为接口的实例。有且仅有一个抽象方法的接口，称为“函数式接口”。
四、例子
4.1 无参数无返回值例子
4.1.1 需求
- 给定一个厨师Cook接口，内含唯一的抽象方法makeFood,且无参数，无返回值
- 使用Lambda 的标准格式调用invokeCook方法，打印输出“吃饭啦！”字样。
4.1.2 代码
Cook.java : 定义一个厨师 Cook接口，内含唯一的抽象方法makeFood
public interface Cook {
//定义无参数无返回值的方法 makeFood
public abstract void makeFood();
}
Demo01Cook.java :
public class Demo01Cook {
public static void main(String[] args) {
//调用invoke方法，参数是Cook接口，传递Cook接口的匿名内部类对象
invokeCook(new Cook() {
@override
public void makeFood() {
System.out.println("吃饭了");
}
});
//使用Lambda表达式，简化匿名内部类的书写
invokeCook(() -> {
System.out.println("吃饭了");
});
}
//定义一个方法，参数传递Cook接口，方法内部调用Cook接口中的方法makeFood
public static void invokeCook(Cook cook){
cook.makeFood();
}
}
4.2 有参数有返回值例子(1)
4.2.1 需求
- 使用数组存储多个Person对象
- 对数组中的Person对象使用Arrays的sort方法通过年龄进行升序排序。
4.2.2 代码
Person.java : 创建person类
public class Person {
private String name;
private int age;
public Person(){
}
public Person(String name, int name){
this.name = name;
this.age = age;
}
@Override
public String toString(){
return "Person{" +
"name='" + name +'\'' +
", age=" + age + '}';
}
public String getName() {
return name;
}
public String setName(String name) {
this.name = name;
}
public String getAge() {
return age;
}
public String setAge(String name) {
this.age = age;
}
}
Demo01Arrays.java :
public class Demo01Arrays {
public static void main(String[] args) {
Person[] arr = {
new Person( name:"小明", age:38),
new Person( name:"小红", age:18),
new Person( name:"小白", age:19),
};
//对数组中的Person对象使用Arrays的sort方法通过年龄进行升序（前边-后边）排序
Arrays.sort(arr, new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
return o1.getAge() - o2.getAge();
}
});
//使用Lambda表达式，简化匿名内部类
Arrays.sort(arr, (Person o1, Person o2) ->{
return o1.getAge() - o2.getAge();
});
//遍历数组
for (Person p : arr) {
System.out.println(p);
}
}
}
4.3 有参数有返回值例子(2)
4.3.1 需求
- 给定一个计算器 Calculator 接口，内含抽象方法 calc 可以将两个int数字相加得到和值。
- 使用Lambda的标准格式调用invokeCalc方法，完成120和130的相加计算
4.3.2 代码
Calculator.java : 创建Calculator类
public interface Calculator {
public abstract int calc(int a, int b);
}
Demo01Calculator.java : 创建测试类
public class Demo01Calculator {
public static void main(String[] args) {
//调用invokeCalc方法，方法的参数是一个接口，可以使用匿名内部类
invokeCalc(a:10, b:20. new Calulator() {
@Override
public int calc(int a, int b) {
return a+b;
}
});
//调用invokeCalc方法，方法的参数是一个接口，可以使用匿名内部类
invokeCalc(a:10, b:20, (int a, int b) -> {
return a+b;
});
}
/*
定义一个方法；参数传递两个int类型的整数；参数传递Calculator接口；方法内部调用Calculator中的方法calc计算两个整数的和
*/
public static void invokeCalc(int a, int b, Calculator c){
int sum = c.cal(a,b);
System.out.println(sum);
}
}
五、Lambda表达式省略
Lambda表达式是可推导的，也是可以省略的，凡是根据上下文推导出来的内容，都可以省略书写
5.1 Lambda表达式省略规则
- （参数列表）：括号中参数列表的数据类型，可以省略不写
- （参数列表）：括号中的参数如果只有一个，那么类型和（）都可以省略
- （一些代码）：如果（）中的代码只有一行，无论是否有返回值，都可以省略（{},return,分号）
注意：要省略{},return,分号必须一起省略。
5.2 代码
5.2.1 【4.1省略】
//使用Lambda表达式
invokeCook(() -> {
System.out.println("吃饭了");
});
//省略写法
invokeCook(() -> System.out.println("吃饭了"));
5.2.2 【4.2省略】
//使用Lambda表达式
Arrays.sort(arr, (Person o1, Person o2) ->{
return o1.getAge() - o2.getAge();
});
//省略写法
Arrays.sort(arr, (o1, o2) -> o1.getAge() - o2.getAge());
5.2.3 【4.3省略】
//使用Lambda表达式
invokeCalc(a:10, b:20, (int a, int b) -> {
return a+b;
});
//省略写法
invokeCalc(a:120, b:130, (a, b) -> a+b);
参考: