重学JDK8新特性之Lambda、函数式接口、接口新增方法、方法引用Lambda表达式需求分析创建一个新的线程，指定

Lambda表达式

需求分析

创建一个新的线程，指定线程要执行的任务

public static void main(String[] args) {
	// 开启一个新的线程
	new Thread(new Runnable() {
		@Override
		public void run() {
			System.out.println("新线程中执行的代码 :"+Thread.currentThread().getName());
		}
	}).start();
	System.out.println("主线程中的代码：" + Thread.currentThread().getName());
}

其实本质就是需要一个Rannbale接口作为参数，其中的抽象方法run方法是用来指定线程任务内容的核心，但实际上，对于这个方法，其实只需要关注run方法体即可，其余的都不需要担心。

Lambda初体验

new Thread(() -> { System.out.println("新线程Lambda表达式..."+Thread.currentThread().getName()); })
.start();

可以清晰的看出，lambda简化了匿名内部类的使用，语法更加简单

Lambda语法规则

Lambda省去了面向对象的条条框框，Lambda的标准格式由3个部分组成：

(参数类型 参数名称) -> {
	代码体;
}

格式说明：

(参数类型参数名称):参数列表
{代码体;} :方法体
-> : 箭头，分割参数列表和方法体

@FunctionalInterface注解

lambda简化了匿名内部类的基本操作，本质上是有限制的，那就是对应的匿名内部类中只能声明一个抽象方法

故使用@FunctionalInterface去声明接口

@FunctionalInterface
public interface UserService {
	void show();
}

Lambda表达式的省略写法

在lambda表达式的标准写法基础上，可以使用省略写法的规则为：

小括号内的参数类型可以省略
如果小括号内有且仅有一个参数，则小括号可以省略
如果大括号内有且仅有一个语句，可以同时省略大括号，return 关键字及语句分号。

public static void main(String[] args) {
	goStudent((String name,Integer age)->{
		return name+age+" 6666 ...";
	});
	// 省略写法
	goStudent((name,age)-> name+age+" 6666 ...");
	System.out.println("------");
	goOrder((String name)->{
		System.out.println("--->" + name);
		return 666;
	});
	// 省略写法
	goOrder(name -> {
		System.out.println("--->" + name);
	return 666;
	});
	goOrder(name -> 666);
}
public static void goStudent(StudentService studentService){
	studentService.show("张三",22);
}
public static void goOrder(OrderService orderService){
	orderService.show("李四");
}

Lambda表达式的使用前提

Lambda表达式的语法是非常简洁的，但是Lambda表达式不是随便使用的，使用时有几个条件要特别注意

方法的参数或局部变量类型必须为接口才能使用Lambda
接口中有且仅有一个抽象方法(@FunctionalInterface)

Lambda和匿名内部类的对比

所需类型不一样

匿名内部类的类型可以是类，抽象类，接口

Lambda表达式需要的类型必须是接口

抽象方法的数量不一样

匿名内部类所需的接口中的抽象方法的数量是随意的

Lambda表达式所需的接口中只能有一个抽象方法

接口新增方法

针对JDK8来讲，在这之前接口中只有静态常量和抽象方法

在jdk8之后，接口中可以有默认方法和静态方法

默认方法

在JDK8以前接口中只能有抽象方法和静态常量，会存在以下的问题：如果接口中新增抽象方法，那么实现类都必须要抽象这个抽象方法，非常不利于接口的扩展的

如果在接口中定义了默认方法的话，就能有效的解决这个问题

interface A{
	void test1();
	// 接口中新增抽象方法，所有实现类都需要重写这个方法，不利于接口的扩展
	void test2();
	/**
	* 接口中定义的默认方法
	* @return
	*/
	public default String test3(){
		System.out.println("接口中的默认方法执行了...");
		return "hello";
	}
}
class B implements A{
	@Override
	public void test1() {
	}
	@Override
	public void test2() {
	}
	@Override
	public String test3() {
		System.out.println("B 实现类中重写了默认方法...");
		return "ok ...";
	}
}
class C implements A{
	@Override
	public void test1() {
	}
	@Override
	public void test2() {
	}
}

