Java8新特性-Stream API

1. 什么是Stream API

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

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

2. 为什么要使用Stream API

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

$Stream$ 和 $Collection$ 集合的区别： $Collection$ 是一种静态的内存数据结构，是一种容器，来存储多个数据的。而 $Stream$ 是有关计算的，主要是用来操作容器中的数据。前者主要面向内存，存储在内存中；后者主要是面向CPU，通过CPU实现计算。

注意

1. $Stream$ 自己不会存储元素
2. $Stream$ 不会改变源对象。相反，他们会返回一个持有结果的新 $Stream$。
3. $Stream$ 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

3. Stream 操作的三个步骤

• Stream的创建
  从一个数据源(集合、数组等)中，获取一个流。

• Stream中间操作
  一个中间操作链，对数据源的数据进行处理。注意：在没有执行终止操作之前，中间操作不会被执行。

• Stream终止操作
  一旦执行终止操作，就执行中间操作链，并产生结果。之后，该 Stream不会被再使用。

3.1 Stream的创建

(1) 创建：通过集合创建

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));
		// ... 
		return list;
	}
}

public class Main {

    public static void main(String[] args) {
        List<Employee> employees = EmployeeData.getEmployees(); // 返回一个List容器对象
		
		// default Stream<E> stream()
		// 返回一个顺序流，其可以保证原始数据流元素的数据顺序一致
		Stream<Employee> stream = employees.stream();
		
		// default Stream<E> parallelStream()
		// 返回一个并行流，多个线程同时从数据源中取数据，获取的元素顺序可能和原始数据源不一致
		Stream<Employee> parallelStream = employees.parallelStream();
    }
}

(2) 创建：通过数组创建

public class Main {

    public static void main(String[] args) {
    	int[] arr = {1, 2, 3, 4, 5, 6};
        // 调用Arrays类的 static <T>Stream<T> stream(T[] array) ：返回一个流
        IntStream stream = Arrays.stream(arr);
		
		Employee e1 = new Employee(1001, "马化腾", 34, 6000.38);
		Employee e2 = new Employee(1002, "马云", 12, 9876.12);
		Employee[] arr2 = {e1, e2};
		Stream<Employee> stream2 = Arrays.stream(arr2);
    }
}

(3) 创建：通过Stream类的静态方法of()

public class Main {

    public static void main(String[] args) {

        // Stream<T> Stream.of(T... values)，传入的是可变参数
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
    }
}

(4) 创建：使用Stream类创建无限流（了解）

$Stream.iterator()$ 和 $Stream.generate()$ 可以帮助我们造一些数据（如随机数、奇偶数等）。

public class Main {

    public static void main(String[] args) {

        // 方式一：迭代 iterate
        // public static <T>Stream<T> iterate(final T seed, final UnaryOperator<T> f)
        // UnaryOperator<T> extends Function<T, T> 抽象函数为 T apply(T t)
        // forEach是一个终止操作，需要传入一个消费型接口
        // 功能：遍历前10个偶数
        Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out :: println);

        // 方式二：生成 generate
        // public static <T>Stream<T> generate(Supplier<T> s)
        // 功能：输出10个随机数
        // 这里可以直接使用System.out :: println函数引用输出
        // 这么写只是为了演示一下装入集合的操作
        List<Double> list = new ArrayList<>();
        Stream.generate(Math :: random).limit(10).forEach(value -> list.add(value));
        for (Double value : list) {
            System.out.println(value);
        }
    }
}

3.2 Stream中间操作

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

(1) 中间操作：筛选与切片

public class Main {

