1 Java8的概述

Java8是 Java 语言的一个重要版本，该版本于2014年3月发布，是自Java5以来最具革命性的版本，这个版本包含语言、编译器、库、工具和JVM等方面的十多个新特性。

2.1 函数式接口

函数式接口主要指只包含一个抽象方法的接口，如：java.lang.Runnable、java.util.Comparator 接口等。
Java8提供@FunctionalInterface注解来定义函数式接口，若定义的接口不符合函数式的规范便会报错。
Java8中增加了java.util.function包，该包包含了常用的函数式接口，具体如下：

接口名称	方法声明	功能介绍
Runnable	void run()	既没有参数又没有返回值的方法
Callable	V call()	没有参数有返回值的方法
Consumer	void accept(T t)	根据指定的参数执行操作
Supplier	T get()	得到一个返回值
Function<T,R>	R apply(T t)	根据指定的参数执行操作并返回
Comparator	int compare(T o1, T o2)	比较
Predicate	boolean test(T t)	判断指定的参数是否满足条件

2.1.1 匿名内部类实现函数式接口

/**
 * @Author 振帅
 * @Date 2021/05/31 22:22
 */
public class FunctionalInterfaceTest {
    public static void main(String[] args) {
        //1.匿名内部类：父类/接口类型 引用变量名 =  new 父类/接口类型(){ 方法重写 }
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("我是既没有参数又没有返回值的方法!");
            }
        };
        runnable.run();

        System.out.println("==================================");

        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println("有参但没有返回值的方法" + s);
            }
        };
        consumer.accept("hello world");

        System.out.println("==================================");

        Supplier<String> supplier = new Supplier<String>() {
            @Override
            public String get() {
                return "无参有返回值";
            }
        };
        System.out.println(supplier.get());

        System.out.println("==================================");

        Function<Integer,String> function = new Function<Integer, String>() {
            @Override
            public String apply(Integer integer) {
                return "有参有返回值" + integer;
            }
        };
        System.out.println(function.apply(1));

        System.out.println("==================================");

        Comparator<Integer> comparator = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return 0;
            }
        };
        System.out.println(comparator.compare(1,2));//0

        System.out.println("==================================");

        Predicate predicate = new Predicate() {
            @Override
            public boolean test(Object o) {
                return false;
            }
        };
        System.out.println(predicate.test("hello"));//false
    }
}

2.1.2 Lambda表达式实现函数式接口

语法格式：(参数列表) -> { 方法体; } - 其中()、参数类型、{} 以及return关键字可以省略。

/**
 * @Author 振帅
 * @Date 2021/05/31 22:22
 */
public class FunctionalInterfaceTest {
    public static void main(String[] args) {
        //1.匿名内部类：父类/接口类型 引用变量名 =  new 父类/接口类型(){ 方法重写 }
        Runnable runnable = () -> System.out.println("我是既没有参数又没有返回值的方法!");
        runnable.run();

        System.out.println("==================================");

        Consumer<String> consumer = s -> System.out.println("有参但没有返回值的方法" + s);
        consumer.accept("hello world");

        System.out.println("==================================");

        Supplier<String> supplier = () -> "无参有返回值";
        System.out.println(supplier.get());

        System.out.println("==================================");

        Function<Integer,String> function = integer -> "有参有返回值" + integer;
        System.out.println(function.apply(1));

        System.out.println("==================================");

        Comparator<Integer> comparator = (o1, o2) -> 0;
        System.out.println(comparator.compare(1,2));//0

        System.out.println("==================================");

        Predicate predicate = o -> false;
        System.out.println(predicate.test("hello"));//false
    }
}

2.1.3 方法引用实现函数式接口

方法引用主要指通过方法的名字来指向一个方法而不需要为方法引用提供方法体，该方法的调用交给函数式接口执行。
方法引用使用一对冒号 :: 将类或对象与方法名进行连接，通常使用方式如下：
- 对象的非静态方法引用 ObjectName :: MethodName
- 类的静态方法引用 ClassName :: StaticMethodName
- 类的非静态方法引用 ClassName :: MethodName
- 构造器的引用 ClassName :: new
- 数组的引用 TypeName[] :: new
方法引用是在特定场景下lambda表达式的一种简化表示，可以进一步简化代码的编写使代码更加紧凑简洁，从而减少冗余代码

（1）对象的非静态方法引用

对象的非静态方法引用 ObjectName :: MethodName

/**
 * @Author 振帅
 * @Date 2021/05/31 23:03
 */
public class MethodReferenceTest {

