JDK8新特性

①Lambda表达式
②streamAPI
③函数式接口（FunctionInterface）
④接口中可以写默认方法（default）和静态方法（static）
⑤移除永久代（JVM中），用元空间代替（本地硬盘中）。

jdk8 10大新特性： https://blog.csdn.net/ZytheMoon/article/details/89715618

注意：default权限修饰符只能在接口中使用，不能在类中使用。还有就是switch中的default。

复习：
权限修饰符：public > protect > default > private; 类中不写就是默认权限
public:公共的，所有都能访问
protect：本包内，子类
default：本包内，没有子类
private：本类中

Lambda表达式

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

函数式接口

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

Lambda表达式使用

写法 ：(参数列表)->{方法体};
-> 箭头运算符（Lambda运算符）

参数列表：
如果没有参数就用（）,有参数在（）中直接写形参名,不用写数据类型。如：（a,b）

方法体：
如果只有一句方法体，可以省略{}直接写；
如果只有返回值，可以省略{}和return，直接写返回值；
想省略return必须省略{}。
方法有多句时不能省略；

方法引用

实现方法体的时候引用其他的方法
如果实现函数式接口时，要实现的功能在其他的对象已经实现了，且参数类型列表一样，就可以用方法引用。
参数列表必须跟引用的方法参数列表一样，所以参数也不用写，就直接写引用

格式

引用静态方法：类名::方法名；
对象方法：对象名::方法名；
创建对象：类名::new；

例子

使用方法

public class Test{
	public static void main(String[] args) {
		T1 t1 = (a) -> {
			System.out.println(a+1);
		};
		t1.fun1(6);//抽象方法，lambda实现的内部类重写了
		t1.fun2("b");//default方法
		T1.fun3();//静态方法

		简写
		T2 t1 = (a) -> return a;
		T2 t2 = a -> a; t1 t2等价

		T2 t3 = () -> {
			System.out.println("哈哈哈")
		};
		T2 t4 = () -> System.out.println("哈哈哈"); t3 t4等价
		
		//方法引用，实现函数式接口，调用
		CompareInt ci1 = (x,y)->Integer.compare(x, y);
		CompareInt ci = Integer::compare;//这两句是等价的
		System.out.println(ci.getCompare(10, 11));
	}
}
@FunctionalInterface
interface T1{
	public void fun1(int x);
	
	default void fun2(String a) {
		System.out.println(a);
	}
	
	static void fun3() {
		System.out.println("static");
	}
}

interface CompareInt{
	int getCompare(int a,int b) ;
}

结果：

Lambda实现Callable接口，创建线程对象

public static void main(String[] args) throws Exception {
		FutureTask<Object> task = new FutureTask<>((Callable<Object>)()->{
			
			System.out.println(Thread.currentThread().getName());
			System.out.println("睡前");
			Thread.sleep(1000);
			System.out.println("睡后");
			return "哈哈哈哈哈，这是callable线程的返回值";
			
		});
//		System.out.println(task.get());//get方法会引起阻塞，一直等线程结束，可是还没开始呢，没办法获取到线程返回值，所以就会一直等
		new Thread(task).start();
		System.out.println(task.get());
	}

结果：

Lambda实现线程池创建callable对象

public static void main(String[] args) throws Exception {
		ExecutorService executorService = Executors.newFixedThreadPool(3);
		Future<String> future = executorService.submit((Callable<String>)()->{
			Thread.sleep(3000);
			System.out.println(Thread.currentThread().getName()+"执行了");
			return "结果";
		});
		System.out.println(future.get());
		
		executorService.shutdown();
	}

结果：三秒后输出

Lambda创建HashSet对象，用第三方比较器Comparator

Person实体类里就姓名年龄；
创建HashSet
TreeSet<Person> set = new TreeSet<>((a,b)->a.getAge()-b.getAge());

		set.add(new Person("123", 1));
		set.add(new Person("1wqe", 4));
		set.add(new Person("1dsa3", 3));
		set.add(new Person("1sad3", 2));
		for (Person person : set) {
			System.out.println(person);
		}