    public static void main(String[] args) {
        List<Employee> list = EmployeeData.getEmployees();

        // filter(Predicate p) — 接收 Lambda，从流中排除某些元素
        Stream<Employee> stream = list.stream();
        // 练习：查询员工表中薪资大于7000的员工信息
        stream.filter(emp -> emp.getSalary() > 7000).forEach(System.out :: println); // 一旦使用了forEach,流就被关闭

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

		// skip(n) — 跳过元素，返回一个扔掉了前n个元素的流
		// 如果一个流中不满n个元素，则返回一个空流
		list.stream().skip(3).forEach(System.out :: println);

		// distinct() — 去重，通过流中元素的 hashCode() 和 equals() 去除重复元素
		list.stream().distinct().forEach(System.out :: println);
    }
}

(2) 中间操作：映射

// map(Function f)
public class Main {

    public static void main(String[] args) {
        // map(Function f) — 接收一个函数型接口作为参数，将元素转换成其他形式或提取信息
        List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
        list.stream().map(str -> str.toUpperCase()).forEach(System.out :: println);

		// 练习：获取员工姓名长度大于3的员工姓名
		List<Employee> employees = EmployeeData.getEmployees();
		// 写法一
		employees.stream().filter(emp -> emp.getName().length() > 3).map(Employee :: getName).forEach(System.out :: println);
		// 写法二：注意如果先进行map提取名字之后，Stream<Employee> 会变成 StringStream，然后再进行filter
		employees.stream().map(Employee :: getName).filter(s -> s.length() > 3).forEach(System.out :: println);
    }
}

// flatMap(Function f)
public class Main {
	// 'flat'的意思就是将流'压平了'，flatMap 和 map的区别，可以参考List.add() 和 List.addAll()的区别
    public static void main(String[] args) {
        List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
		
		// 一个例子，来体现map 和 flatMap的区别
		// Stream<String> -> Stream<Stream<Character>>
		Stream<Stream<Character>> streamStream = list.stream().map(Main :: fromStringToStream); // 类似于[[1], [2], [3], [4, 5, 6]]
		streamStream.forEach(stream -> {
			stream.forEach(System.out :: println);	// 显得麻烦
		});
		
		// flatMap(Function f) — 接收一个函数作为参数，将流中的每个值都转换为另一个流，然后把所有流都连成一个流
		Stream<Character> stream = list.stream().flatMap(Main :: fromStringToStream);
		stream.forEach(System.out :: println);
		// 因此，如果有类似于"流套流"的方式，如果你想遍历元素，优先使用flatMap
    }
	
	// 将一个字符串中的多个字符构成的的集合转换为对应的Stream类实例
	public static Stream<Character> fromStringToStream(String str) {
		ArrayList<Character> list = new ArrayList<>();
		for (Character c : str.toCharArray()) {
			list.add(c);
		}
		return list.stream();
	}
}

(3) 中间操作：排序

public class Main {

    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(12, 43, 65, 34, 87, 0, -98, 7);

        // sorted() - 自然排序：正序
        list.stream().sorted().forEach(System.out :: println);

        // sorted(Comparator comparator) - 定制排序：逆序
        list.stream().sorted((o1, o2) -> o2.compareTo(o1)).forEach(System.out :: println);

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

3.3 Stream终止操作

终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如 $List$、$Integer$，甚至是 $void$。

流进行了终止操作后，不能再使用。

(1) 终止操作：匹配与查找

public class Main {

    public static void main(String[] args) {
		List<Employee> employees = EmployeeData.getEmployees();

		// allMatch(Predicate p) - 检查是否匹配所有元素
		// 例子：是否所有的员工年龄都大于18
		bool allMatch = employees.stream().allMatch(emp -> emp.getAge() > 18);
		System.out.println(allMatch);

		// anyMatch(Predicate p) - 检查是否至少匹配一个元素
		// 例子：是否存在员工的工资大于10000
		bool anyMatch = employees.stream().anyMatch(emp -> emp.getSalary() > 10000.0);
		System.out.println(anyMatch);

		// noneMatch(Predicate p) - 检查是否没有匹配的元素
		// 例子：检查是否没有员工姓"雷"
		bool noneMatch = employees.stream().noneMatch(emp -> emp.getName().startsWith("雷"));
		System.out.println(noneMatch);

		// findFirst() - 返回第一个元素，这里结合薪资排序
		Optional<Employee> employee = employees.stream().sorted((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())).findFirst();	// Optional类之后会介绍
		System.out.println(employee);

		// findAny() - 返回当前流中的任意一个元素
		Optional<Employee> employee1 = employees.stream().findAny();
		System.out.println(employee1);
    }
}

public class Main {

