第十七章 java8特性

17、java8中Lambda表达式与Stream API的使用
17.1 Lambda 表达式(Lambda Expressions)	1课时
17.2 函数式(Functional)接口	1课时
17.3 方法引用与构造器引用	1课时
17.4 Stream API	1课时

Java 11 2018年9月25日发布，那么还要有必要学习java 8 吗？

Java 8新特性简介

Java 8 (又称为 jdk 1.8) 是 Java 语以来最具革命性的版本。Java 8为Java语言、编译器、类库、开发工具与JVM带来了大量新特性。

• 速度更快
• 代码更少(增加了新的语法：Lambda 表达式)
• 强大的 Stream API
• 便于并行
• 最大化减少空指针异常：Optional
• Nashorn引擎，允许在JVM上运行JS应用

17-1 Lambda表达式

为什么使用 Lambda 表达式

• Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。
• 从匿名类到 Lambda 的转换举例1
  
  
  
  
• 从匿名类到 Lambda 的转换举例2
  
  
  
  

由一个问题的迭代看Lambda表达式

问题：针对员工的集合数据，有如下的一些需求，我们考虑如何完成？

需求1：获取当前公司中员工年龄大于30的员工信息

需求2：获取公司中工资大于 5000 的员工信息

....

Lambda 表达式语法

Lambda 表达式：在Java 8 语言中引入的一种新的语法元素和操作符。这个操作符为 “->” ， 该操作符被称为 Lambda 操作符或箭头操作符。它将 Lambda 分为两个部分：

左侧：指定了 Lambda 表达式需要的参数列表

右侧：指定了 Lambda 体，是抽象方法的实现逻辑，也即 Lambda 表达式要执行的功能。

Lambda表达式使用

public class LambdaTest {
	private List<Employee> data = EmployeeData.getEmployees();

	//举例三：由一个具体的问题，展开对Lambda表达式和 Stream api的使用的理解

	//解决层次六：使用Stream API
	@Test
	public void test11(){
		//查询员工中年龄大于30岁的员工的信息
		data.stream().filter(e -> e.getAge() > 30).forEach(System.out::println);

		System.out.println();

		//查询员工中工资大于5000的员工的信息
		data.stream().filter(e -> e.getSalary() > 5000).forEach(System.out::println);
	}

	//解决层次五：使用Lambda表达式的进一步优化
	@Test
	public void test10(){
		//查询员工中年龄大于30岁的员工的信息
		List<Employee> list = filterData(data, e -> e.getAge() > 30);
		list.forEach(System.out::println);

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

		//查询员工中工资大于5000的员工的信息
		List<Employee> list1 = filterData(data,e -> e.getSalary() > 5000);
		list1.forEach(System.out::println);
	}

	//解决层次四：使用Lambda表达式
	@Test
	public void test9(){
		//查询员工中年龄大于30岁的员工的信息
		List<Employee> list = filterData(data, e -> e.getAge() > 30);
		for (Employee emp : list) {
			System.out.println(emp);
		}

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

		//查询员工中工资大于5000的员工的信息
		List<Employee> list1 = filterData(data,e -> e.getSalary() > 5000);
		for (Employee emp : list1) {
			System.out.println(emp);
		}

	}

	//解决层次三：使用FilterData接口的匿名实现类
	@Test
	public void test8(){
		//查询员工中年龄大于30岁的员工的信息
		List<Employee> list = filterData(data, new FilterData<Employee>() {
			@Override
			public boolean filter(Employee employee) {
				return employee.getAge() > 30;
			}
		});
		for (Employee emp : list) {
			System.out.println(emp);
		}

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

		//查询员工中工资大于5000的员工的信息
		List<Employee> list1 = filterData(data, new FilterData<Employee>() {
			@Override
			public boolean filter(Employee employee) {
				return employee.getSalary() > 5000;
			}
		});
		for (Employee emp : list1) {
			System.out.println(emp);
		}

	}

	//解决层次二：策略的设计模式
	@Test
	public void test7(){
		//查询员工中年龄大于30岁的员工的信息
		List<Employee> list = filterData(data, new FilterByAge());
		for (Employee emp : list) {
			System.out.println(emp);
		}

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

		//查询员工中工资大于5000的员工的信息
		List<Employee> list1 = filterData(data, new FilterBySalary());
		for (Employee emp : list1) {
			System.out.println(emp);
		}

	}

	public List<Employee> filterData(List<Employee> list,FilterData<Employee> filter){

		ArrayList<Employee> data = new ArrayList<>();
		for (Employee emp : list) {
			if(filter.filter(emp)){
				data.add(emp);
			}
		}
		return data;

	}

	//解决层次一：
	@Test
	public void test6(){
		List<Employee> list = filterEmployeesBySalary(data);
		for (Employee emp : list) {
			System.out.println(emp);
		}
	}

