Lambda表达式的使用

1、为什么使用 Lambda 表达式

• Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。
• 从匿名类到 Lambda 的转换

// 匿名内部类
Runnable runnable = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello World"); 
    }
};

// lambda表达式
Runnable runnable = () -> System.out.println("Hello World");

// 使用匿名内部类作为参数传递
TreeSet<String> treeSet = new TreeSet<>(new Comparator<String>() {
    @Override
    public int compare(String o1, String o2) {
        return Integer.compare(o1.length(),o2.length());
    }
});

// 现在的 Lambda 表达式
Comparator<String> com = (x, y) -> Integer.compare(x.length(), y.length());
TreeSet<String> ts = new TreeSet<>(com);

2、Lambda 表达式语法

Lambda 表达式在Java 语言中引入了一个新的语法元素和操作符。这个操作符为 ->， 该操作符被称为 Lambda 操作符或剪头操作符。它将 Lambda 分为

两个部分：

• 左侧：指定了 Lambda 表达式需要的所有参数
• 右侧：指定了 Lambda 体，即 Lambda 表达式要执行的功能。

1、Lambda 需要两个参数，并且有返回值

• 无参，无返回值，Lambda 体只需一条语句

Runnable runnable = () -> System.out.println("Hello World");

2、Lambda 需要一个参数

• Lambda 需要一个参数

Consumer<String> fun = (arg) -> System.out.println(arg);

3、Lambda 只需要一个参数时，参数的小括号可以省略

• Lambda 只需要一个参数时，参数的小括号可以省略

Consumer<String> fun = arg -> System.out.println(arg);

4、Lambda 需要两个参数，并且有返回值

• Lambda 需要两个参数，并且有返回值

BinaryOperator<Long> binaryOperator = (Long x,Long y) -> {
    return x + y;
};

// 数据类型可以省略，因为可由编译器推断得出，称为“类型推断”
BinaryOperator<Long> binaryOperator = (x,y) -> {
    return x + y;
};

5、当 Lambda 体只有一条语句时，return 与大括号可以省略

• 当 Lambda 体只有一条语句时，return 与大括号可以省略

BinaryOperator<Long> binaryOperator = (x,y) -> x + y;

3、类型推断

​ 上述 Lambda 表达式中的参数类型都是由编译器推断得出的。Lambda 表达式中无需指定类型，程序依然可以编译，这是因为 javac 根据程序的上下文，在后台推断出了参数的类型。Lambda 表达式的类型依赖于上下文环境，是由编译器推断出来的。这就是所谓的类型推断.

4、案例

1、Employee类

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;
	}
}

2、初始化数据

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)
);

3、获取公司中年龄小于 35 的员工信息

// 获取公司中年龄小于 35 的员工信息
public List<Employee> filterEmployeeAge(List<Employee> emps){
    List<Employee> list = new ArrayList<>();

    for (Employee emp : emps) {
        if(emp.getAge() <= 35){
            list.add(emp);
        }
    }
    return list;
}

public void test3(){
    List<Employee> list = filterEmployeeAge(emps);
    for (Employee employee : list) {
        System.out.println(employee);
    }
}

// 获取公司中工资大于 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;
}

4、优化方式一：策略设计模式

@FunctionalInterface
public interface MyPredicate<T> {
	public boolean test(T t);
}

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;
}

public class FilterEmployeeForAge implements MyPredicate<Employee>{
	@Override
	public boolean test(Employee t) {
		return t.getAge() <= 35;
	}
}

public class FilterEmployeeForSalary implements MyPredicate<Employee> {
	@Override
	public boolean test(Employee t) {
		return t.getSalary() >= 5000;
	}
}

public void test4(){
    List<Employee> list = filterEmployee(emps, new FilterEmployeeForAge());
    for (Employee employee : list) {
        System.out.println(employee);
    }

    System.out.println("------------------------------------------");

    List<Employee> list2 = filterEmployee(emps, new FilterEmployeeForSalary());
    for (Employee employee : list2) {
        System.out.println(employee);
    }
}

5、优化方式二：匿名内部类

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);
    }
}

 不好理解的话，下面代码是filterEmployee方法内部执行逻辑

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;
}

6、优化方式三：Lambda 表达式

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);
}

  不好理解的话，下面代码是filterEmployee方法内部执行逻辑

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;
}

7、优化方式四：Stream API

