JDK1.8中Stream的相关操作

什么是流？
Stream（流）是一个来自数据源的元素队列并支持聚合操作

元素是特定类型的对象，形成一个队列。 Java中的Stream并不会存储元素，而是按需计算。
数据源 流的来源。 可以是集合，数组，I/O channel， 产生器generator 等。
聚合操作 类似SQL语句一样的操作， 比如filter, map, reduce, find, match, sorted等。
和以前的Collection操作不同， Stream操作还有两个基础的特征：

Pipelining: 中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道， 如同流式风格（fluent style）。 这样做可以对操作进行优化， 比如延迟执行(laziness)和短路( short-circuiting)。

内部迭代： 以前对集合遍历都是通过Iterator或者For-Each的方式, 显式的在集合外部进行迭代， 这叫做外部迭代。 Stream提供了内部迭代的方式， 通过访问者模式(Visitor)实现。

Stream 不是集合元素，它不是数据结构并不保存数据，它是有关算法和计算的，它更像一个高级版本的 Iterator。原始版本的 Iterator，用户只能显式地一个一个遍历元素并对其执行某些操作；高级版本的 Stream，用户只要给出需要对其包含的元素执行什么操作，比如 “过滤掉长度大于 10 的字符串”、“获取每个字符串的首字母”等，Stream 会隐式地在内部进行遍历，做出相应的数据转换。

Stream 就如同一个迭代器（Iterator），单向，不可往复，数据只能遍历一次，遍历过一次后即用尽了，就好比流水从面前流过，一去不复返。而和迭代器又不同的是，Stream 可以并行化操作，迭代器只能命令式地、串行化操作。顾名思义，当使用串行方式去遍历时，每个 item 读完后再读下一个 item。而使用并行去遍历时，数据会被分成多个段，其中每一个都在不同的线程中处理，然后将结果一起输出。

• 串行与并行

测试：

 String[] str = {"1","2","3","4","5"};
         List<String> strs = Arrays.asList(str);
         strs.stream().forEach(o-> System.out.print(o));
         System.out.println();
         strs.parallelStream().forEach(o-> System.out.print(o));

结果为：

12345
35421

有关parallelStream详细信息参照：
https://blog.csdn.net/darrensty/article/details/79283146
stream中常用的方法：

- forEach

Stream 提供了新的方法 ‘forEach’ 来迭代流中的每个数据。并消耗这个流，传入item，不会返回任何值：

Random random = new Random();
random.ints().limit(10).forEach(System.out::println);

- map

map 方法用于映射每个元素到对应的结果，但是不会消耗流，而是生成一个新的流，与forEach的区别为：map不会消耗流，而是生成一个新的流，用作后续处理，并且有返回值：

  List<Integer> nums = Arrays.asList(new Integer[]{0, 1, 2, 3, 4, 5});
  nums.stream().map(i->++i).forEach(System.out::print);
   
   结果为：1 2 3 4 5 6

• peek

peek，它是参数是一个Consumer，peek不会改变当前的流，只是用于中间操作，与map 的区别为：peek不会生成一个新的流，而是返回当前的流，适用于中间操作：

      List<Integer> nums = Arrays.asList(new Integer[]{0, 1, 2, 3, 4, 5});
      nums.stream().peek(i->++i).forEach(System.out::print);
   
   结果为：0 1 2 3 4 5

- filter 方法用于通过设置的条件过滤出元素，生成新的流

  List<Integer> nums = Arrays.asList(new Integer[]{0, 1, 2, 3, 4, 5});
  nums.stream().filter(i -> i > 3).forEach(i -> System.out.print(i));
  
  结果为：4	5

- limit方法用于获取指定数量的流；

List<Integer> nums = Arrays.asList(new Integer[]{0, 1, 2, 3, 4, 5});
nums.stream().limit(4).forEach(i -> System.out.println(i));

结果为：0 1 2 3

- sorted方法用于对流进行排序，生成一个新的流：

正序

List<Integer> nums = Arrays.asList(new Integer[]{0, 1, 2, 3, 4, 5});
nums.stream().sorted().forEach(System.out::println);

结果为：0 1 2 3 4 5 

倒序

        List<Integer> nums = Arrays.asList(new Integer[]{0, 1, 2, 3, 4, 5});
        nums.stream().sorted((i,j)->i>j?-1:1).forEach(System.out::print);

结果为：5 4 3 2 1 0

• count 方法不言而喻，结束掉这个流，计算它的长度：

        List<Integer> nums = Arrays.asList(new Integer[]{0, 1, 2, 3, 4, 5});
        long count = nums.stream().count();

结果为：6

• mapToxxx:可以把一个流变成其他流，下面列的这些流有计算操作：max,min,sum…，注意其返回值不是Stream<>，其他方法可以自己测试

        List<Integer> nums = Arrays.asList(new Integer[]{0, 1, 2, 3, 4, 5});
        int sum = nums.stream().mapToInt(i -> i).sum();
        System.out.println(sum);

结果为：15

• Collectors
  类实现了很多归约操作，例如将流转换成集合和聚合元素，collect会消耗掉流，从而聚合出一个Collection。Collectors
  可用于返回列表或字符串：

测试类：

@Data
public class Student {
   private Integer id;
   private String name;
   private Integer age;
}

构造测试数据：
mapToObj就不说了。。。看上面就懂

        List<Student> students = IntStream.rangeClosed(0, 10)
                .mapToObj(i -> {
                    Student student = new Student();
                    student.setId(i);
                    student.setName("张三" + i);
                    return student;
                })
                .peek(sut -> sut.setAge(15))
                .peek(System.out::println)
                .collect(Collectors.toList());

结合使用：自己脑补，多试试就好啦