Java学习之路（十六）：Java8新特性

一、Lambda表达式

Lambda是一个匿名函数，我们可以把Lambda表达式理解为是一段可以传递的代码（将代码想数据一样进行传递）

• Lambda表达式的使用

  1. 举例：(o1,o2) -> Integer.compare(o1,o2);
  2. 格式：
     ① -> ：lambda操作符或箭头操作符
     ② -> 左边：lambda参数列表（其实就是借口的抽象方法的形参列表）
     ③ -> 右边：lambda体（其实就是重写的抽象方法的方法体）

• Lambda表达式的使用（分为6种情况介绍）

  1. 无参，无返回值
  2. 需要一个参数，但是没有返回值
  3. 数据类型可以省略，因此可由编译器推断得出，称为“类型维护”
  4. Lambda表达式若只需要一个参数时，参数的小括号可以省略
  5. Lambda表达式需要两个或以上的参数，多条执行语句，并且可以有返回值
  6. 当Lambda体只有一条语句是，return与大括号若有，都可以省略

• 总结：

  1. -> 左边：Lambda形参列表的参数类型可以省略(类型推断)；如果只有一个参数，则可以省略小括号（只有一个可以省）
  2. -> 右边：Lambda体应该使用一对 {} 括起来，如果只有一条执行语句，则大括号和return都可以省略

3. ->左右遇一括号省，左侧推断类型省

• Lambda表达式的本质：作为接口的实例（对接口的要求：函数式接口）

函数式接口：接口中只有一个抽象方法的接口，称为函数式接口
可以使用注解 @FunctionalInterface修饰，可以检查接口是否是函数式接口

package lambda;

import org.junit.Test;

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

/**
 * @author ZC
 * @Description  lambda表达式的6种使用方式
 * @date 2020-07-14 21:39
 */
public class LambdaTest2 {
    //格式一：无参，无返回值
    @Test
    public void test1(){
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("我爱你！");
            }
        };
        r1.run();

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

        Runnable r2 = () -> {
            System.out.println("我爱她！");
        };
        r2.run();
    }


    //格式二：Lambda需要一个表达式，但是没有返回值
    @Test
    public void test2(){
        Consumer<String> cons = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        cons.accept("我爱你");

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

        Consumer<String> cons2 = (String s) -> {
            System.out.println(s);
        };
        cons2.accept("我爱她");

    }

    //格式三：数据类型可以省略，因此可由编译器推断得出，称为“类型维护”
    @Test
    public void test3(){
        Consumer<String> cons = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        cons.accept("我爱你");

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

        Consumer<String> cons2 = (s) -> {
            System.out.println(s);
        };
        cons2.accept("我爱她");
    }

    //格式四：Lambda表达式若只需要一个参数时，参数的小括号可以省略
    @Test
    public void test4(){
        Consumer<String> cons = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        cons.accept("我爱你");

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

        Consumer<String> cons2 = s -> {
            System.out.println(s);
        };
        cons2.accept("我爱她");
    }

    //格式五：Lambda表达式需要两个或以上的参数，多条执行语句，并且可以有返回值
    @Test
    public void test5(){
        Comparator<Integer> com1 = 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("***********************************");

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

    //格式六：当Lambda体只有一条语句是，return与大括号若有，都可以省略
    @Test
    public void test6(){
        Comparator<Integer> com1 = (o1, o2) -> {
            return o1.compareTo(o2);
        };

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

        Comparator<Integer> com2 = (o1, o2) -> o1.compareTo(o2);
    }
}

二、函数式（Functional）接口

• 只有一个抽象方法的接口，（有注解@FunctionalInterface）
• 可以通过Lambda表达式来创建接口的对象。（若Lambda表达式抛出一个受检异常（即非运行时异常），那么该异常需要在目标接口的抽象方法上进行声明）
• 可以在一个接口上使用@FunctionalInterface注解，这样做可以检查它是不是一个函数式接口。同时javadoc也会包含一条声明，说明这个接口是一个函数式接口。
• 以前用匿名实现类表示的函数式接口现在都可以用Lambda表达式来写
• 在java.util.function包下定义了Java8的丰富的函数式接口

package funcationalInterface;

import org.junit.Test;

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

/**
 * @author ZC
 * @Description  函数式接口
 * @date 2020-07-14 22:54
 */
public class FuncationalInterfaceTest {

    @Test
    public void test(){
        happyTime(500, new Consumer<Double>() {
            @Override
            public void accept(Double aDouble) {
                System.out.println("asdasdasd"+aDouble);
            }
        });
        System.out.println("**************");

        happyTime(500,money -> System.out.println("asdasdasd"+money));
    }

    public void happyTime(double money, Consumer<Double> con){
        con.accept(money);
    }


