Java8新特性

1、Lambda表达式

Lambda是一个匿名函数，可以理解为一段可以传递的代码（将代码像数据一样传递）；可以写出更简洁、更灵活的代码；作为一种更紧凑的代码风格，是Java语言表达能力得到提升。

匿名内部类：

@Test
public void test01(){
   
    //匿名内部类
    Comparator<Integer> comparator = new Comparator<Integer>() {
   
        @Override
        public int compare(Integer o1, Integer o2) {
   
            return Integer.compare(o1,o2);
        }

        @Override
        public boolean equals(Object obj) {
   
            return false;
        }
    };
    //调用
    TreeSet<Integer> set = new TreeSet<>(comparator);
}

Lambda写法：

@Test
public void test02(){
   
    // Lambda 表达式
    Comparator<Integer> comparator = (a, b) -> Integer.compare(a, b);

    TreeSet<Integer> set = new TreeSet<>(comparator);
}

Lambda语法：

• 操作符：->
• 左侧：参数列表
• 右侧：执行代码块 / Lambda 体

口诀：

• 写死小括号，拷贝右箭头，落地大括号
• 左右遇一括号省
• 左侧推断类型省

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

例如 Runnable接口：
public class Test02 {
   
	int num = 10; //jdk 1.7以前 必须final修饰
    
    @Test
    public void test01(){
   
        // 匿名内部类
        new Runnable() {
   
            @Override
            public void run() {
   
                // 在局部类中引用同级局部变量
                // 只读
                System.out.println("Hello Lambda" + num);
            }
        };
    }

    @Test
    public void test02(){
   
        // 语法糖
     	Runnable runnable = () -> {
   
         	System.out.println("Hello Lambda");
     	};
    }
}

b、有一个参数，无返回值

@Test
public void test03(){
   
    // 一个参数，没有返回值
    Consumer<String> consumer = (a) -> System.out.println(a);
    consumer.accept("Hello Lambda！");

    // 一个参数，没有返回值（小括号可以省略不写）
    Consumer<String> consumer1 = a -> System.out.println(a);
    consumer1.accept("Hello Lambda！");
}

c、有两个及以上的参数，有返回值

// 有两个及以上的参数，有返回值（并且 Lambda 体中有多条语句）
Comparator<Integer> comparator = (a, b) -> {
   
    System.out.println("比较接口");
    return Integer.compare(a, b);
};

// 测试
ArrayList<Integer> list = new ArrayList<>();
list.add(3);
list.add(2);
list.add(1);
System.out.println(list); // [3, 2, 1]
list.sort(comparator);
System.out.println(list); // [1, 2, 3]

// 有两个及以上的参数，有返回值，并且 Lambda 体中只有1条语句 （大括号 与 return 都可以省略不写）
Comparator<Integer> comparator = (a, b) -> Integer.compare(a, b);

2、函数式接口

java给我们提供了很多预置好的接口（各种参数和返回值），不用我们自己定义，方便使用。

函数式接口	参数类型	返回类型	用途
Consumer 消费型接口	T	void	对类型为T的对象应用操作：void accept(T t)
Supplier 提供型接口	无	T	返回类型为T的对象：T get()
Function<T, R> 函数型接口	R	void	对类型为T的对象应用操作，并返回结果为R类型的对象：R apply(T t)
Predicate 断言型接口	T	boolean	确定类型为T的对象是否满足某约束，并返回boolean值：boolean test(T t)

a、Consumer 消费型接口（有去无回）

    @Test
    public void test01(){
   
        //Consumer
        Consumer<Integer> consumer = (x) -> System.out.println("消费型接口:" + x);
        //test
        consumer.accept(100);
    }

b、Supplier 提供型接口

没有参数，有返回

    @Test
    public void test02(){
   
        // Supplier
        Supplier<ArrayList<String>> supplier = () -> {
   
            ArrayList<String> list = new ArrayList<>();
            list.add("test");