	//问题二：查询员工中工资大于5000的员工的信息
	public List<Employee> filterEmployeesBySalary(List<Employee> list){
		ArrayList<Employee> data = new ArrayList<>();
		for (Employee emp : list) {
			if(emp.getSalary() > 5000){
				data.add(emp);
			}
		}
		return data;

	}

	@Test
	public void test5(){
		List<Employee> list = filterEmployeesByAge(data);
		for (Employee employee : list) {
			System.out.println(employee);
		}
	}

	//问题一：查询员工中年龄大于30岁的员工的信息
	public List<Employee> filterEmployeesByAge(List<Employee> list){

		ArrayList<Employee> data = new ArrayList<>();

		for (Employee emp : list) {
			if(emp.getAge() > 30){
				data.add(emp);
			}
		}

		return data;

	}

	//***************************************************************************

	//举例二：Thread中的Runnable的使用
	//使用Lambda之后
	@Test
	public void test4(){
		Runnable r = () -> {
			for (int i = 0; i <= 100; i++) {
				System.out.println(i);
			}
		};

		Thread t = new Thread(r);
		t.start();
	}

	//使用Lambda之前
	@Test
	public void test3(){

		//提供实现接口的匿名实现类的对象
		Runnable r = new Runnable() {
			@Override
			public void run() {
				for (int i = 0; i <= 100; i++) {
					System.out.println(i);
				}
			}
		};

		Thread t = new Thread(r);
		t.start();
	}

	//***************************************************************************

	//举例一：TreeSet中使用Comparator的使用
	//使用Lambda之后
	@Test
	public void test2(){

		Comparator<String> com = (o1,o2) -> o1.compareTo(o2);

		TreeSet<String> set = new TreeSet<String>(com);

		set.add("HH");
		set.add("MM");
		set.add("GG");
		set.add("JJ");
		set.add("DD");

		for (String s : set) {
			System.out.println(s);
		}
	}
	//使用Lambda之前
	@Test
	public void test1(){
//        System.out.println("hello");

		//提供匿名实现类的对象
		Comparator<String> com = new Comparator<String>() {
			@Override
			public int compare(String o1, String o2) {
				return o1.compareTo(o2);
			}
		};

		TreeSet<String> set = new TreeSet<String>(com);

		set.add("HH");
		set.add("MM");
		set.add("GG");
		set.add("JJ");
		set.add("DD");

		for (String s : set) {
			System.out.println(s);
		}

	}

}

---

public class Employee {

	private int id;
	private String name;
	private int age;
	private double salary;

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public double getSalary() {
		return salary;
	}

	public void setSalary(double salary) {
		this.salary = salary;
	}

	public Employee(int id, String name, int age, double salary) {

		this.id = id;
		this.name = name;
		this.age = age;
		this.salary = salary;
	}

	public Employee() {

	}

	@Override
	public String toString() {
		return "Employee{" +
				"id=" + id +
				", name='" + name + '\'' +
				", age=" + age +
				", salary=" + salary +
				'}';
	}
}

---

public interface FilterData {

	public boolean filter(T t);
}

---

/**
*
* 提供FilterData接口的实现类，实现按照工资过滤数据
*/
public class FilterBySalary implements FilterData {
@Override
public boolean filter(Employee employee) {
return employee.getSalary() > 5000;
}
}

---

/**
 * 提供FilterData接口的实现类，实现按照年龄过滤数据
 */
public class FilterByAge implements FilterData<Employee> {
	@Override
	public boolean filter(Employee employee) {

		return employee.getAge() > 30;

	}
}

---

/**
 * 提供用于测试的数据
 *
 */
public class EmployeeData {

	public static List<Employee> getEmployees(){
		List<Employee> list = new ArrayList<>();

		list.add(new Employee(1001, "马化腾", 34, 6000.38));
		list.add(new Employee(1002, "马云", 12, 9876.12));
		list.add(new Employee(1003, "刘强东", 33, 3000.82));
		list.add(new Employee(1004, "雷军", 26, 7657.37));
		list.add(new Employee(1005, "李彦宏", 65, 5555.32));
		list.add(new Employee(1006, "比尔盖茨", 42, 9500.43));
		list.add(new Employee(1007, "任正非", 25, 4333.32));
		list.add(new Employee(1008, "扎克伯格", 35, 2500.32));

		return list;
	}

}

语法格式一：无参，无返回值

语法格式二：Lambda 需要一个参数，但是没有返回值

语法格式三：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”

语法格式四：Lambda 若只需要一个参数时，数参数的小括号可以省略

语法格式五：Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值

语法格式六：当 Lambda 体只有一条语句时，return 与大括号若有，都可以省略

类型推断

