Java8新特性

Java8新特性-Lambda表达式

总结一下java8中的新特性lambda表达式

1 匿名函数

Lambda是一个匿名函数，可以理解为一段可以传递的代码（将代码像数据一样传递）；可以写出更简洁、更灵活的代码；作为一种更紧凑的代码风格，是Java语言表达能力得到提升。

有一个需求：获取公司中年龄小于 35 的员工信息、获取公司中工资大于 5000 的员工信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Employee {

	private int id;
	private String name;
	private int age;
	private double salary;
    // get/set/constructor...
}
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)
);

该需求最直接的实现方式，遍历筛选符合条件的员工

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

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

如果又增加一种筛选条件，岂不是又要增加一个方法，且很多代码都是重复的，我们来进行优化

优化方式一：策略模式改造

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 抽象接口
public interface MyPredicate<T> {
	public boolean test(T t);
}
// 按年龄筛选策略类
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;
	}
}
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
//优化方式一：策略设计模式
@Test
public void test4(){
    List<Employee> list = filterEmployee(emps, new FilterEmployeeForAge());
    // 获取小于 35 的员工信息
    for (Employee employee : list) {
        System.out.println(employee);
    }

    System.out.println("------------------------------------------");
	// 获取工资大于5000的员工信息
    List<Employee> list2 = filterEmployee(emps, new FilterEmployeeForSalary());
    for (Employee employee : list2) {
        System.out.println(employee);
    }
}
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;
}

优化方式二：匿名内部类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//优化方式二：匿名内部类
@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 表达式

1
2
3
4
5
6
7
8
9
10
11
//优化方式三：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);
}

优化方式四：Stream API

Stream API也是java8的新特性，为了保持这个例子的完整性，我也还是放在了这里，可以跳过，在了解完Stream API可以再回来看这个简单例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Test
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);
}

从上面的演变过程如下：

垃圾代码 --> 策略模式 --> 匿名内部类 --> Lambda表达式 --> Stream API

可以看出，lambda没有一句废话，直奔主题（我们的筛选条件），为我们减少了很多工作量

那么lambda语法如何使用呢？

2.Lambda 表达式语法

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
// 1.无参数，无返回值
@Test
public void test01(){
    Runnable runnable = () -> {
        System.out.println("Hello Lambda");
    };
}
// 2.有一个参数，无返回值
@Test
public void test02(){
    Consumer<String> consumer = (a) -> System.out.println(a);
    consumer.accept("我觉得还行！");
}
// 3.有一个参数，无返回值 （小括号可以省略不写）
@Test
public void test03(){
    Consumer<String> consumer = a -> System.out.println(a);
    consumer.accept("我觉得还行！");
}
// 4。有两个及以上的参数，有返回值，并且 Lambda 体中有多条语句
@Test
public void test04(){
    Comparator<Integer> comparator = (a, b) -> {
        System.out.println("比较接口");
        return Integer.compare(a, b);
    };
}
// 5.有两个及以上的参数，有返回值，并且 Lambda 体中只有1条语句 （大括号 与 return 都可以省略不写）
@Test
public void test05(){
    Comparator<Integer> comparator = (a, b) -> Integer.compare(a, b);
}

Lambda 表达式的参数列表的数据类型可以省略不写，因为JVM编译器通过上下文推断出，数据类型，即“类型推断”：(Integer a, Integer b) -> Integer.compare(a, b);

3.Lambda 表达式与函数式接口

函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。

函数式接口可以被隐式转换为 lambda 表达式。

MyFun接口是一个函数式接口，它接受一个输入Integer参数 num，返回一个Integer结果。

使用@FunctionalInterface将这个接口定义为函数式接口

1
2
3
4
5
// 增加@FunctionalInterface注解
@FunctionalInterface
public interface MyFun {
	public Integer getValue(Integer num);
}

需求：对一个数进行运算

1
2
3
4
5
6
7
8
9
10
11
12
//需求：对一个数进行运算
@Test
public void test6(){
    Integer num = operation(100, (x) -> x * x);
    System.out.println(num);

    System.out.println(operation(200, (y) -> y + 200));
}

public Integer operation(Integer num, MyFun mf){
    return mf.getValue(num);
}