java8之Lambda表达式

在软件工程，一个众所周知的问题就是，用户的需求不断的在变化

这里我举个例子：比如有一个员工类Employee 和员工列表

   	@Data
    @AllArgsConstructor
    @NoArgsConstructor
    @EqualsAndHashCode
    public class Employee {
    
    	private int id;
    	private String name;
    	private int age;
    	private double salary;
    
    }

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

现在我的需求是需要获取小于35岁的员工信息 很简单我们只需要遍历列表然后筛选

	/**
	 * 获取小于35岁的员工
	 * @param emps
	 * @return
	 */
	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 的员工信息 这时我们需要复制粘贴然后把其中的判断改成

if(emp.getSalary() >= 5000){
	...
}

行吧 。如果调皮的我现在想获取小于35岁并且工资大于5000的呢？ 又是复制粘贴改条件？这也太笨拙了把！

这时为了解决这种笨拙的办法…就可以提出一个概念叫做行为参数化
什么叫做行为参数化？

行为参数化，就是可以帮助我们处理频繁变化需求的一种软件开发模式，通俗的说，就是拿出一个代码块，把它准备好，却不去执行它。这个代码块以后可以被程序的其他部分调用，这就意味着我们可以推迟这块代码的执行。

我们可以把我们需要不断变化的需求封装成方法 然后定义成接口 我们可以对接口进行不同的实现
有了这个想法之后 我们可以这样做 ：

先定义一个接口：

@FunctionalInterface // 表明这是一个函数式接口 就是只有一个抽象方法的接口
public interface MyPredicate<T> {

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

现在我们已经做了一个很酷的事情 filterEmployee方法的行为取决于 我们对MyPredicate实现传递过去的代码 这时我们已经将filterEmployee方法的行为参数化

比如: 当我需要筛选出id小于103的员工我们只需要定义一个下面的实现然后传递过去

class FilterAgeEmployee implements MyPredicate<Employee>{

		@Override
		public boolean test(Employee e) {
			return t.getId() <= 103;
		}
	}

当我们再需要小于40岁的员工我们只需要再定义一个实现传递过去就行了 对了 上面的做法也太傻了吧
为什么还要另外写个类呢？这些类作为行为往往只需要实例化一次 我们可以用匿名内部类进行改造

List<Employee> list = filterEmployee(emps, new MyPredicate<Employee>() {
		@Override
		public boolean test(Employee t) {
			return t.ge;
		}
});

其实平时写java程序的时候已经在很多地方运用到了行为参数化
比如当我们实现多线程的时候我们只需要实现Runnable的run方法表示稍后执行的一段代码然后传递给Thread交给他执行 这时我们可以说thread需要执行的行为被Runnable参数化

new Thread(new Runnable(){

	@Override
	public void run() {
		for (int i = 0; i < 520; i++) {
			System.out.println("wmh--wyy");
		}
	}
});

现在我们已经用行为参数化解决了之前需要复制粘贴的糟糕操作 但仔细想想 如果我们每次都用匿名内部类这种方式 传递代码 ，其实也十分啰嗦。我们根本不关心 new XXX(){
}这种模块代码 我们只关心其中的业务逻辑好吧

这个时候我们就引出了我们今天的主题 Lambda表达式

我们可以把Lambda表达式简洁的表示为可传递的匿名函数的一种方式
有了Lambda我们可以更方便的传递代码！！！
java8之前我们如果需要定义一个排序规则可能需要这样:

Comparator<Employee> comparator = new Comparator<Employee>() {

	@Override
	public int compare(Employee o1, Employee o2) {
		return o1.getAge() - o2.getAge();
	}
};

而java8有了lamada表示之后我他么就用一行代码好不(当然可以):

Comparator<Employee> comparator1 = (o1,o2) -> o1.getAge() - o2.getAge();

甚至可以这样(这种方法后面讲)

// 用了静态导包 方法引用
Comparator<Employee> comparator2 = comparing(Employee::getAge);

怎么样 简单不。。下面介绍一下Lambda语法：

其实就是对函数式接口实现的一种简写形式
任何函数是接口都可以用Lambda来表示他的实现
那么函数式接口是什么？
就是只有一个抽象方法的接口！！！！
比如上面的例子中我们自己写的MyPredicate接口就是函数式接口 我们就可以用Lambda来代替匿名内部类来对它实现

MyPredicate<Employee> predicate = e -> e.getAge() < 35; 

Lambda由3个部分组成

• 参数列表 其实就是函数接口中的参数
• 箭头 将参数列表和主体分开
• Lambda主体 其实就是方法体 将业务逻辑写在里面

语法格式一：无参数，无返回值

() -> System.out.println("Hello Lambda!")

对应的函数式接口比如Runnable接口

语法格式二：有一个参数，并且无返回值 (若只有一个参数，小括号可以省略不写)

x -> System.out.println(x)

对应的函数式接口

语法格式三：有两个以上的参数，有返回值，并且 Lambda 体中有多条语句