上述 Lambda 表达式中的参数类型都是由编译器推断得出的。Lambda 表达式中无需指定类型，程序依然可以编译，这是因为 javac 根据程序的上下文，在后台推断出了参数的类型。Lambda 表达式的类型依赖于上下文环境，是由编译器推断出来的。这就是所谓的“类型推断”。

java中Lambda表达式使用

/**
 * 一、Lambda表达式的基本语法。
 * 1.格式：  lambda形参列表 -> lambda体
 * 2.说明： -> : lambda操作符 或箭头操作符
 *         ->左边 ：lambda表达式的形参列表
 *         ->右边：lambda表达式的执行语句，称为lambda体
 *
 * 3.如何使用：分为六种情况
 *
 * 总结：
 * 1）lambda形参列表：如果有形参的话，都可以省略变量的数据类型 ---类型推断
 *                   如果形参列表只有一个形参，还可以省略一对()
 * 2)lambda体:正常情况下，需要使用一对{}包起来所有的执行语句。
 *            特别的，①lambda体如果只有一条执行语句，可以省略这一对{}.
 *                   ②如果此唯一的一条执行语句是return,则除了省略一对{}之外，return关键字也可以省略
 *
 *
 *  二、函数式接口
 *  1.特点：如果一个接口中只有唯一的一个抽象方法，则此接口称为函数式接口
 *  2.可以在接口的声明上使用@FunctionalInterface注解去校验一个接口是否是函数式接口
 *  3.lambda表达式的使用依赖于函数式接口
 *  4.lambda表达式即为函数式接口的实例。
 *
 *  只要一个对象是函数式接口的实例，那么该对象就可以用Lambda表达式来表示。
 *  所以以前用匿名类表示的现在都可以用Lambda表达式来写。
 */
public class LambdaTest {

	//情况六：lambda体如果只有一条执行语句，可以省略这一对{}.
	//特别的，如果此唯一的一条执行语句是return,则除了省略一对{}之外，return关键字也可以省略
	@Test
	public void test7(){
		Comparator<Integer> com1 = (o1,o2) -> o1.compareTo(o2);
		int value = com1.compare(12, 34);
		System.out.println(value);
	}

	//情况五：lambda表达式的形参列表有两个或两个以上的变量，lambda体有多条执行语句，甚至有返回值
	@Test
	public void  test6(){
		Comparator<Integer> com1 = new Comparator<Integer>() {
			@Override
			public int compare(Integer o1, Integer o2) {
				System.out.println(o1);
				System.out.println(o2);
//                return Integer.compare(o1,o2);
				return o1.compareTo(o2);
			}
		};
		int value = com1.compare(12, 34);
		System.out.println(value);

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

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

		int value1 = com2.compare(32, 12);
		System.out.println(value1);

	}

	//情况四：针对于情况三进行迭代。
	//如果lambda表达式的形参列表只有一个变量，则可以省略一对()
	@Test
	public void test5(){
		Consumer<String> con1 = s -> {
			System.out.println(s);
		};

		con1.accept("你好我也好！");
	}

	//以前在java程序中出现的类型推断
	@Test
	public void test4(){
		//举例1：
		int[] arr = new int[]{1,2,3,4};
		//类型推断
		int[] arr1 = {1,2,3,4};
		int[] arr2 ;
		arr2 = new int[]{1,2,3,4};
		//举例2：
		List<String> list = new ArrayList<String>();
		//类型推断
		List<String> list1 = new ArrayList<>();

		//举例3
		method(new HashMap<>());
	}
	public void method(HashMap<String,Employee> map){

	}

	//情况三：针对于情况二进行迭代。lambda形参列表的变量的数据类型可以省略
	//说明：java编译器可以根据上下文推断出变量的数据类型，故可以省略：类型推断
	@Test
	public void test3(){
		Consumer<String> con1 = (s) -> {
			System.out.println(s);
		};

		con1.accept("你好我也好！");
	}

	//情况二：lambda形参列表有一个参数，无返回值
	@Test
	public void test2(){
		Consumer<String> con = new Consumer<String>() {
			@Override
			public void accept(String s) {
				System.out.println(s);
			}
		};

		con.accept("昨天过的挺好！");

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

		Consumer<String> con1 = (String s) -> {
			System.out.println(s);
		};

		con1.accept("你好我也好！");

	}

	//情况一：无形参，无返回值
	@Test
	public void test1(){
		Runnable r = new Runnable() {
			@Override
			public void run() {
				System.out.println("昨天是七夕情人节！");
			}
		};

		Thread t1 = new Thread(r);
		t1.start();

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

		Runnable r1 = () -> {
			System.out.println("你们有没有因为爱情而鼓掌呢？");
		};

		Thread t2 = new Thread(r1);
		t2.start();
	}
}

---

17-2 函数式接口

什么是函数式(Functional)接口