    @Test
    public void test2(){
        List<String> list = Arrays.asList("北京","南京","天津");
        List<String> result1 = filterString(list, new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.contains("京");
            }
        });
        System.out.println(result1);
        System.out.println("********************");
        List<String> result2 = filterString(list,s -> s.contains("京"));
        System.out.println(result2);
    }

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

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

1. 方法引用

• 当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用
• 方法引用可以看做是Lambda表达式深层次的表达。换句话说，方法引用就是Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法，可以认为是Lambda表达式的一个语法糖
• 要求：实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致
• 格式：使用操作符 “ :: ”将类（或对象）与方法名分隔开来
• 如下三种主要使用情况：
  1. 对象 :: 实例方法名
  2. 类 :: 静态方法名
  3. 类 :: 实例方法名 （参数列表中的第一个参数是实例方法的调用者，第二个参数是实例方法的参数）

package com.atguigu.java2;

import org.junit.Test;

import java.io.PrintStream;
import java.util.Comparator;
import java.util.function.BiPredicate;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * Created by shkstart.
 */
public class MethodRefTest {

	// 情况一：对象 :: 实例方法
	//Consumer中的void accept(T t)
	//PrintStream中的void println(T t)
	@Test
	public void test1() {
		Consumer<String> con1 = str -> System.out.println(str);
		con1.accept("北京");

		System.out.println("*******************");
		PrintStream ps = System.out;
		Consumer<String> con2 = ps::println;
		con2.accept("beijing");
	}
	
	//Supplier中的T get()
	//Employee中的String getName()
	@Test
	public void test2() {
		Employee emp = new Employee(1001,"Tom",23,5600);

		Supplier<String> sup1 = () -> emp.getName();
		System.out.println(sup1.get());

		System.out.println("*******************");
		Supplier<String> sup2 = emp::getName;
		System.out.println(sup2.get());

	}

	// 情况二：类 :: 静态方法
	//Comparator中的int compare(T t1,T t2)
	//Integer中的int compare(T t1,T t2)
	@Test
	public void test3() {
		Comparator<Integer> com1 = (t1,t2) -> Integer.compare(t1,t2);
		System.out.println(com1.compare(12,21));

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

		Comparator<Integer> com2 = Integer::compare;
		System.out.println(com2.compare(12,3));

	}
	
	//Function中的R apply(T t)
	//Math中的Long round(Double d)
	@Test
	public void test4() {
		Function<Double,Long> func = new Function<Double, Long>() {
			@Override
			public Long apply(Double d) {
				return Math.round(d);
			}
		};

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

		Function<Double,Long> func1 = d -> Math.round(d);
		System.out.println(func1.apply(12.3));

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

		Function<Double,Long> func2 = Math::round;
		System.out.println(func2.apply(12.6));
	}

	// 情况三：类 :: 实例方法  (有难度)
	// Comparator中的int comapre(T t1,T t2)
	// String中的int t1.compareTo(t2)
	@Test
	public void test5() {
		Comparator<String> com1 = (s1,s2) -> s1.compareTo(s2);
		System.out.println(com1.compare("abc","abd"));

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

		Comparator<String> com2 = String :: compareTo;
		System.out.println(com2.compare("abd","abm"));
	}

	//BiPredicate中的boolean test(T t1, T t2);
	//String中的boolean t1.equals(t2)
	@Test
	public void test6() {
		BiPredicate<String,String> pre1 = (s1,s2) -> s1.equals(s2);
		System.out.println(pre1.test("abc","abc"));

		System.out.println("*******************");
		BiPredicate<String,String> pre2 = String :: equals;
		System.out.println(pre2.test("abc","abd"));
	}
	
	// Function中的R apply(T t)
	// Employee中的String getName();
	@Test
	public void test7() {
		Employee employee = new Employee(1001, "Jerry", 23, 6000);


		Function<Employee,String> func1 = e -> e.getName();
		System.out.println(func1.apply(employee));

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


		Function<Employee,String> func2 = Employee::getName;
		System.out.println(func2.apply(employee));


	}

}

2. 构造器引用

• 一、构造器引用
  和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致。
  抽象方法的返回值类型即为构造器所属的类的类型
• 二、数组引用
  大家可以把数组看做是一个特殊的类，则写法与构造器引用一致。

package com.atguigu.java2;

import org.junit.Test;

import java.util.Arrays;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * Created by shkstart
 */
public class ConstructorRefTest {
	//构造器引用
    //Supplier中的T get()
    //Employee的空参构造器：Employee()
    @Test
    public void test1(){

        Supplier<Employee> sup = new Supplier<Employee>() {
            @Override
            public Employee get() {
                return new Employee();
            }
        };
        System.out.println("*******************");

        Supplier<Employee>  sup1 = () -> new Employee();
        System.out.println(sup1.get());

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

        Supplier<Employee>  sup2 = Employee :: new;
        System.out.println(sup2.get());
    }

