新特性

一、Lambda表达式

import java.util.Comparator;
import java.util.function.Consumer;

public class LambdaTest {
    public static void main(String[] args) {

        // Lambda表达式
        // 本质：作为函数式接口的实例


        // 格式一：无参、无返回值
        Runnable runnable1 = new Runnable() {
            public void run() {
                System.out.println("Hello World!");
            }
        };
        runnable1.run();

        Runnable runnable2 = () -> {
            System.out.println("Hello World!");
        };
        runnable2.run();


        // 格式二：需要一个参数、无返回值
        Consumer<String> consumer1 = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        consumer1.accept("Hello World!");

        Consumer<String> consumer2 = (String s) -> {
            System.out.println(s);
        };
        consumer2.accept("Hello World!");


        // 格式三：数据类型可以省略，因为可由编译器推断得出，称为类型推断
        Consumer<String> consumer3 = (s) -> {
            System.out.println(s);
        };
        consumer3.accept("Hello World!");


        // 格式四：Lambda若只需要一个参数时，参数的小括号可以省略
        Consumer<String> consumer4 = s -> {
            System.out.println(s);
        };
        consumer4.accept("Hello World!");

        // 格式五：Lambda若只需要两个或两个以上的参数，多条执行语句，并且可以有返回值
        Comparator<Integer> comparator1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                System.out.println(o2);
                return o1.compareTo(o2);
            }
        };
        System.out.println(comparator1.compare(21, 25));

        Comparator<Integer> comparator2 = (o1, o2) -> {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };
        System.out.println(comparator2.compare(25, 21));


        // 格式六：当Lambda体只有一条语句时，return与大括号若有，都可以省略
        Comparator<Integer> comparator3 = (o1, o2) -> o1.compareTo(o2);
        System.out.println(comparator3.compare(21, 21));

    }
}

二、函数式接口

如果一个接口中，只声明了一个抽象方法，则此接口称为函数式接口。

// 内置的4大核心函数式接口

// 消费型接口 Consumer<T>    void accept(T t)
// 供给型接口 Supplier<T> T  get()
// 函数型接口 Function<T, R> R apply(T t)
// 断定型接口 Predicate<T>   boolean test(T t)


import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;

public class LambdaTest {
    public static void main(String[] args) {
        method1(500, new Consumer<Double>() {
            @Override
            public void accept(Double aDouble) {
                System.out.println(aDouble);
            }
        });
        // Lambda
        method1(500, money -> System.out.println(money));


        List<String> list = Arrays.asList("Beijing", "Tianjin", "Shanghai", "Guangzhou");
        List<String> filterString1 = filterString(list, new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.contains("Beijing");
            }
        });
        System.out.println(filterString1);
        // Lambda
        List<String> filterString2 = filterString(list, s -> s.contains("Beijing"));
        System.out.println(filterString2);
    }

    public static void method1(double money, Consumer<Double> consumer) {
        consumer.accept(money);
    }

    // 根据给定的规则，过滤集合中的字符串，此规则有Predicate的方法决定
    public static List<String> filterString(List<String> list, Predicate<String> predicate) {
        ArrayList<String> filterList = new ArrayList<>();
        for (String str : list) {
            if (predicate.test(str)) {
                filterList.add(str);
            }
        }
        return filterList;
    }

}

三、方法引用与构造器引用

四、Stream API

五、Optional类