• 只包含一个抽象方法的接口，称为函数式接口。
• 你可以通过 Lambda 表达式来创建该接口的对象。（若 Lambda 表达式抛出一个受检异常(即：非运行时异常)，那么该异常需要在目标接口的抽象方法上进行声明）。
• 我们可以在一个接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口。同时 javadoc 也会包含一条声明，说明这个接口是一个函数式接口。
• 在java.util.function包下定义了java 8 的丰富的函数式接口

如何理解函数式接口

Java从诞生日起就是一直倡导“一切皆对象”，在java里面面向对象(OOP)编程是一切。但是随着python、scala等语言的兴起和新技术的挑战，java不得不做出调整以便支持更加广泛的技术要求，也即java不但可以支持OOP还可以支持OOF（面向函数编程）

在函数式编程语言当中，函数被当做一等公民对待。在将函数作为一等公民的编程语言中，Lambda表达式的类型是函数。但是在Java8中，有所不同。在Java8中，Lambda表达式是对象，而不是函数，它们必须依附于一类特别的对象类型——函数式接口。

简单的说，在Java8中，Lambda表达式就是一个函数式接口的实例。这就是Lambda表达式和函数式接口的关系。也就是说，只要一个对象是函数式接口的实例，那么该对象就可以用Lambda表达式来表示。

所以以前用匿名内部类表示的现在都可以用Lambda表达式来写。

函数式接口举例

自定义函数式接口

函数式接口中使用泛型：

作为参数传递 Lambda 表达式

作为参数传递 Lambda 表达式

作为参数传递 Lambda 表达式：为了将 Lambda 表达式作为参数传递，接收Lambda 表达式的参数类型必须是与该 Lambda 表达式兼容的函数式接口的类型。

Java 内置四大核心函数式接口

/**
 *
 * java8中关于Lambda表达式提供的4个基本的函数式接口：
 *
 * 1.Consumer<T> :消费型接口
 *      void accept(T t)
 *
 * 2.Supplier<T> : 供给型接口
 *      T get()
 *
 * 3. Function<T,R> : 函数型接口
 *      R apply(T t)
 *
 * 4. Predicate<T> : 断定型接口
 *      boolean test(T t)
 *
 *  总结：从方法的角度来说：
 *  1.方法在调用时，如果发现方法的形参是一个函数型接口，那么我们调用此方法时，可以使用lambda表达式
 *  作为实参传递给此接口形参
 *  2.方法定义时，如果需要一个定义接口，且此接口只有一个抽象方法，(说明此接口就是函数式接口)，那么
 *  考虑是有有现成的函数式接口可用。如果有，则不需要我们再去定义。比如：FilterData 替换为Predicate

 */
public class LambdaTest1 {

	//针对于昨天讲的举例三，可以不用定义FilterData接口，而使用Predicate接口即可
	@Test
	public void test5(){
		List list = EmployeeData.getEmployees();
		List data1 = filterData(list, e -> e.getAge() > 30);
		System.out.println(data1);

		List data2 = filterData(list, e -> e.getSalary() > 5000);
		System.out.println(data2);
	}
	public List<Employee> filterData(List<Employee> list, Predicate<Employee> filter){

		ArrayList<Employee> data = new ArrayList<>();
		for (Employee emp : list) {
			if(filter.test(emp)){
				data.add(emp);
			}
		}
		return data;

	}

	//4. Predicate<T> : 断定型接口
	//boolean test(T t)
	@Test
	public void test4(){
		List<String> list = Arrays.asList("北京","南京","东京","西京","普京","上海","深圳");
		List<String> data = getStrings(list, s -> s.contains("京"));
		System.out.println(data);
	}

	public List<String> getStrings(List<String> list, Predicate<String> pre){
		List<String> data = new ArrayList<>();
		for (String s : list) {
			if(pre.test(s)){
				data.add(s);
			}
		}
		return data;
	}

	//3. Function<T,R> : 函数型接口
	//R apply(T t)
	@Test
	public void test3(){
		strHandler("    hel   lo   ",str -> str.trim());

		strHandler("世界那么大，我想去看看",str -> str.substring(2,5));
	}

	public void strHandler(String str, Function<String,String> func){
		String s = func.apply(str);
		System.out.println(s);
	}

//    2.Supplier<T> : 供给型接口
//    T get()
	@Test
	public void test2(){
		List<Double> list = getRandomValue(10, () -> Math.random() * 100);
		for (Double d : list) {
			System.out.println(d);
		}
	}

	public List<Double> getRandomValue(int num, Supplier<Double> sup){
		List<Double> list = new ArrayList<>();
		for(int i = 0;i < num;i++){
		   list.add(sup.get());
		}
		return list;
	}