	//Function中的R apply(T t)
    @Test
    public void test2(){
        Function<Integer,Employee> func1 = id -> new Employee(id);
        Employee employee = func1.apply(1001);
        System.out.println(employee);

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

        Function<Integer,Employee> func2 = Employee :: new;
        Employee employee1 = func2.apply(1002);
        System.out.println(employee1);

    }

	//BiFunction中的R apply(T t,U u)
    @Test
    public void test3(){
        BiFunction<Integer,String,Employee> func1 = (id,name) -> new Employee(id,name);
        System.out.println(func1.apply(1001,"Tom"));

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

        BiFunction<Integer,String,Employee> func2 = Employee :: new;
        System.out.println(func2.apply(1002,"Tom"));

    }

	//数组引用
    //Function中的R apply(T t)
    @Test
    public void test4(){
        Function<Integer,String[]> func1 = length -> new String[length];
        String[] arr1 = func1.apply(5);
        System.out.println(Arrays.toString(arr1));

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

        Function<Integer,String[]> func2 = String[] :: new;
        String[] arr2 = func2.apply(10);
        System.out.println(Arrays.toString(arr2));

    }
}

四、强大的Stream API

1. 创建Stream实例

1. 创建Stream方式一：通过集合 stream()和parallelStream()
2. 创建Stream方式二：通过数组 Arrays.stream()
3. 创建Stream方式三：通过Stream的of()
4. 创建Stream方式四：创建无限流

package streamAPI;

import org.junit.Test;

import java.util.Arrays;
import java.util.List;
import java.util.stream.DoubleStream;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
 * @author ZC
 * @Description   创建Stream的实例
 * @date 2020-07-15 11:22
 */
public class StreamAPITest {

    //创建Stream方式一：通过集合  stream()和parallelStream()
    @Test
    public void test1(){
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,11);
        //default Stream<E> stream() :返回一个顺序流
        Stream<Integer> stream = list.stream();

        //default Stream<E> parallelStream() :返回一个并行流
        Stream<Integer> parallelStream = list.parallelStream();
    }
    //创建Stream方式二：通过数组  Arrays.stream()
    @Test
    public void test2(){
        int[] arr = new int[]{1,2,3,4,5,6};
        IntStream stream = Arrays.stream(arr);

        double[] arr2 = new double[]{1,2,3,4,5,6};
        DoubleStream stream1 = Arrays.stream(arr2);
    }

    //创建Stream方式三：通过Stream的of()
    @Test
    public void test3(){
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
    }

    //创建Stream方式四：创建无限流
    @Test
    public void test4(){
        //迭代
        //public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
        Stream.iterate(0,t -> t+2).limit(10).forEach(System.out :: println);


        //生成
        //public static<T> Stream<T> generate(Supplier<T> s)
        Stream.generate(Math :: random).limit(10).forEach(System.out :: println);

    }
}

2. Stream的中间操作

• 多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”

• 内部迭代：迭代操作由StreamAPI自完成
• 外部迭代：迭代操作由自己写代码完成

a. 筛选与切片