 (x, y) -> {
  			System.out.println("函数式接口");
  		return Integer.compare(x, y);
  	}

语法格式四：若 Lambda 体中只有一条语句， return 和 大括号都可以省略不写

(x, y) -> Integer.compare(x, y);

4，5对应的函数式接口:

我们可以看到在上文中Lambda 表达式的参数列表的数据类型都没有写出来，这是因为JVM编译器可以自己通过上下文推断出，数据类型，即“类型推断

这里提出一个细节：
在之前如果我们在匿名内部类中引用外部函数的变量时 这个变量必须是final的
而在lambda中也是需要的 只不过 java8 进行了优化 不用显示的声明final 但必须是事实上的fnal

至于为什么 final用来保证一致性:
如果外部函数局部变量发生变化后，匿名内部类是不知道的（因为他只是拷贝了局部变量的值，并不是直接使用的局部变量）。这里举个栗子：原先局部变量指向的是对象A，在创建匿名内部类后，匿名内部类中的成员变量也指向A对象。但过了一段时间局部变量的值指向另外一个B对象，但此时匿名内部类中还是指向原先的A对象。那么程序再接着运行下去，可能就会导致程序运行的结果与预期不同。
原文链接：https://blog.csdn.net/tianjindong0804/article/details/81710268

现在我们已经知道了Lamada表达式可以用来实现函数式接口

为了更好的运用stream流(后面说) java8的设计师已经为我们提供好了很多函数式接口比如下面这4个

  /**
     * Java8 内置的四大核心函数式接口
     * 
     * Consumer<T> : 消费型接口
     * 		void accept(T t);   实现:t -> System.out.println("wmh");
     * 
     * Supplier<T> : 供给型接口
     * 		T get();  实现:() ->  2;
     * 
     * Function<T, R> : 函数型接口
     * 		R apply(T t); 实现: t -> 2;
     * 
     * Predicate<T> : 断言型接口
     * 		boolean test(T t); 实现: t -> true;
     * 
     */

其实还有一个概念叫做方法引用 它用来简化Lambda表达式 可以被看作仅仅调用特定方法的Lambda的一种快捷写法，他的思想是 如果一个Lambda代表的只是“直接调用这个方法” 那最好还是直接用名称来代替他 而不是描述如何调用它
方法引用分为3类

1. 对象的引用 :: 实例方法名

2. 类名 :: 静态方法名

3. 类名 :: 实例方法名

下面举几个个例子比如:

对象的引用 :: 实例方法名
Lambda表达式 s -> System.out.println(s)

用方法引用来表示就可以写成 System.out :: println
类名 :: 静态方法名
Lambda表达式 (x, y) -> Integer.compare(x, y);

用方法引用来表示就可以写成 Integer::compare;
类名 :: 实例方法名
Lambda表达式 (s1,s2) -> s1.substring(s2)

用方法引用来表示就可以写成 String :: substring

类名 :: 实例方法名
Lambda表达式 (Employee e) -> e.getAge()

用方法引用来表示就可以写成 Employee :: getAge

简单来说有2条规则

• ①方法引用所引用的方法的参数列表与返回值类型，需要与函数式接口中抽象方法的参数列表和返回值类型保持一致！
• ②若Lambda 的参数列表的第一个参数，是实例方法的调用者，第二个参数(或无参)是实例方法的参数时，格式： ClassName::MethodName

构造函数引用 造器的参数列表，需要与函数式接口中参数列表保持一致！
比如:

这是接口中的方法

这是构造函数

我们就可以将

Function<String,Employee> function = s -> new Employee(s);

写成这样

Function<String, Employee> fun = Employee::new;