接口中的默认方法有两种使用方式

实现类直接调用接口的默认方法
实现类重写接口的默认方法

静态方法

JDK8中为接口新增了静态方法，作用也是为了接口的扩展

public static void main(String[] args) {
	A a = new B();
	a.test3();
	A c = new C();
	c.test3();
	A.test4();
}
interface A{
	void test1();
	// 接口中新增抽象方法，所有实现类都需要重写这个方法，不利于接口的扩展
	void test2();
	/**
	* 接口中定义的默认方法
	* @return
	*/
	public default String test3(){
		System.out.println("接口中的默认方法执行了...");
		return "hello";
	}
	/**
	* 接口中的静态方法
	* @return
	*/
	public static String test4(){
		System.out.println("接口中的静态方法....");
		return "Hello";
	}
}
class B implements A{
	@Override
	public void test1() {
	}
	@Override
	public void test2() {
	}
	@Override
	public String test3() {
		System.out.println("B 实现类中重写了默认方法...");
		return "ok ...";
	}
}
class C implements A{
	@Override
	public void test1() {
	}
	@Override
	public void test2() {
	}
}

接口中的静态方法在实现类中是不能被重写的，调用的话只能通过接口类型来实现: 接口名.静态方法名();

两者的区别介绍

默认方法通过实例调用，静态方法通过接口名调用
默认方法可以被继承，实现类可以直接调用接口默认方法，也可以重写接口默认方法
静态方法不能被继承，实现类不能重写接口的静态方法，只能使用接口名调用

函数式接口

首先说一下，我个人认为，这个地方可能和Stream流式接口有关。

我们知道使用Lambda表达式的前提是需要有函数式接口，而Lambda表达式使用时不关心接口名，抽象方法名。只关心抽象方法的参数列表和返回值类型。因此为了让我们使用Lambda表达式更加的方法，在JDK中提供了大量常用的函数式接口

例如假如自己封装一个函数式接口：

public static void main(String[] args) {
	fun1((arr)->{
		int sum = 0 ;
		for (int i : arr) {
			sum += i;
		}
		return sum;
	});
}
public static void fun1(Operator operator){
	int[] arr = {1,2,3,4};
	int sum = operator.getSum(arr);
	System.out.println("sum = " + sum);
}
/**
* 函数式接口
*/
@FunctionalInterface
interface Operator{
	int getSum(int[] arr);
}

函数式接口介绍

在JDK中帮我们提供的有函数式接口，主要是在 java.util.function 包中。

Supplier

无参有返回值的接口，对于的Lambda表达式需要提供一个返回数据的类型。

@FunctionalInterface
public interface Supplier<T> {
	/**
	* Gets a result.
	*
	* @return a result
	*/
	T get();
}

使用

public static void main(String[] args) {
	fun1(()->{
		int arr[] = {22,33,55,66,44,99,10};
		// 计算出数组中的最大值
		Arrays.sort(arr);
		return arr[arr.length-1];
	});
}
private static void fun1(Supplier<Integer> supplier){
	// get() 是一个无参的有返回值的 抽象方法
	Integer max = supplier.get();
	System.out.println("max = " + max);
}

Consumer

有参无返回值得接口,前面介绍的Supplier接口是用来生产数据的，而Consumer接口是用来消费数据的，使用的时候需要指定一个泛型来定义参数类型

@FunctionalInterface
public interface Consumer<T> {
	/**
	* Performs this operation on the given argument.
	*
	* @param t the input argument
	*/
	void accept(T t);
}

使用：将输入的数据统一转换为小写输出

public class ConsumerTest {
	public static void main(String[] args) {
		test(msg -> {
			System.out.println(msg + "-> 转换为小写：" + msg.toLowerCase());
		});
	}
	public static void test(Consumer<String> consumer){
		consumer.accept("Hello World");
	}
}

