一、为什么使用Lambda表达式？
Lambda是一个匿名函数，我们可以把Lambda表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。
二、Lambda表达式初识
下面我们来看一下几个Lambda表达式的例子：
-
从匿名类到Lambda的转换
Runnable r = new Runnable() { @Override public void run() { System.out.println("Hello World!" ); } };-
Lambda表达式
Runnable r1 = () -> System.out.println("Hello Lambda!");-
原来使用匿名内部类作为参数传递
TreeSet<String> ts2 = new TreeSet<>(new Comparator<String>(){ @Override public int compare(String o1, String o2) { return Integer.compare(o1.length(), o2.length()); } }); Lambda表达式作为参数传递
-
-
TreeSet<String> ts2=new TreeSet<>(
(o1,o2) -> Integer.compare(o1.lenrth(),o2.length())
);
三、Lambda表达式引入点
要求：现在有一个员工集合，要求按照员工的薪资、员工的年龄得到符合要求的员工集合。
首先，我们定义一个员工类，Employee.java
public class Employee {
private int id;
private String name;
private int age;
private double salary;
public Employee() {
}
public Employee(String name) {
this.name = name;
}
public Employee(String name, int age) {
this.name = name;
this.age = age;
}
public Employee(int id, String name, int age, double salary) {
this.id = id;
this.name = name;
this.age = age;
this.salary = salary;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
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;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
@Override
public String toString() {
return "Employee [id=" + id + ", name=" + name + ", age=" + age + ", salary=" + salary + "]";
}
}
第一种解决方案：也是我们比较常规思维，就是定义一个方法，对应要求得到指定的员工集合，这里我们就只看“获取公司中工资大于 5000 的员工信息”定义的方法如下：
public List<Employee> filterEmployeeSalary(List<Employee> emps){
List<Employee> list = new ArrayList<>();
for (Employee emp : emps) {
if(emp.getSalary() >= 5000){
list.add(emp);
}
}
return list;
}
然后每一种要求对应一种方法，但是这种会很冗余，本来就一个条件不同，但是要写这么多相同的代码。这样，我们就要来优化了，我们更好的思维就是通过设计模式来操作了。
第二种解决方案：利用设计模式中的策略模式来优化。
首先，我们定义一个接口
public interface MyPredicate<T> {
public boolean test(T t);
}
然后只要有一个要求，我就定义一个对应的类实现这个接口，这里依然是使用上述的要求：获取公司中工资大于 5000 的员工信息。
public class FilterEmployeeForSalary implements MyPredicate<Employee> {
@Override
public boolean test(Employee t) {
return t.getSalary() >= 5000;
}
}
然后定义一个方法。如下
public List<Employee> filterEmployee(List<Employee> emps, MyPredicate<Employee> mp){
List<Employee> list = new ArrayList<>();
for (Employee employee : emps) {
if(mp.test(employee)){
list.add(employee);
}
}
return list;
}
最后在测试代码里面匿名内部类。
@Test
public void test5(){
List<Employee> list = filterEmployee(emps, new MyPredicate<Employee>() {
@Override
public boolean test(Employee t) {
return t.getId() <= 103;
}
});
for (Employee employee : list) {
System.out.println(employee);
}
}
这样就能得到要求的员工集合了。
但是这样看来，还是有点冗余，因为每一个要求我都要创建一个类。所以，Lambda表达式就引入了。
第三种方案：引进Lambda表达式
@Test
public void test6(){
List<Employee> list = filterEmployee(emps, (e) -> e.getAge() <= 35);
list.forEach(System.out::println);
System.out.println("------------------------------------------");
List<Employee> list2 = filterEmployee(emps, (e) -> e.getSalary() >= 5000);
list2.forEach(System.out::println);
}
四、Lambda表达式语法
Lambda表达式在Java语言中引入了一个新的语法元素和操作符。这个操作符为“->”,该操作符被称为Lambda操作符或箭头操作符。它将Lambda分为两个部分：
左侧：指定了Lambda表达式需要的所有参数。
右侧：指定了Lambda体，即Lambda表达式要执行的功能。
1、语法格式一：无参数，无返回值
() -> System.out.println("Hello Lambda!");
示例代码：
@Test
public void test1(){
int num = 0;//jdk 1.7 前，必须是 final
Runnable r = new Runnable() {
@Override
public void run() {
System.out.println("Hello World!" + num);
}
};
r.run();
System.out.println("-------------------------------");
//无参无返回值
Runnable r1 = () -> System.out.println("Hello Lambda!");
r1.run();
}
2、语法格式二：有一个参数，并且无返回值
(x) -> System.out.println(x)
示例代码：
@Test
public void test2(){
Consumer<String> con = (x) -> System.out.println(x);
con.accept("你是大傻子！");
}
3、语法格式三：若只有一个参数，小括号可以省略不写
x -> System.out.println(x)
示例代码：
@Test
public void test2(){
Consumer<String> con = x -> System.out.println(x);
con.accept("你是大傻子！");
}
4、语法格式四：有两个以上的参数，有返回值，并且 Lambda 体中有多条语句
Comparator<Integer> com = (x, y) -> {
System.out.println("函数式接口");
return Integer.compare(x, y);
};
示例代码：
@Test
public void test3(){
Comparator<Integer> com = (x, y) -> {
System.out.println("函数式接口");
return Integer.compare(x, y);
};
}
5、语法格式五：若 Lambda 体中只有一条语句， return 和 大括号都可以省略不写
Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
示例代码：
@Test
public void test4(){
Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
}
6、 语法格式六：Lambda 表达式的参数列表的数据类型可以省略不写，因为JVM编译器通过上下文推断出，数据类型，即“类型推断”
(Integer x, Integer y) -> Integer.compare(x, y);
示例代码：
@Test
public void test5(){
// String[] strs;
// strs = {"aaa", "bbb", "ccc"};
//字符串数组定义时不能分两步写，这样写是因为类型推断。所以编译才能通过的。
List<String> list = new ArrayList<>();
// ArrayList<>的类型可以不用写，这样也是因为类型推断的。
show(new HashMap<>());
}
public void show(Map<String, Integer> map){
}
语法小总结：
上联：左右遇一括号省
下联：左侧推断类型省
横批：能省则省
五、类型推断（比较重要）
上述的语法六，Lambda表达式中的参数类型都是由编译器推断得出的。Lambda表达式中无需指定类型，程序依然可以编译，这是因为javac根据程序的上下文，在后台推断出了参数的类型。Lambda表达式的类型依赖于上下文环境，是由编译器推断出来的。这就是所谓的“类型推断”。
六、函数式接口
这里就稍微讲一下，下面的文章会详细讲解
1、什么是函数式接口？
（1）、只包含一个抽象方法的接口，称为函数式接口。
（2）、你可以通过Lambda表达式来创建该接口的对象。（若Lambda表达式抛出一个受检异常，那么该异常需要在目标接口的抽象方法上进行声明）。
（3）、我们可以在任意函数式接口上使用@FunctionalInterface注解，这样做可以检查它是否是一个函数式接口，同时javadoc也会包含一条声明，说明这个接口是一个函数式接口。
2、自定义函数式接口
示例代码：
@FunctionalInterface
public interface MyFun {
public Integer getValue(Integer num);
}
七、Lambda练习
1、调用Collecions.sort()方法，通过定制排序比较两个Employee（先按年龄比，年龄相同按姓名比），使用Lambda作为参数传递。
步骤一：先创建一个pojo
package com.nieshenkuan.pojo;
public class Employee {
private int id;
private String name;
private int age;
private double salary;
public Employee() {
}
public Employee(String name) {
this.name = name;
}
public Employee(String name, int age) {
this.name = name;
this.age = age;
}
public Employee(int id, String name, int age, double salary) {
this.id = id;
this.name = name;
this.age = age;
this.salary = salary;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
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;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public String show() {
return "测试方法引用！";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + id;
result = prime * result + ((name == null) ? 0 : name.hashCode());
long temp;
temp = Double.doubleToLongBits(salary);
result = prime * result + (int) (temp ^ (temp >>> 32));
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Employee other = (Employee) obj;
if (age != other.age)
return false;
if (id != other.id)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
if (Double.doubleToLongBits(salary) != Double.doubleToLongBits(other.salary))
return false;
return true;
}
@Override
public String toString() {
return "Employee [id=" + id + ", name=" + name + ", age=" + age + ", salary=" + salary + "]";
}
}
步骤二：事先声明一个emps员工集合
List<Employee> emps = Arrays.asList(
new Employee(101, "张三", 18, 9999.99),
new Employee(102, "李四", 59, 6666.66),
new Employee(103, "王五", 28, 3333.33),
new Employee(104, "赵六", 8, 7777.77),
new Employee(105, "田七", 38, 5555.55)
);
步骤三：测试实现要求
@Test
public void test1(){
Collections.sort(emps, (e1, e2) -> {
if(e1.getAge() == e2.getAge()){
return e1.getName().compareTo(e2.getName());
}else{
return -Integer.compare(e1.getAge(), e2.getAge());
}
});
for (Employee emp : emps) {
System.out.println(emp);
}
}
2、（1）、声明函数式接口，接口中声明抽象方法，public String getValue(String str);
(2)、声明类TestLambda，类中编写方法使用接口作为参数，将一个字符串转换成大写，并作为方法的返回值。
（3）、再将一个字符串的第2个和第4个索引位置进行截取子串。
步骤一：先声明一个函数式接口MyFunction，并接口中声明抽象方法，public String getValue(String str);
@FunctionalInterface
public interface MyFunction {
public String getValue(String str);
}
步骤二：编写一个方法处理字符串,这个方法在Lambda类中定义的。
//需求：用于处理字符串
public String strHandler(String str, MyFunction mf){
return mf.getValue(str);
}
步骤三：测试，实现具体的要求
@Test
public void test2(){
//这个是测试去除字符串的前后空格
String trimStr = strHandler("\t\t\t 你是大傻逼 ", (str) -> str.trim());
System.out.println(trimStr);
//这个是测试将字符串转换成大写的
String upper = strHandler("abcdef", (str) -> str.toUpperCase());
System.out.println(upper);
//截取字符串的指定索引的字符串
String newStr = strHandler("我大望江县威武", (str) -> str.substring(2, 5));
System.out.println(newStr);
}
3、（1）、声明一个带两个泛型的函数式接口，泛型类型为<T,R>T为参数，R为返回值。
（2）、接口中声明对应抽象方法
（3）、在TestLambda类中声明方法，使用接口作为参数，计算两个long型参数的和。
（4）、在计算两个long型参数的乘积。
步骤一：声明一个带两个泛型的函数式接口，泛型类型为<T,R>T为参数，R为返回值
public interface MyFunction2<T, R> {
public R getValue(T t1, T t2);
}
步骤二：编写一个方法，计算两个long型的数据
//需求：对于两个 Long 型数据进行处理
public void op(Long l1, Long l2, MyFunction2<Long, Long> mf){
System.out.println(mf.getValue(l1, l2));
}
步骤三：测试，并实现要求。
@Test
public void test3(){
//实现两个long型的数值的和
op(100L, 200L, (x, y) -> x + y);
//实现两个long型的数值的积
op(100L, 200L, (x, y) -> x * y);
}