	//1.Consumer<T> :消费型接口
	//void accept(T t)
	@Test
	public void  test1(){
		happyNight(500, s -> {
			System.out.println("学习很辛苦，累了的话，可以去正规的足浴店放松一下。花费：" + s);
		});
	}

	public void happyNight(Integer money, Consumer<Integer> con){
		con.accept(money);
	}

}

其他接口

17-3 方法引用与构造器引用

方法引用(Method References)

• 当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！
• 方法引用就是Lambda表达式，就是函数式接口的一个实例，通过方法的名字来指向一个方法，可以认为是Lambda表达式的一个语法糖。
• 要求：实现抽象方法的参数列表和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致！
• 方法引用：使用操作符 “::” 将类(或对象) 与 方法名分隔开来。
• 如下三种主要使用情况：
  • 对象::实例方法名
  • 类::静态方法名
  • 类::实例方法名

方法引用

例如：

等同于：

例如：

等同于：

例如：

等同于：

注意：当函数式接口方法的第一个参数是需要引用方法的调用者，并且第二个参数是需要引用方法的参数(或无参数)时：ClassName::methodName

---

/**
* 方法引用的使用
* 1.方法引用可以看做是Lambda表达式深层次的表达，或者可以理解为：方法引用就是Lambda表达式。
* 又因为Lambda表达式本身就是函数式接口的实例，进而方法引用也可以看做函数式接口的实例。
*
* 2.使用情境：
* 当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！
*
* 3.要求：函数式接口中抽象方法的形参列表和返回值类型 要与 方法引用对应的方法的形参列表和返回值类型一致！
*
* 4.格式：类(或 对象) :: 方法名
*
* 5.分为如下的三种情况：
* ① 对象 :: 实例方法
* ② 类 :: 静态方法
* ③ 类 :: 实例方法 （有难度）
*
* 6.在满足如上的第2条d的情况下，使用方法引用替换Lambda表达式。如果方法引用不熟悉，可以使用Lambda表达式。
*/
public class MethodRefTest {

	//情况三：类 :: 实例方法  （有难度）
	//注意：当函数式接口方法的第一个参数是需要引用方法的调用者，
	//并且第二个参数是需要引用方法的参数(或无参数)时：ClassName::methodName
	@Test
	public void test7(){
		Employee emp = new Employee(1001, "Jerry", 32, 23430);
		Function<Employee,String> func1 = (e) -> e.getName();
		String name = func1.apply(emp);
		System.out.println(name);

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

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

	}
	@Test
	public void test6(){
		BiPredicate<String,String> bi = (s1,s2) -> s1.equals(s2);
		boolean b = bi.test("abc", "abc");
		System.out.println(b);

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

		BiPredicate<String,String> bi1 = String::equals;
		boolean b1 = bi1.test("abc", "abc");
		System.out.println(b1);
	}
	@Test
	public void test5(){
		Comparator<String> com = (s1,s2) -> s1.compareTo(s2);
		int value = com.compare("abad", "abdd");
		System.out.println(value);

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

		Comparator<String> com1 = String::compareTo;
		int value1 = com1.compare("aaaaaa", "aa");
		System.out.println(value1);
	}

	//情况二：类 :: 静态方法
	@Test
	public void test4(){
		Function<Double,Long> func1 = d -> Math.round(d);
		Long value = func1.apply(12.3);
		System.out.println(value);

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

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

		Function<Long,Long> func3 = Math::abs;
		Long value2 = func3.apply(-1234L);
		System.out.println(value2);
	}
	@Test
	public void test3(){
		Comparator<Integer> com = (num1,num2) -> Integer.compare(num1,num2);
		int value = com.compare(12, 32);
		System.out.println(value);

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

		Comparator<Integer> com1 = Integer::compare;
		int value1 = com1.compare(43, 12);
		System.out.println(value1);

	}

	//情况一：对象 :: 实例方法
	@Test
	public void test2(){
		Employee emp = new Employee(1001, "Tom", 23, 4534);
		Supplier<String> sup = () -> emp.getName();
		String name = sup.get();
		System.out.println(name);

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

		Supplier<String> sup1 = emp::getName;
		String name1 = sup1.get();
		System.out.println(name1);
	}
	@Test
	public void test1(){
		Consumer<String> con1 = str -> System.out.println(str);
		con1.accept("beijing");

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

		PrintStream ps = System.out;
		Consumer<String> con2 = ps :: println;
		con2.accept("shanghai");

	}
}

构造器引用

格式： ClassName::new

与函数式接口相结合，自动与函数式接口中方法兼容。

可以把构造器引用赋值给定义的方法，要求

构造器参数列表要与接口中抽象方法的参数列表一致！且方法的返回值即为构造器对应类的对象。

例如：

等同于：

数组引用

格式： ClassName::new

例如：

等同于：

---