public void test7(){
    emps.stream()
        .filter((e) -> e.getAge() <= 35)
        .forEach(System.out::println);

    System.out.println("----------------------------------------------");

    emps.stream()
        .map(Employee::getName)
        .limit(3)
        .sorted()
        .forEach(System.out::println);
}

5、Lambda例子分析

 1、优化线程代码

以前我们使用线程可能是这么使用的：

new Thread(new Runnable(){
    @Override
    public void run() {
        System.out.println("thread run");
    }
}).start();

使用lambda可以这么使用：

new Thread(()->{
     System.out.println("thread run");
}).start();

上面的代码只有一行代码，可以再次进行优化写法：

new Thread( ()->System.out.println("thread run")).start();

2、Arrays.sort排序优化

在代码中，我们会使用Arrays.sort对数据进行排序，Arrays.sort是可以对数组、列表集合进行排序的，很多时候会使用的到。那么以前我们的写法是这样子的：

Integer[] playerScore = {89, 100, 77, 90,  86};
// 使用匿名内部类根据 分数从低到高进行排序
Arrays.sort(playerScore,new Comparator<Integer>(){
    /**
     *
     * @param o1 o1是后一个数，第一次比较就是100
     * @param o2 o2是前一个数，第一次比较就是89
     * @return 比较的返回值，第一次就是100.compareTo(89),返回值是1
     */
    @Override
    public int compare(Integer o1, Integer o2) {
        return o1.compareTo(o2);
    }
});
for(Integer score:playerScore){
//输出结果：77,86,89,90,100,
    System.out.print(score);
}

使用lambda可以这么使用：

Arrays.sort(playerScore,(Integer o1,Integer o2)->o1.compareTo(o2) );

类型Integer也可以去掉优化成：

Arrays.sort(playerScore,(o1,o2)->o1.compareTo(o2) );

再次优化还可以这么写：

Arrays.sort(playerScore,Comparator.comparing(Integer::intValue));

其中Integer::intValue（方法引用使用一对冒号 ::），就是Integer类中的方法intValue：

从高到底呢？

Arrays.sort(playerScore,Comparator.comparing(Integer::intValue).reversed());

3、List遍历

在java8之前对于List的遍历使用for循环的方式，在java8之后遍历打印就显得很简单了：

List<String> languages = Arrays.asList("java","php","python");
//java8 之前
for(String str:languages){
    System.out.print(str+",");
}

for(int i=0;i<languages.size();i++){
    System.out.print(languages.get(i)+",");
}

//java8之后
languages.forEach(language-> System.out.print(language+","));

4、Map遍历

Map<String,Object> map = new HashMap<>();
map.put("author","悟纤");
map.put("age","18");
map.put("blog","微信公众号「SpringBoot」");
map.put("hobby","美女");

//java8之前的方式：方法一 在for-each循环中使用entries来遍历（常用）
System.out.println("方法一 在for-each循环中使用entries来遍历:");
for(Map.Entry<String,Object> entry:map.entrySet()){
    System.out.println("key:"+entry.getKey()+",value:"+entry.getValue());
}

//java8之前的方式：方法二 在for-each循环中遍历keys或values。
System.out.println();
System.out.println("方法二 在for-each循环中遍历keys或values");
//遍历keys and value
for(String key:map.keySet()){
    System.out.println("key:"+key+",value:"+map.get(key));
}
//只遍历values
System.out.println("----------------");
for(Object value:map.values()){
    System.out.println("value:"+value);
}

//java8之前的方式：方法三使用Iterator遍历
System.out.println();
System.out.println("方法三使用Iterator遍历");
Iterator<Map.Entry<String,Object>> entryIterator = map.entrySet().iterator();
while(entryIterator.hasNext()){
    Map.Entry<String,Object> entry =  entryIterator.next();
    System.out.println("key:"+entry.getKey()+",value:"+entry.getValue());
}

//java8之后的方式
System.out.println("\njava8之后的方式");
map.forEach((key,value)->System.out.println("key:"+key+",value:"+value) );

对于对于Map如果没获取到key的话，我们会有一个默认值的显示，比如显示为“-”或者“无”，在java8这样的需求就简单的一匹：

//java8之前没有获取到key显示默认值为"-"
Object birthday = map.get("birthday");
if(birthday == null){
    birthday = "-";
}
System.out.println("birthday:"+birthday);

//java8之后的方式
System.out.println("birthday:"+map.getOrDefault("birthday","-"));