方法	描述
filter(Predicate p)	接收Lambda表达式，从流中排除某些元素
distinct(0	筛选，通过流所生成的元素的hashCode()和equals()去除重复元素
limit(long maxSize)	截断流，使其元素不超过给定数量
skip(long n)	跳过元素，返回一个扔掉了前n个元素的流，若流中元素不足n个，则返回一个空流。与limit(n)互补

package streamAPI;

import org.junit.Test;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

/**
 * @author ZC
 * @Description  测试Stream的中间操作
 * @date 2020-07-15 11:58
 */
public class StreamAPITest1 {

    //filter(Predicate p)
    @Test
    public void test1(){
        List<Integer> list = Arrays.asList(1,2,3,4,5,6);
        Stream<Integer> stream = list.stream();
        stream.filter(t -> t > 3).forEach(System.out :: println);
    }

    //limit(long n)
    @Test
    public void test2(){
        List<Integer> list = Arrays.asList(1,2,3,4,5,6);
        Stream<Integer> stream = list.stream();
        stream.limit(3).forEach(System.out :: println);
    }

    //skip(long n)
    @Test
    public void test3(){
        List<Integer> list = Arrays.asList(1,2,3,4,5,6);
        Stream<Integer> stream = list.stream();
        stream.skip(2).limit(3).forEach(System.out :: println);
    }

    //distinct()
    @Test
    public void test4(){
        List<Integer> list = Arrays.asList(1,2,3,3,4,5,1,6);
        Stream<Integer> stream = list.stream();
        stream.distinct().forEach(System.out :: println);
    }
}

b. 映射

方法	描述
map(Function f)	接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
mapToDouble(ToDoubleFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的DoubleStream
mapToInt(ToIntFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的IntStream
mapToLong(ToLongFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的LongStream
flatMap(Function f)	接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流

package streamAPI;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

/**
 * @author ZC
 * @Description
 * @date 2020-07-15 12:25
 */
public class StreamAPITest2 {
    //map(Function f)
    @Test
    public void test1(){
        List<String> list = Arrays.asList("aa","bb","cc");
        Stream<String> stream = list.stream();
        stream.map(t -> t.toUpperCase()).forEach(System.out :: println);
    }

    //flatMap(Function f)
    @Test
    public void test2(){

        //使用map的方法
        List<String> list = Arrays.asList("aa","bb","cc");
        Stream<String> stream = list.stream();
        Stream<Stream<Character>> streamStream = stream.map(StreamAPITest2::fromStringToStream);
        streamStream.forEach(s ->{
            s.forEach(System.out :: println);
        });
        System.out.println("**************************");
        //使用flatMap的方法:集合套集合的遍历
        Stream<String> stream2 = list.stream();
        stream2.flatMap(StreamAPITest2::fromStringToStream).forEach(System.out :: println);
    }

    //将字符串中的多个字符构成的集合转换成对应的Stream的实例
    public static Stream<Character> fromStringToStream(String str){
        List<Character> list = new ArrayList<>();
        char[] chars = str.toCharArray();
        for (char c: chars
             ) {
            list.add(c);
        }
        return list.stream();
    }
}

c. 排序

方法	描述
sorted()	产生一个新流，其中按自然排序排序
sorted(Comparator com)	产生一个新流，其中按比较器顺序排序

package streamAPI;

import org.junit.Test;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

/**
 * @author ZC
 * @Description 测试Stream的中间操作
 * @date 2020-07-15 12:25
 */
public class StreamAPITest3 {
    //sorted()
    @Test
    public void test1(){
        List<String> list = Arrays.asList("zz","aa","bb","cc");
        Stream<String> sorted = list.stream().sorted();
        sorted.forEach(System.out :: println);

    }

    //sorted(Comparator com))
    @Test
    public void test2(){

        //使用map的方法
        List<String> list = Arrays.asList("zz","aa","bb","cc");
        Stream<String> stream = list.stream();
        stream.sorted((s1,s2) -> s1.compareTo(s2)).forEach(System.out :: println);
    }


}

3. Stream的终止操作

• 终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List，Integer，甚至是void
• 流进行了终止操作后，不能再次使用

a. 匹配与查找

方法	描述
allMatch(Predicate p)	检查是否匹配所有元素 （boolean）
anyMatch(Predicate p)	检查是否至少匹配一个元素 （boolean）
noneMatch(Predicate p)	检查是否没有匹配所有元素（boolean）
findFirst()	返回第一个元素 （Optional）
findAny()	返回当前流中的任意一个元素 （Optional）
count()	返回当前流的元素总数 （long）
max(Comparator c)	返回流中的最大值（Optional）
min(Comparator c)	返回流中的最小值 （Optional）
forEach(Consumer c)	内部迭代（使用Collection接口需要用户去做迭代，称为外部迭代，相反，StreamAPI使用内部迭代——它帮我们把迭代做了）

b. 归约

方法	描述
reduce(T iden,BinaryOperator b)	可以将流中元素反复结合起来，得到一个值。返回T
reduce(BinaryOperator b)	可以将流中元素反复结合起来，得到一个值，返回Optional<T>

package streamAPI;

import org.junit.Test;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;

/**
 * @author ZC
 * @Description 测试Stream的终止操作
 * @date 2020-07-15 12:25
 */
public class StreamAPITest4 {
    //reduce(T iden,BinaryOperator b)
    @Test
    public void test1(){
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9);
        Integer sum = list.stream().reduce(0, Integer::sum);
        System.out.println(sum);
    }

    //reduce(BinaryOperator b)
    @Test
    public void test2(){

        //使用map的方法
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9);
        Optional<Integer> sum = list.stream().reduce(Integer::sum);
        System.out.println(sum);
    }


}

c. 收集

方法	描述
collect(Collector c)	将流转换成其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法

• Collector接口中方法的实现决定了如何对流执行收集的操作（如收集到List,Set,Map）
• 另外，Collectors实用类提供了很多静态方法，可以方便的创建常见收集器实例
  
  

 //collect()
    @Test
    public void test3(){

        //使用map的方法
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9);
        List<Integer> integers = list.stream().filter(i -> i >= 5).collect(Collectors.toList());
        integers.forEach(System.out :: println);
    }

五、Optional类

六、并行流

1. 了解Fork/Join框架