/**
 * 一、构造器引用
 * 1.格式： 类名 :: new
 * 2.要求：函数式接口中抽象方法的形参列表与构造器形参列表一致（类型相同，个数相同），
 *        同时，抽象方法的返回值类型即为构造器所属的类的类型。
 *
 *
 * 二、数组引用
 */
public class ConstructorRefTest {

	@Test
	public void test4(){
		Function<Integer,String[]> func1 = (length) -> new String[length];
		String[] arr = func1.apply(10);
		System.out.println(arr.length);

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

		Function<Integer,String[]> func2 = String[]::new;
		String[] arr1 = func2.apply(20);
		System.out.println(arr1.length);
	}

	@Test
	public void test3(){
		BiFunction<Integer,String,Employee> func1 = (id,name) -> new Employee(id,name);
		Employee emp = func1.apply(10, "Jim");
		System.out.println(emp);

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

		BiFunction<Integer,String,Employee> func2 = Employee::new;
		Employee emp1 = func2.apply(20, "Jim");
		System.out.println(emp1);
	}

	@Test
	public void test2(){
		Function<Integer,Employee> func1 = (id) -> new Employee(id);
		Employee emp1 = func1.apply(12);
		System.out.println(emp1);

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

		Function<Integer,Employee> func2 = Employee::new;
		Employee emp2 = func2.apply(12);
		System.out.println(emp2);
	}

	@Test
	public void test1(){
		Supplier<Employee> sup = () -> new Employee();
		Employee emp = sup.get();
		System.out.println(emp);

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

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

17-4 强大的Stream API

Stream API说明

Java8中有两大最为重要的改变。 第一个是 Lambda 表达式；另外一个则是 Stream API。

Stream API ( java.util.stream) 把真正的函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充，因为Stream API可以极大提供Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。

Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。 使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

为什么要使用Stream API

实际开发中，项目中多数数据源都来自于Mysql，Oracle等。但现在数据源可以更多了，有MongDB，Radis等，而这些NoSQL的数据就需要java层面去处理。

什么是 Stream

Stream到底是什么呢？

是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。

“集合讲的是数据，Stream流讲的是计算！”

注意：

①Stream 自己不会存储元素。

②Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。

③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

Stream 的操作三个步骤

创建 Stream方式一：通过集合

Java8 中的 Collection 接口被扩展，提供了两个获取流的方法：

• default Stream stream() : 返回一个顺序流
• default Stream parallelStream() : 返回一个并行流

####创建 Stream方式二：通过数组
Java8 中的 Arrays 的静态方法 stream() 可以获取数组流：

• static Stream stream(T[] array): 返回一个流

重载形式，能够处理对应基本类型的数组：

• public static IntStream stream(int[] array)
• public static LongStream stream(long[] array)
• public static DoubleStream stream(double[] array)

创建 Stream方式三：通过Stream的of()

可以调用Stream类静态方法 of(), 通过显示值创建一个流。它可以接收任意数量的参数。

• public static Stream of(T... values) : 返回一个流

####创建 Stream方式四：创建无限流
可以使用静态方法 Stream.iterate() 和 Stream.generate(), 创建无限流。

• 迭代
  public static Stream iterate(final T seed, final UnaryOperator f)
• 生成
  
  public static Stream generate(Supplier s)

####Stream 的中间操作

Stream 的终止操作

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

并行流与串行流

并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。

Java 8 中将并行进行了优化，我们可以很容易的对数据进行并行操作。Stream API 可以声明性地通过 parallel() 与 sequential() 在并行流与顺序流之间进行切换。

java中Stream API使用

/**
 * 1.Stream API:
 *   可以理解为java提供的一套api，使用这套api可以实现对集合、数组中的数据进行过滤、映射、归约、查找等操作
 *
 * 2.注意点：
 * ①Stream 自己不会存储元素。
 * ②Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
 * ③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。
 *
 * 3.Stream的使用流程：
 *  步骤一：Stream的实例化
 *  步骤二：一系列的中间操作
 *  步骤三：终止操作
 *
 *  注意：①步骤二中的中间操作可以有多个
 *       ②如果没有终止操作，那么一系列的中间操作是不会执行的。只有执行了步骤三的终止操作，步骤二才会执行：惰性求值
 *       ③终止操作一旦执行，就不可以再执行中间操作或其他的终止操作。
 *
 *
 *  测试Stream的实例化
 *
 */
public class StreamAPITest {

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

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

	}

	//方式三：Stream的静态方法of()
	@Test
	public void test3(){
		//public static<T> Stream<T> of(T... values) : 返回一个流
		Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
	}

	//方式二：通过数组
	@Test
	public void test2(){
		//调用Arrays的static <T> Stream<T> stream(T[] array): 返回一个流
		String[] arr = new String[]{"MM","GG","JJ","DD"};
		Stream<String> stream = Arrays.stream(arr);

	}

	//方式一：通过集合
	@Test
	public void test1(){
//        default Stream<E> stream() : 返回一个顺序流
		List<Employee> list = EmployeeData.getEmployees();
		Stream<Employee> stream = list.stream();
//        default Stream<E> parallelStream() : 返回一个并行流
		Stream<Employee> stream1 = list.parallelStream();

	}
}

---

/**
* 测试中间操作
* 1.可以通过Stream的实例，执行多次中间操作
* 2.中间操作，只有在执行了终止操作以后才会执行。
*/
public class StreamAPITest1 {