    public static void main(String[] args) {

        Person person = new Person("yangzhen",24);

        //1.使用匿名内部类的方式通过函数式接口Runable中的方法实现对Person类中的show方法调用
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                person.show();
            }
        };
        runnable.run();
        System.out.println("==================================");

        //2.使用lambda表达式的方式实现对Person类中的show方法调用
        Runnable runnable1 = () -> person.show();
        runnable1.run();
        System.out.println("==================================");

        //3.使用方法引用的方式对实现对Person类中的show方法调用
        Runnable runnable2 = person::show;
        runnable2.run();
        System.out.println("==================================");

        //4.使用匿名内部类的方式通过函数式接口Consumer中的方法实现对Person类中的setName方法调用
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                person.setName(s);
            }
        };
        consumer.accept("yangzhen2");
        System.out.println(person); // yangzhen2 24
        System.out.println("==================================");

        //5.使用lambda表达式的方式实现对Person类中的setName方法调用
        Consumer<String> consumer1 = s -> person.setName(s);
        consumer.accept("yangzhen3");
        System.out.println(person); // yangzhen3 24
        System.out.println("==================================");

        //6.使用方法引用的方式对实现对Person类中的setName方法调用
        Consumer<String> consumer2 = person::setName;
        consumer.accept("yangzhen4");
        System.out.println(person); // yangzhen4 24
    }

}

（2）类的静态方法引用

类的静态方法引用 ClassName :: StaticMethodName

/**
 * @Author 振帅
 * @Date 2021/05/31 23:43
 */
public class MethodReferenceTest {

    public static void main(String[] args) {

        //使用匿名内部类的方式通过函数式接口Comparator中的方法实现对Integer类中的compare方法调用
        Comparator<Integer> comparator = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        };
        System.out.println(comparator.compare(10,20)); //-1

        Comparator<Integer> comparator1 = (o1,o2) -> Integer.compare(o1,o2);
        System.out.println(comparator1.compare(10,20)); //-1

        Comparator<Integer> comparator2 = Integer::compare;
        System.out.println(comparator.compare(20,10)); //1

        //自定义返回
        Comparator<Integer> comparator3 = (o1, o2) -> {
           return o1 >= o2 ? o1:o2;
        };
        System.out.println(comparator3.compare(10,11)); //11
    }

}

（3）类的非静态方法引用

类的非静态方法引用 ClassName :: MethodName

其中一个参数对象作为调用对象来调用方法时,可以使用上述方式更抽象

/**
 * @Author 振帅
 * @Date 2021/05/31 23:43
 */
public class MethodReferenceTest {

    public static void main(String[] args) {

        //使用匿名内部类的方式
        Comparator<Integer> comparator4 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        };
        System.out.println(comparator4.compare(20,10)); //1

        Comparator<Integer> comparator5 = (o1, o2) -> o1.compareTo(o2);
        System.out.println(comparator5.compare(20,10)); //1
        
        //其中一个参数对象作为调用对象来调用方法时 更抽象
        Comparator<Integer> comparator6 = Integer::compareTo;
        System.out.println(comparator6.compare(10,20)); //-1
    }

}

（4）构造器的引用

构造器的引用 ClassName :: new

/**
 * @Author 振帅
 * @Date 2021/05/31 23:43
 */
public class MethodReferenceTest {

    public static void main(String[] args) {

        Supplier<Person> supplier = new Supplier<Person>() {
            @Override
            public Person get() {
                return new Person();
            }
        };
        System.out.println(supplier.get()); //Person{name='null', age=0}

        Supplier<Person> supplier1 = ()-> new Person();
        System.out.println(supplier1.get()); //Person{name='null', age=0}

        Supplier<Person> supplier2 = Person::new;
        System.out.println(supplier2.get()); //Person{name='null', age=0}

        //有参构造需要使用BiFunction
    }

}

（4）数组的引用

数组的引用 TypeName[] :: new

/**
 * @Author 振帅
 * @Date 2021/05/31 23:43
 */
public class MethodReferenceTest {

    public static void main(String[] args) {

        Function<Integer,Person[]> function = new Function<Integer, Person[]>() {
            @Override
            public Person[] apply(Integer integer) {
                return new Person[integer];
            }
        };
        System.out.println(Arrays.toString(function.apply(3)));//[null, null, null]

        Function<Integer,Person[]> function1 = integer -> new Person[integer];
        System.out.println(Arrays.toString(function1.apply(4)));//[null, null, null, null]

        Function<Integer,Person[]> function2 = Person[]::new;
        System.out.println(Arrays.toString(function2.apply(5)));//[null, null, null, null, null]
    }

}

2.2 Stream接口

2.2.1 基本概念

java.util.stream.Stream接口是对集合功能的增强，可以对集合元素进行复杂的查找、过滤、筛选等操作。
Stream接口借助于Lambda 表达式极大的提高编程效率和程序可读性，同时它提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势。

2.2.2 使用步骤

创建Stream，通过一个数据源来获取一个流。
转换Stream，每次转换返回一个新的Stream对象。
对Stream进行聚合操作并产生结果。

2.2.3 创建方式

方式一：通过调用集合的默认方法来获取流，如：default Stream stream()
方式二：通过数组工具类中的静态方法来获取流，如：static IntStream stream(int[] array)
方式三：通过Stream接口的静态方法来获取流，如：static Stream of(T... values)
方式四：通过Stream接口的静态方法来获取流，static Stream generate(Supplier<? extends T> s)

