Stream流

从Java 8 之后进行提供，用来以“做什么而非怎么做的方式”来处理集合

1. 基本信息

1. 流不会存储元素，这些元素可能存储在底层的集合之中，或者是按需生成
2. 流操作不会修改数据源
3. 流的操作是尽可能惰性执行的。这意味着直到需要其结果，操作才会执行

2. 使用场景

某些场合之下，经常会对数据进行求和，去重，过滤等操作，但是自己手写起来又会比较麻烦，所以来说提供了一些API 给你进行使用，使用时调用API就可以了
但是这种方式来讲，调试会比较困难

3. 使用步骤

1. 从数据源获取流
2. 数据处理
3. 收集结果

3.1 获取数据源

可以将任何的集合转换成一个流

通过Collection中的**stream()**** 或者是 ****parallelStream()**

List<Integer>  list = Arrays.asList(1,2,3,4,5,6,7);

Stream<Integer> way1 = list.stream();

Stream<Integer> way2 = list.parallelStream();

通过Arrays中的静态方法**stream()**获取数组流

Integer [] arr = new Integer[4];

Stream<Integer> way3 = Arrays.stream(arr);

通过Stream类中的静态方法**of()**

Stream<Integer> way4 = Stream.of(1, 2, 3);

创建无限流：他里面的值是通过反复调用里面的函数进行获取

Stream<Integer> way5 = Stream.iterate(0, x -> x + 2);

3.2 数据处理

**filter：**转换会产生一个新的流，他的元素与某种条件相匹配

1. 他的参数是：Predicate接口，里面有一个返回值为boolean 类型的函数 test。

Predicate predicate = new Predicate<>() {
    @Override
    public boolean test(Object o) {
        return false;
    }
}

2. 通常在filter中使用lambda表达式

map：按照某种方式来转换流中的值

1. 可以使用map方法并传递执行该转换的函数
2. 通常，我们使用带有方法引用的map

抽取子流 和 组合流

1. limit(long maxSize)：返回当前流中最初的maxSize个元素
2. skip(long n)：当前流中除了前 n 个元素以外的元素
3. takeWhile（Predicate）：当前流中所有满足谓词条件的元素----->Java9
4. dropWhile(Predicate)：当前流中排除不满足谓词条件的元素之外的所有元素—>Java9
5. concat(Stream a,Stream b)：产生一个流，他的元素是 a 后面跟着 b 的元素—> Java9

其他流的转换

1. distinct()：产生一个流，包含当前流中所有不同的元素
2. sorted(Comparator)：如果说不传递参数，就要求元素实现Comparable类
3. peek(Consumer<? super T > action)：产生一个流，他与当前流中共的元素保持一致，在获取其中每一个元素的时候，会将其传递给action

3.3 收集结果

查看结果：**stream.forEach(System.out::pritln);**

list.stream().forEach(System.out::println);

将流中的元素收集到另一个目标之中

1. collect(Collectors接口实例)
2. 收集器是一种收集众多元素并产生单一结果的对象，Collectors中提供了大量用于生成常见收集器的工厂方法

/**
* 使用Collectors提供的工厂方法
* */
Set<Integer> s1 = list.stream().collect(Collectors.toSet());

/**
 * 控制获得的集的种类
* */
TreeSet<Integer> s2 = list.stream().collect(Collectors.toCollection(TreeSet::new));

/**
* 元素之间添加分隔符，流中元素是 字符串
* */
String s3 = list.stream().map(i -> i + "").collect(Collectors.joining(","));

收集到映射表中

1. 提供键值对：用户的ID作为map集合的键，用户名作为map集合的值

list.stream().collect(Collectors.toMap(Product::getID,Product::getName));

2. 分组:groupingBy(分组依据)，该方法会产生一个映射表，他的每个值都是一个列表，可以自己指定，也可以自己在该方法的第二个参数中指定

List<OrderItem> orderItemList = orderItemMapper.selectList(queryWrapper1);

Map<Long,List<OrderItem>> collect1 = orderItemList.stream().collect(Collectors.groupingBy(OrderItem::getOrderNo));

Map<Long, Set<OrderItem>> collect1 = orderItemList.stream().collect(Collectors.groupingBy(OrderItem::getOrderNo, Collectors.toSet()));

3. 如果说对这个列表中的元素进行处理，就需要提供一个方式，这种方式也叫做下游收集器

• counting():收集到元素的个数
• summing[Int | Long | Double]:产生他们的和
• maxBy 和 minBy会接受一个比较器，并分别产生下游元素中共的最大和最小值