	//3-排序
	@Test
	public void test4(){
//        sorted()——自然排序
		List<Integer> list = Arrays.asList(23,43,454,32,1,2,5,5,-8);
		list.stream().sorted().forEach(System.out::println);

		//此时针对Employees进行排序：失败。原因：Employee类没有实现Comparable接口
//        List<Employee> list1 = EmployeeData.getEmployees();
//        list1.stream().sorted().forEach(System.out::println);

//        sorted(Comparator com)——定制排序
		List<Employee> list1 = EmployeeData.getEmployees();
		list1.stream().sorted((e1,e2) -> {
			if(e1.getAge() != e2.getAge()){
				return e1.getAge() - e2.getAge();
			}else{
				return -Double.compare(e1.getSalary(),e2.getSalary());
			}
		}).forEach(System.out::println);

	}

	@Test
	public void test3(){
		ArrayList list1 = new ArrayList();
		list1.add(1);
		list1.add(2);
		list1.add(3);

		ArrayList list2 = new ArrayList();
		list2.add(4);
		list2.add(5);
		list2.add(6);

//        list1.add(list2); ---map()
//        System.out.println(list1);//[1, 2, 3, [4, 5, 6]]

//        list1.addAll(list2); -- flatMap()
//        System.out.println(list1);//[1, 2, 3, 4, 5, 6]

	}
	//2-映射
	@Test
	public void test2(){
//        map(Function f)——接收一个函数作为参数，将元素转换成其他形式或提取信息，该函数会被应用到每个元素上，并将其映射成一个新的元素。
		List<String> list = Arrays.asList("aa","bb","cc","dd");
		list.stream().map(String::toUpperCase).forEach(System.out::println);
//        练习：获取员工姓名长度大于3的员工的姓名。
		Stream<Employee> stream = EmployeeData.getEmployees().stream();
		Stream<String> stream1 = stream.map(Employee::getName);
		stream1.filter(name -> name.length() > 3).forEach(System.out::println);

		Stream<Stream<Character>> stream2 = list.stream().map(StreamAPITest1::fromStringToChar);
		stream2.forEach(
				x ->{
				   x.forEach(System.out::println);
				}

		);

		System.out.println();

//        flatMap(Function f)——接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
		Stream<Character> stream3 = list.stream().flatMap(StreamAPITest1::fromStringToChar);
		stream3.forEach(System.out::println);
	}
	//将str中的字符存在集合中，返回集合的Stream
	public static Stream<Character> fromStringToChar(String str){
		ArrayList<Character> list = new ArrayList<>();
//        for(Character c : str.toCharArray()){
//              list.add(c);
//        }
		for(int i = 0;i < str.length();i++){
			list.add(str.charAt(i));
		}
		return list.stream();
	}

	//1-筛选与切片
	@Test
	public void test1(){
		List<Employee> list = EmployeeData.getEmployees();
		//体会方法链的调用方式。比如：StringBuffer s = new StringBuffer(); s.append("A").append("B");
//        filter(Predicate p)——接收 Lambda ， 从流中排除某些元素。
		Stream<Employee> stream = list.stream().filter(e -> e.getAge() > 30);
		stream.forEach(System.out::println);

		System.out.println();

//        limit(n)——截断流，使其元素不超过给定数量。
		list.stream().filter(e -> e.getAge() > 30).limit(3).forEach(System.out::println);

		System.out.println();

		//        skip(n) —— 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
		list.stream().filter(e -> e.getAge() > 30).skip(3).forEach(System.out::println);

		System.out.println();

		//        distinct()——筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
		list.add(new Employee(1009,"刘强东",30,6000));
		list.add(new Employee(1009,"刘强东",30,6000));
		list.add(new Employee(1009,"刘强东",30,6000));
		list.add(new Employee(1009,"刘强东",30,6000));
		list.add(new Employee(1009,"刘强东",30,6000));
		list.stream().distinct().forEach(System.out::println);
	}
}

---

/**
* 步骤三：终止操作
*/
public class StreamAPITest2 {