2.2.4 中间操作

筛选与切片的常用方法如下：

方法声明	功能介绍
Stream filter(Predicate<? super T> predicate)	返回一个包含匹配元素的流
Stream distinct()	返回不包含重复元素的流
Stream limit(long maxSize)	返回不超过给定元素数量的流
Stream skip(long n)	返回丢弃前n个元素后的流

映射的常用方法如下：

方法声明	功能介绍
Stream map(Function<? super T,? extends R> mapper)	返回每个处理过元素组成的流
Stream flatMap(Function<? super T,? extends Stream<? extends R>> mapper)	返回每个被替换过元素组成的流，并将所有流合成一个流

排序的常用方法如下：

方法声明	功能介绍
Stream sorted()	返回经过自然排序后元素组成的流
Stream sorted(Comparator<? super T> comparator)	返回经过比较器排序后元素组成的流

2.2.5 终止操作

匹配与查找的常用方法如下：

方法声明	功能介绍
Optional findFirst()	返回该流的第一个元素
boolean allMatch(Predicate<? super T> predicate)	返回所有元素是否匹配
boolean noneMatch(Predicate<? super T> predicate)	返回没有元素是否匹配
Optional max(Comparator<? super T> comparator)	根据比较器返回最大元素
Optional min(Comparator<? super T> comparator)	根据比较器返回最小元素
long count()	返回元素的个数
void forEach(Consumer<? super T> action)	对流中每个元素执行操作

规约的常用方法如下：

方法声明	功能介绍
Optional reduce(BinaryOperator accumulator)	返回结合后的元素值

收集的常用方法如下：

方法声明	功能介绍
<R,A> R collect(Collector<? super T,A,R> collector)	使用收集器对元素进行处理

2.2.6 代码案例

（1）Stream流实现集合元素的过滤和打印

/**
 * @Author 振帅
 * @Date 2021/06/01 0:39
 * 过滤出大于18岁的人
 */
public class ListPersonTest {

    public static void main(String[] args) {

        //1.准备一个List集合并放入Person类型的对象后打印
        List<Person> list = new LinkedList<>();

        list.add(new Person("AAA",16));
        list.add(new Person("BBB",13));
        list.add(new Person("CCC",22));
        list.add(new Person("DDD",21));
        list.add(new Person("DDD",21));
        list.add(new Person("EEE",30));

        for (Person person : list) {
            System.out.println(person);
        }

        System.out.println("==================================");

        //2.将List集合中所有成年人过滤出来并放入另外一个集合中打印
        List<Person> list2 = new LinkedList<>();

        for (Person person : list) {
            if (person.getAge() >= 18) {
                list2.add(person);
            }
        }

        for (Person person : list2) {
            System.out.println(person);
        }

        System.out.println("==================================");

        //3.使用Stream接口实现上述功能
        list.stream().filter(new Predicate<Person>() {
            @Override
            public boolean test(Person person) {
                return person.getAge() >= 18;
            }
        }).forEach(new Consumer<Person>() {
            @Override
            public void accept(Person person) {
                System.out.println(person);
            }
        });

        System.out.println("==================================");
        //4.使用Lambda表达式对上述代码进行优化
        list.stream().filter(person -> person.getAge() >= 18).forEach(person -> System.out.println(person));

        System.out.println("==================================");
        //5.使用方法引用
        list.stream().filter(person -> person.getAge() >= 18).forEach(System.out::println);
        
    }
}

（2）Stream流实现集合元素的切片和映射

public class ListPersonTest {

    public static void main(String[] args) {

        List<Person> list = new LinkedList<>();

        list.add(new Person("AAA",16));
        list.add(new Person("BBB",13));
        list.add(new Person("CCC",22));
        list.add(new Person("DDD",21));
        list.add(new Person("DDD",21));
        list.add(new Person("EEE",30));

        //1.实现对集合元素通过流跳过2个元素后再取2个元素后打印
        list.stream().skip(2).limit(3).forEach(System.out::println);
        
        //2.实现对集合中所有元素中的年龄获取并打印
        list.stream().map(new Function<Person, Integer>() {
            @Override
            public Integer apply(Person person) {
                return person.getAge();
            }
        }).forEach(System.out::println);
        
        list.stream().map(person -> person.getAge()).forEach(System.out::println);
        
        list.stream().map(Person::getAge).forEach(System.out::println);
        
    }
}

（3）Stream流实现集合元素排序

public class ListPersonTest {

    public static void main(String[] args) {

        List<Person> list = new LinkedList<>();

        list.add(new Person("AAA",16));
        list.add(new Person("BBB",13));
        list.add(new Person("CCC",22));
        list.add(new Person("DDD",21));
        list.add(new Person("DDD",21));
        list.add(new Person("EEE",30));

        list.stream().sorted((p1,p2)-> p1.getAge() - p2.getAge()).forEach(System.out::println);

        list.stream().sorted(Comparator.comparingInt(Person::getAge)).forEach(System.out::println);
        
    }
}

Java8新特性