Lambda表达式引子

有一个员工类：

public class Employee {
	
	private String name;
	private int age;
	private double salary;
	
	public Employee(String name, int age, double salary) {
		this.name = name;
		this.age = age;
		this.salary = salary;
	}
	
	public String getName() {
		return name;
	}
	
	public int getAge() {
		return age;
	}
	
	public double getSalary() {
		return salary;
	}
	
	@Override
	public String toString() {
		return "Employee{" +
			"name='" + name + '\'' +
			", age=" + age +
			", salary=" + salary +
			'}';
	}
}

准备初始数据：

List<Employee> employeeList = Arrays.asList(
	new Employee("张三", 18, 7777),
	new Employee("李四", 38, 22222),
	new Employee("王五", 50, 33333),
	new Employee("赵六", 24, 8888),
	new Employee("钱大", 28, 9999)
);

初始需求：获取年龄大于 35 的员工

publi List<Employee> filterEmployeeAgeOver35(List<Employee> employeeList) {
	List<Employee> employees = new ArrayList<>(8);
	if (employeeList != null && !employeeList.isEmpty()) {
		for(Employee employee : employeeList) {
			if (employee.getAge() >= 35) {
				employees.add(employee);
			}
		}
	}
	return employees;
}

当然了， 35 应该用常量代替

需求变更：获取年龄大于 20 的员工

publi List<Employee> filterEmployeeAgeOver20(List<Employee> employeeList) {
	List<Employee> employees = new ArrayList<>(8);
	if (employeeList != null && !employeeList.isEmpty()) {
		for(Employee employee : employeeList) {
			if (employee.getAge() >= 20) {
				employees.add(employee);
			}
		}
	}
	return employees;
}

对方法进行重构：

publi List<Employee> filterEmployeeByAge(List<Employee> employeeList, int overAge) {
	List<Employee> employees = new ArrayList<>(8);
	if (employeeList != null && !employeeList.isEmpty()) {
		for(Employee employee : employeeList) {
			if (employee.getAge() >= overAge) {
				employees.add(employee);
			}
		}
	}
	return employees;
}

此时需求再次发生变更：获取工资大于 10000 的员工

publi List<Employee> filterEmployeeBySalary(List<Employee> employeeList, double overSalary) {
	List<Employee> employees = new ArrayList<>(8);
	if (employeeList != null && !employeeList.isEmpty()) {
		for(Employee employee : employeeList) {
			if (employee.getSalary() >= overSalary) {
				employees.add(employee);
			}
		}
	}
	return employees;
}

此时发现两个方法非常相似，且如果需求变的更加灵活复杂，如：
获取员工工资大于8000小于2000的员工；获取员工年龄小于35但工资大于10000的员工等等

为了继续优化，此时需要引入策略设计模式：

定义比较策略方法：

public interface MyEmployeeFilter<T> {
	
	boolean test(T t);
	
}

通过策略方法实现比较：

public List<Employee> filterEmployee(List<Employee> employeeList, MyEmployeeFilter<Employee> employeeFilter) {
	List<Employee> employees = new ArrayList<>(8);
	if (employeeList != null && !employeeList.isEmpty()) {
		for(Employee employee : employeeList) {
			if (employeeFilter.test(employee)) {
				employees.add(employee);
			}
		}
	}
	return employees;
}

那么不管是什么比较的需求，只需要实现 MyEmployeeFilter 接口即可， 不能的需求，实现不同的比较。

比如：

public class FileterEmployeeByAgeOver35 implements MyEmployeeFilter<Employee> {
	
	@Override
	public boolean test(Employee employee) {
		return employee.getAge() >= 35;
	}
	
}

如果不想每次都创建一个新的实现类，可以使用匿名内部类的方式：

List<Employee> employeeList = filterEmployee(employees, new MyEmployeeFilter<Employee>() {
	@Override
	public boolean test(Employee employee) {
		return employee.getAge() >= 35;
	}
});

使用 Lambda 表达式：

List<Employee> employees = filterEmployee(employeeList, (e) -> (e).getAge() >= 35);

Lambda 表达式相对于匿名内部类，代码更加简洁，更加可读

代码可参考lxmuse-jdk8-new-feature-lambda-01

赏

谢谢你请我吃糖果