默认方法:andThen 如果一个方法的参数和返回值全部是Consumer类型，那么就可以实现效果，消费一个数据的时候，首先做一个操作，然后再做一个操作，实现组合，而这个方法就是Consumer接口中的default方法andThen方法

public static void main(String[] args) {
	test2(msg1->{
		System.out.println(msg1 + "-> 转换为小写：" + msg1.toLowerCase());
	},msg2->{
		System.out.println(msg2 + "-> 转换为大写：" + msg2.toUpperCase());
	});
}
public static void test2(Consumer<String> c1,Consumer<String> c2){
	String str = "Hello World";
	//c1.accept(str); // 转小写
	//c2.accept(str); // 转大写
	//c1.andThen(c2).accept(str);
	c2.andThen(c1).accept(str);
}

Function

有参有返回值的接口，Function接口是根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件。有参数有返回值。

@FunctionalInterface
public interface Function<T, R> {
	/**
	* Applies this function to the given argument.
	*
	* @param t the function argument
	* @return the function result
	*/
	R apply(T t);
}

使用：传递进入一个字符串返回一个数字

public static void main(String[] args) {
	test(msg ->{
		return Integer.parseInt(msg);
	});
}
public static void test(Function<String,Integer> function){
	Integer apply = function.apply("666");
	System.out.println("apply = " + apply);
}

默认方法：andThen，也是用来进行组合操作

public static void main(String[] args) {
	test(msg ->{
		return Integer.parseInt(msg);
	},msg2->{
		return msg2 * 10;
	});
}
public static void test(Function<String,Integer>
f1,Function<Integer,Integer> f2){
	/*Integer i1 = f1.apply("666");
	Integer i2 = f2.apply(i1);*/
	Integer i2 = f1.andThen(f2).apply("666");
	System.out.println("i2:" + i2);
}

默认的compose方法的作用顺序和andThen方法刚好相反

Predicate

有参且返回值为Boolean的接口

@FunctionalInterface
public interface Predicate<T> {
	/**
	* Evaluates this predicate on the given argument.
	*
	* @param t the input argument
	* @return {@code true} if the input argument matches the predicate,
	* otherwise {@code false}
	*/
	boolean test(T t);
}

使用：

public static void main(String[] args) {
	test(msg -> {
		return msg.length() > 3;
	},"HelloWorld");
}
private static void test(Predicate<String> predicate,String msg){
	boolean b = predicate.test(msg);
	System.out.println("b:" + b);
}

在Predicate中的默认方法提供了逻辑关系操作 and or negate isEquals方法

public static void main(String[] args) {
	test(msg1 -> {
		return msg1.contains("H");
	},msg2 -> {
		return msg2.contains("W");
	});
}
private static void test(Predicate<String> p1,Predicate<String> p2){
	/*boolean b1 = predicate.test(msg);
	boolean b2 = predicate.test("Hello");*/
	// b1 包含H b2 包含W
	// p1 包含H 同时 p2 包含W
	boolean bb1 = p1.and(p2).test("Hello");
	// p1 包含H 或者 p2 包含W
	boolean bb2 = p1.or(p2).test("Hello");
	// p1 不包含H
	boolean bb3 = p1.negate().test("Hello");
	System.out.println(bb1); // FALSE
	System.out.println(bb2); // TRUE
	System.out.println(bb3); // FALSE
}

方法引用

lambda表达式冗余

在使用Lambda表达式的时候，也会出现代码冗余的情况，比如：用Lambda表达式求一个数组的和

public static void main(String[] args) {
	printMax(a->{
		// Lambda表达式中的代码和 getTotal中的代码冗余了
		int sum = 0;
		for (int i : a) {
			sum += i;
		}
		System.out.println("数组之和：" + sum);
	});
}
/**
* 求数组中的所有元素的和
* @param a
*/
public void getTotal(int a[]){
	int sum = 0;
	for (int i : a) {
		sum += i;
	}
	System.out.println("数组之和：" + sum);
}
private static void printMax(Consumer<int[]> consumer){
	int[] a= {10,20,30,40,50,60};
	consumer.accept(a);
}

