Lambda表达式

语法

() -> {}

() 是接口方法的括号，如果有参数，也需要写参数。只有一个参数时，括号可以省略。

-> 分割左右部分

{} 要实现的方法体，只有一行代码时，可以不加

概念

使用于lambda表达式的接口称之为函数型接口，函数型接口说白了就是一个抽象方法的接口。

基本语法

interface Test1Service{
    
	void sayMsg(String msg);
}

public class Test1 {
    

	public static void main(String[] args) {
    
		// TODO Auto-generated method stub
		Test1Service ts = msg -> System.out.println("test"+msg);
		ts.sayMsg("hello");
	}

}

注意事项

1. java8为函数式接口引入了一个新注解**@FunctionalInterface**，该注解主要用于编译级错误检查
2. 接口中包含了两个抽象方法的话，就违反了函数式接口的定义，IDE会直接报错
3. 函数式接口里可以包含默认方法，因为默认方法不是抽象方法，其有一个默认实现，所以是符合函数式接口的定义的
4. 函数式接口里可以包含静态方法，因为静态方法不能是抽象方法，是一个已经实现了的方法，所以是符合函数式接口的定义的
5. 函数式接口里可以包含Object里的public方法，因为任何一个函数式接口的实现，默认都继承了Object类，包含了来自java.lang.Object里对这些抽象方法的实现

进阶

方法引用

我们要实现接口的方法与另一个方法A类似，（这里的类似是指参数类型与返回值部分相同），我们直接声明A方法即可

方法引用的语法有三种：

1. 类::静态方法名
2. 类::实例方法名
3. 对象::实例方法名

interface Function{
    
	String sendMsg(Object o);
	
	@Override
	boolean equals(Object obj);
}

public class Test2 {
    

	public static void main(String[] args) {
    
		// TODO Auto-generated method stub
		Function f = String::valueOf;
		System.out.println(f.sendMsg(1));
		System.out.println(f.sendMsg('c'));
	}

}

构造引用

import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;

class Function3 {
    
	private int x;
	private String y;
	Function3(){
    
		x = 0;
		y = "hello";
	}
	Function3(int x){
    
		this.x = x;
		y = "hello";
	}
	Function3(int x,String y){
    
		this.x = x;
		this.y = y;
	}
	public int getX() {
    
		return x;
	}
	public void setX(int x) {
    
		this.x = x;
	}
	public String getY() {
    
		return y;
	}
	public void setY(String y) {
    
		this.y = y;
	}
	@Override
	public String toString() {
    
		return "Function3 [x=" + x + ", y=" + y + "]";
	}
}
	
public class Test3 {
    

	public static void main(String[] args) {
    
		// TODO Auto-generated method stub
		//无参
		Supplier<Function3> f1 = () -> new Function3();
		Function3 ft1 = f1.get();
		System.out.println(f1.toString());
		System.out.println(ft1);
		//单参
		Function<Integer, Function3> f2 = x -> new Function3(x);
		System.out.println(f2.apply(1));
		//双参
		BiFunction<Integer, String, Function3> f3 = (x,y) -> new Function3(x,y);
		System.out.println(f3.apply(1, "test"));
		
	}

}