    public static void main(String[] args) {
		List<Employee> employees = EmployeeData.getEmployees();
		
		// long count() - 返回当前流中元素的总个数
		// 例：获取工资大于10000 的员工总个数
		long count = employees.stream().filter(emp -> emp.getSalary() > 10000.0).count();
		System.out.println(count);

		// max(Comparator c) - 返回流中的最大值
		// 例：返回最高工资
		Optional<Double> maxSalary = employees.stream().map(emp -> emp.getSalary()).max(Double :: compare);
		System.out.println(maxSalary);

		// min(Comparator c) - 返回流中的最小值
		// 例：返回最低工资的员工
		Optional<Employee> employee = employees.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
		System.out.println(employee);

		// forEach(Consumer consumer) - 内部迭代
		employees.stream().forEach(System.out :: println);
		// 多说一句：集合自己也有一个内部迭代方式forEach(Consumer consumer)
		employees.forEach(System.out :: println);
		// 与内部迭代相对应的是使用 iterator的外部迭代方式
    }
}

(2) 终止操作：规约

public class Main {

    public static void main(String[] args) {
		// reduce(T identity, BinaryOperator b) - 可以将流中的元素反复结合起来，得到一个值，返回T
		// BinaryOperator<T> extends BiFunction<T, T, T>
		// BiFunction<T t1, T t2, T tsum> 
		// identity就是初始值
		// 在这里就相当于：第一次t1为第一个数，t2为第二个数，tsum为t1 + t2的
		// 第二次的时候将t1=上一次的tsum，t2为第三个数，tsum 为t1 + t2的和...
		// 例子：计算1-10的自然数的和
		// 写法1:
		Integer sum = Stream.iterator(1, t -> t + 1).limit(10).reduce(0, (t1, t2) -> t1 + t2);
		System.out.println(sum); 	// 55
		// 写法2: (t1, t2) -> t1 + t2 实现的接口可以用 Integer.sum(t1, t2) 代替，使用方法引用
		Integer sum2 = Stream.iterator(1, t -> t + 1).limit(10).reduce(0, Integer :: sum); 
		System.out.println(sum2);

		// reduce(BinaryOperator b) - 可以将流中的一个元素反复结合起来，得到一个值。返回Optional<T>
		// 例子：计算公司所有员工的工资总和
		List<Employee> employees = EmployeeData.getEmployees();
		Optional<Double> sumMoney = employees.stream().map(Emloyee :: getSalary).reduce(Double :: sum);
		System.out.println(sumMoney);
    }
}

(3) 终止操作：收集

public class Main {

    public static void main(String[] args) {
		// collect(Collector c) - 将流转换为其他形式。接收一个Collector接口的实现方法，用于给Stream中元素做汇总。
		// 例子：查找工资大于6000的员工，结果返回为一个List或Set
		List<Employee> employees = EmployeeData.getEmployees();
		// 用List收集
		List<Employee> employeeList = employees.stream().filter(e -> e.getSalary() > 6000.0).collect(Collections.toList());
		employeeList.forEach(System.out :: println);
		// 用Set收集
		Set<Employee> employeeSet = employees.stream().filter(e -> e.getSalary() > 6000.0).collect(Collections.toSet());
		employeeSet.forEach(System.out :: println);
    }
}

4. Stream的效率问题

这里引用另外两篇博客，写的很好，推荐一下：【Java 8 Stream的性能到底如何？】，【Java 8中用法优雅的Stream，性能也"优雅"吗？】。