因为在Lambda表达式中要执行的代码和我们另一个方法中的代码是一样的，这时就没有必要重写一份逻辑了，这时我们就可以“引用”重复代码

public class FunctionRefTest02 {
	public static void main(String[] args) {
	// :: 方法引用 也是JDK8中的新的语法
		printMax(FunctionRefTest02::getTotal);
	}
	/**
	* 求数组中的所有元素的和
	* @param a
	*/
	public static void getTotal(int a[]){
		int sum = 0;
		for (int i : a) {
			sum += i;
		}
		System.out.println("数组之和：" + sum);
	}
	private static void printMax(Consumer<int[]> consumer){
		int[] a= {10,20,30,40,50,60};
		consumer.accept(a);
	}
}

:: 方法引用也是JDK8中的新的语法

方法引用的格式

符号表示： :: 符号说明：双冒号为方法引用运算符，而它所在的表达式被称为方法引用应用场景：如果Lambda表达式所要实现的方案，已经有其他方法存在相同的方案，那么则可以使用方法引用。常见的引用方式：方法引用在JDK8中使用是相当灵活的，有以下几种形式：

instanceName::methodName 对象::方法名
ClassName::staticMethodName 类名::静态方法
ClassName::methodName 类名::普通方法
ClassName::new 类名::new 调用的构造器
TypeName[]::new String[]::new 调用数组的构造器

对象名::方法名

这是最常见的一种用法。如果一个类中的已经存在了一个成员方法，则可以通过对象名引用成员方法

public static void main(String[] args) {
	Date now = new Date();
	Supplier<Long> supplier = ()->{return now.getTime();};
	System.out.println(supplier.get());
	// 然后我们通过 方法引用 的方式来处理
	Supplier<Long> supplier1 = now::getTime;
	System.out.println(supplier1.get());
}

方法引用的注意事项：

被引用的方法，参数要和接口中的抽象方法的参数一样
当接口抽象方法有返回值时，被引用的方法也必须有返回值

类名::静态方法名

也是比较常用的方式：

public static void main(String[] args) {
	Supplier<Long> supplier1 = ()->{
		return System.currentTimeMillis();
	};
	System.out.println(supplier1.get());
	// 通过 方法引用 来实现
	Supplier<Long> supplier2 = System::currentTimeMillis;
	System.out.println(supplier2.get());
}

类名::引用实例方法

Java面向对象中，类名只能调用静态方法，类名引用实例方法是用前提的，实际上是拿第一个参数作为方法的调用者

public static void main(String[] args) {
	Function<String,Integer> function = (s)->{
		return s.length();
	};
	System.out.println(function.apply("hello"));
	// 通过方法引用来实现
	Function<String,Integer> function1 = String::length;
	System.out.println(function1.apply("hahahaha"));
}

类名::构造器

由于构造器的名称和类名完全一致，所以构造器引用使用 ::new 的格式使用，

public static void main(String[] args) {
	Supplier<Person> sup = ()->{return new Person();};
	System.out.println(sup.get());
	// 然后通过 方法引用来实现
	Supplier<Person> sup1 = Person::new;
	System.out.println(sup1.get());
}

数组::构造器

数组是怎么构造出来的呢？

public static void main(String[] args) {
	Function<Integer,String[]> fun1 = (len)->{
		return new String[len];
	};
	String[] a1 = fun1.apply(3);
	System.out.println("数组的长度是：" + a1.length);
	// 方法引用 的方式来调用数组的构造器
	Function<Integer,String[]> fun2 = String[]::new;
	String[] a2 = fun2.apply(5);
	System.out.println("数组的长度是：" + a2.length);
}

小结：方法引用是对Lambda表达式符合特定情况下的一种缩写方式，它使得我们的Lambda表达式更加的精简，也可以理解为lambda表达式的缩写形式，不过要注意的是方法引用只能引用已经存在的方法。