	//3-收集:将集合--->Stream --->集合
	@Test
	public void test5(){
//        collect(Collector c)——将流转换为其他形式。接收一个 Collector接口的实现，
//                              用于给Stream中元素做汇总的方法

		List<Employee> list = EmployeeData.getEmployees();
		List<Employee> list1 = list.stream().filter(e -> e.getSalary() > 5000).collect(Collectors.toList());
		//遍历
		list1.forEach(System.out::println);

		System.out.println();

		Set<Employee> set = list.stream().filter(e -> e.getSalary() > 5000).collect(Collectors.toSet());
		set.forEach(System.out::println);

		System.out.println();

		ArrayList<Employee> list2 = list.stream().filter(e -> e.getSalary() > 5000).collect(Collectors.toCollection(ArrayList::new));
		for (Employee employee : list2) {
			System.out.println(employee);
		}
	}

	//2-归约
	@Test
	public void test4(){
//        reduce(T identity, BinaryOperator)——可以将流中元素反复结合起来，得到一个值。返回 T
		List<Integer> list = Arrays.asList(1,2,3,4,5,6);
//        Integer sum = list.stream().reduce(0, (x1, x2) -> x1 + x2);
		Integer sum = list.stream().reduce(10, Integer::sum);
		System.out.println(sum);

//        reduce(BinaryOperator) ——可以将流中元素反复结合起来，得到一个值。返回 Optional<T>
//        练习1：计算公司所有员工工资的总和
		List<Employee> emps = EmployeeData.getEmployees();
		Stream<Double> moneyStream = emps.stream().map(Employee::getSalary);
		Optional<Double> moneyOptional = moneyStream.reduce(Double::sum);
		System.out.println(moneyOptional.get());

//        练习2：员工姓名中包含“马”字的个数
		Stream<String> nameStream = emps.stream().map(Employee::getName);
		Stream<Character> charStream = nameStream.flatMap(StreamAPITest1::fromStringToChar);
		//方式一：
//        long count = charStream.filter(c -> c.equals('马')).count();
//        System.out.println(count);
		//方式二：
		Optional<Integer> op = charStream.map(c -> {
			if (c.equals('马')) {
				return 1;
			} else {
				return 0;
			}
		}).reduce(Integer::sum);

		System.out.println(op.get());

		//练习3：员工姓名中包含“马”的员工个数
		long count = emps.stream().map(Employee::getName).filter(name -> name.contains("马")).count();
		System.out.println(count);

//        练习4：员工姓名中包含“马”的员工的姓名
		emps.stream().map(Employee::getName).filter(name -> name.contains("马")).forEach(System.out::println);

	}
	//1-匹配与查找
	@Test
	public void test2(){
		List<Employee> list = EmployeeData.getEmployees();
//        max(Comparator c)——返回流中最大值
//        练习：返回最高的工资：
		Stream<Employee> stream = list.stream();
		Stream<Double> stream1 = stream.map(Employee::getSalary);
		Optional<Double> max = stream1.max(Double::compare);
		System.out.println(max.get());
//        min(Comparator c)——返回流中最小值
//        练习：返回最低工资的员工
		Stream<Employee> stream2 = list.stream();
		Optional<Employee> min = stream2.min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
		System.out.println(min.get());
//        forEach(Consumer c)——内部迭代
		list.stream().forEach(System.out::println);

	}

	//外部迭代
	@Test
	public void test3(){
		List<Employee> list = EmployeeData.getEmployees();
		Iterator<Employee> iterator = list.iterator();
		while (iterator.hasNext()){
			System.out.println(iterator.next());
		}
	}

	@Test
	public void test1(){
		List<Employee> list = EmployeeData.getEmployees();
//        allMatch(Predicate p)——检查是否匹配所有元素
		//是否所有的员工的年龄都大于18
		boolean b = list.stream().allMatch(e -> e.getAge() > 18);
		System.out.println(b);

//        anyMatch(Predicate p)——检查是否至少匹配一个元素
		//是否存在员工的工资大于 10000
		boolean b1 = list.stream().anyMatch(e -> e.getSalary() > 9900);
		System.out.println(b1);

//        noneMatch(Predicate p)——检查是否没有匹配的元素
		//是否存在员工姓“雷”
		boolean b2 = list.stream().noneMatch(e -> e.getName().contains("雷"));
		System.out.println(b2);

//        findFirst——返回第一个元素
		Optional<Employee> emp = list.stream().sorted((e1,e2) -> {
			if(e1.getAge() != e2.getAge()){
				return e1.getAge() - e2.getAge();
			}else{
				return -Double.compare(e1.getSalary(),e2.getSalary());
			}
		}).findFirst();
		System.out.println(emp.get());

//        findAny——返回当前流中的任意元素
		Optional<Employee> emp1 = list.parallelStream().findAny();
		System.out.println(emp1.get());
//        count——返回流中元素的总个数
		long count = list.stream().filter(e -> e.getSalary() > 5000).count();
		System.out.println(count);

	}
}