Stream流式编程知识总结

Java8新特性系列：

• 《Lambda表达式你会吗》
• 《Stream流式编程知识总结》
• 《Stream流式编程实现原理》

本篇继上一篇《Lambda表达式你会吗》又一篇Java8新特性——流式编程，上篇文章中并没有采用Stream例子来装饰Lambda表达式，害怕有同学看不懂，所以在文章末尾留个彩蛋，本篇文章重点讲一下对Java8中流式编程的运用学习。

什么是Stream

Stream它并不是一个容器，它只是对容器的功能进行了增强，添加了很多便利的操作,例如查找、过滤、分组、排序等一系列的操作。并且有串行、并行两种执行模式，并行模式充分的利用了多核处理器的优势，使用fork/join框架进行了任务拆分，同时提高了执行速度。简而言之，Stream就是提供了一种高效且易于使用的处理数据的方式。

特点：

• Stream自己不会存储元素。
• Stream操作不会改变源对象。相反，他们会返回一个持有结果的新Stream。
• Stream操作是延迟执行的。它会等到需要结果的时候才执行。也就是执行终端操作的时候。

图解：

一个Stream的操作就如上图，在一个管道内，分为三个步骤：

• 第一步是创建Stream，从集合、数组中获取一个流；
• 第二步是中间操作链，对数据进行处理；
• 第三步是终端操作，用来执行中间操作链，返回结果；

为什么需要流式操作

集合API是Java API中最重要的部分。基本上每一个java程序都离不开集合。尽管很重要，但是现有的集合处理在很多方面都无法满足需要。

一个原因是，许多其他的语言或者类库以声明的方式来处理特定的数据模型，比如SQL语言，你可以从表中查询，按条件过滤数据，并且以某种形式将数据分组，而不必需要了解查询是如何实现的——数据库帮你做所有的脏活。这样做的好处是你的代码很简洁。很遗憾，Java没有这种好东西，你需要用控制流程自己实现所有数据查询的底层的细节。

其次是你如何有效地处理包含大量数据的集合。理想情况下，为了加快处理过程，你会利用多核架构。但是并发程序不太好写，而且很容易出错。

Stream API很好的解决了这两个问题。它抽象出一种叫做流的东西让你以声明的方式处理数据，更重要的是，它还实现了多线程：帮你处理底层诸如线程、锁、条件变量、易变变量等等。

怎么创建Stream

常用的Stream有三种创建方式：

• 集合 Collection.stream()
• 数组 Arrays.stream
• 静态方法 Stream.of

由集合创建

Java8 中的 Collection 接口被扩展，提供了两个获取流的方法,这两个方法是default方法，也就是说所有实现Collection接口的接口都不需要实现就可以直接使用：

1. default Stream stream() : 返回一个串行流。
2. default Stream parallelStream() : 返回一个并行流。

List<Integer> integerList = new ArrayList<>();
integerList.add(1);
integerList.add(2);
Stream<Integer> stream = integerList.stream();
Stream<Integer> stream1 = integerList.parallelStream();

由数组创建

Java8 中的 Arrays 的静态方法 stream() 可以获取数组流:

int[] array = {1,2,3};
Stream<Integer> stream = Arrays.stream(array);

由静态方法Stream.of创建

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

Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6, 7, 8);

准备数据

//计算机俱乐部
private static List<Student> computerClub = Arrays.asList(
        new Student("2015134001", "小明", 15, "1501"),
        new Student("2015134003", "小王", 14, "1503"),
        new Student("2015134006", "小张", 15, "1501"),
        new Student("2015134008", "小梁", 17, "1505")
);
//篮球俱乐部
private static List<Student> basketballClub = Arrays.asList(
        new Student("2015134012", "小c", 13, "1503"),
        new Student("2015134013", "小s", 14, "1503"),
        new Student("2015134015", "小d", 15, "1504"),
        new Student("2015134018", "小y", 16, "1505")
);
//乒乓球俱乐部
private static List<Student> pingpongClub = Arrays.asList(
        new Student("2015134022", "小u", 16, "1502"),
        new Student("2015134021", "小i", 14, "1502"),
        new Student("2015134026", "小m", 17, "1504"),
        new Student("2015134027", "小n", 16, "1504")
);

private static List<List<Student>> allClubStu = new ArrayList<>();
allClubStu.add(computerClub);
allClubStu.add(basketballClub);
allClubStu.add(pingpongClub);

以上数据用于下边的Stream的中间操作和终止操作实例说明。

Stream中间操作

如果Stream只有中间操作是不会执行的，当执行终端操作的时候才会执行中间操作，这种方式称为延迟加载或惰性求值。多个中间操作组成一个中间操作链，只有当执行终端操作的时候才会执行一遍中间操作链，下面看下Stream有哪些中间操作。

distinct

distinct: 对于Stream中包含的元素进行去重操作（去重逻辑依赖元素的equals方法），新生成的Stream中没有重复的元素；

List<String> list = Arrays.asList("b","b","c","a");
list.forEach(System.out::print); //bbca
list.stream().distinct().forEach(System.out::print);//bca

filter

filter: 对于Stream中包含的元素使用给定的过滤函数进行过滤操作，新生成的Stream只包含符合条件的元素；

//筛选1501班的学生
computerClub.stream().filter(e -> e.getClassNum().equals("1501")).forEach(System.out::println);
//筛选年龄大于15的学生
List<Student> collect = computerClub.stream().filter(e -> e.getAge() > 15).collect(Collectors.toList());

map

map: 对于Stream中包含的元素使用给定的转换函数进行转换操作，新生成的Stream只包含转换生成的元素。

这个方法有三个对于原始类型的变种方法，分别是：mapToInt，mapToLong和mapToDouble。这三个方法也比较好理解，比如mapToInt就是把原始Stream转换成一个新的Stream，这个新生成的Stream中的元素都是int类型。之所以会有这样三个变种方法，可以免除自动装箱/拆箱的额外消耗；

//篮球俱乐部所有成员名 + 暂时住上商标^_^,并且获取所有队员名
List<String> collect1 = basketballClub.stream()
        .map(e -> e.getName() + "^_^")
        .collect(Collectors.toList());
collect1.forEach(System.out::println);
//小c^_^^_^
//小s^_^^_^
//小d^_^^_^
//小y^_^^_^

flatMap

flatMap：和map类似，不同的是其每个元素转换得到的是Stream对象，会把子Stream中的元素压缩到父集合中；

//获取年龄大于15的所有俱乐部成员
List<Student> collect2 = Stream.of(basketballClub, computerClub, pingpongClub)
        .flatMap(e -> e.stream().filter(s -> s.getAge() > 15))
        .collect(Collectors.toList());
collect2.forEach(System.out::println);

//用双层list获取所有年龄大于15的俱乐部成员
List<Student> collect3 = allClubStu.stream()
        .flatMap(e -> e.stream().filter(s -> s.getAge() > 15))
        .collect(Collectors.toList());
collect3.forEach(System.out::println);

peek

peek: 生成一个包含原Stream的所有元素的新Stream，同时会提供一个消费函数（Consumer实例），新Stream每个元素被消费的时候都会执行给定的消费函数；

//篮球俱乐部所有成员名 + 赞助商商标^_^,并且获取所有队员详细内容
List<Student> collect = basketballClub.stream()
        .peek(e -> e.setName(e.getName() + "^_^"))
        .collect(Collectors.toList());
collect.forEach(System.out::println);
//Student{idNum='2015134012', name='小c^_^', age=13, classNum='1503'}
//Student{idNum='2015134013', name='小s^_^', age=14, classNum='1503'}
//Student{idNum='2015134015', name='小d^_^', age=15, classNum='1504'}
//Student{idNum='2015134018', name='小y^_^', age=16, classNum='1505'}

limit

limit: 对一个Stream进行截断操作，获取其前N个元素，如果原Stream中包含的元素个数小于N，那就获取其所有的元素；

List<String> list = Arrays.asList("a","b","c");
//获取list中top2即截断取前两个
List<String> collect1 = list.stream().limit(2).collect(Collectors.toList());
collect1.forEach(System.out::print);//ab

skip

skip: 返回一个丢弃原Stream的前N个元素后剩下元素组成的新Stream，如果原Stream中包含的元素个数小于N，那么返回空Stream；

List<String> list = Arrays.asList("a","b","c");
//获取list中top2即截断取前两个
List<String> collect1 = list.stream().skip(2).collect(Collectors.toList());
collect1.forEach(System.out::print);//c

sorted

sorted有两种形式存在：

1. sorted(Comparator): 指定比较规则进行排序。
2. sorted(): 产生一个新流，按照自然顺序排序。

List<String> list = Arrays.asList("b","c","a");
//获取list中top2即截断取前两个
List<String> collect1 = list.stream().sorted().collect(Collectors.toList());
collect1.forEach(System.out::print);//abc

Stream的终端操作

如果说Stream中间操作返回的是Stream，那么终端操作返回的就是最终转换需要返回的结果。

汇聚操作：

• foreach(Consumer c) 遍历操作
• collect(Collector) 将流转化为其他形式

其中Collectors具体方法有：

• toList List 把流中元素收集到List
• toSet Set 把流中元素收集到Set
• toCollection Coolection 把流中元素收集到Collection中
• groupingBy Map<K,List> 根据K属性对流进行分组
• partitioningBy Map<boolean, List> 根据boolean值进行分组

栗子：

//此处只是演示 此类需求直接用List构造器即可
List<Student> collect = computerClub.stream().collect(Collectors.toList());
Set<Student> collect1 = pingpongClub.stream().collect(Collectors.toSet());

//注意key必须是唯一的 如果不是唯一的会报错而不是像普通map那样覆盖
Map<String, String> collect2 = pingpongClub.stream()
        .collect(Collectors.toMap(Student::getIdNum, Student::getName));

//分组 类似于数据库中的group by
Map<String, List<Student>> collect3 = pingpongClub.stream()
        .collect(Collectors.groupingBy(Student::getClassNum));

//字符串拼接 第一个参数是分隔符 第二个参数是前缀 第三个参数是后缀
String collect4 = pingpongClub.stream().map(Student::getName).collect(Collectors.joining(",", "【", "】")); //【小u,小i,小m,小n】

//三个俱乐部符合年龄要求的按照班级分组
Map<String, List<Student>> collect5 = Stream.of(basketballClub, pingpongClub, computerClub)
        .flatMap(e -> e.stream().filter(s -> s.getAge() < 17))
        .collect(Collectors.groupingBy(Student::getClassNum));

//按照是否年龄>16进行分组 key为true和false
ConcurrentMap<Boolean, List<Student>> collect6 = Stream.of(basketballClub, pingpongClub, computerClub)
        .flatMap(Collection::stream)
        .collect(Collectors.groupingByConcurrent(s -> s.getAge() > 16));

匹配操作

• booelan allMatch(Predicate) 都符合
• boolean anyMatch(Predicate) 任一元素符合
• boolean noneMatch(Predicate) 都不符合

boolean b = basketballClub.stream().allMatch(e -> e.getAge() < 20);
boolean b1 = basketballClub.stream().anyMatch(e -> e.getAge() < 20);
boolean b2 = basketballClub.stream().noneMatch(e -> e.getAge() < 20);

寻找操作

• findFirst——返回第一个元素
• findAny——返回当前流中的任意元素

Optional<Student> first = basketballClub.stream().findFirst();
if (first.isPresent()) {
    Student student = first.get();
    System.out.println(student);
}

Optional<Student> any = basketballClub.stream().findAny();
if (any.isPresent()) {
    Student student2 = any.get();
    System.out.println(student2);
}
Optional<Student> any1 = basketballClub.stream().parallel().findAny();
System.out.println(any1);

计数和极值

• count 返回流中元素的总个数
• max(Comparator) 返回流中最大值
• min(Comparator) 返回流中最小值

long count = basketballClub.stream().count();
Optional<Student> max = basketballClub.stream().max(Comparator.comparing(Student::getAge));
if (max.isPresent()) {
    Student student = max.get();
}
Optional<Student> min = basketballClub.stream().min(Comparator.comparingInt(Student::getAge));
if (min.isPresent()) {
    Student student = min.get();
}

Fork/Join框架

上面我们提到过，说Stream的并行模式使用了Fork/Join框架，这里简单说下Fork/Join框架是什么？Fork/Join框架是java7中加入的一个并行任务框架，可以将任务拆分为多个小任务，每个小任务执行完的结果再合并成为一个结果。在任务的执行过程中使用工作窃取（work-stealing）算法，减少线程之间的竞争。

Fork/Join图解：

工作窃取图解:

什么是工作窃取算法？说白了就是多线程同步执行，当一个线程把自己队列任务完成后去“窃取”其他线程队列任务继续干。而在这时它们会访问同一个队列，所以为了减少窃取任务线程和被窃取任务线程之间的竞争，通常会使用双端队列，被窃取任务线程永远从双端队列的头部拿任务执行，而窃取任务的线程永远从双端队列的尾部拿任务执行。

最后

本篇文章大量的图片示例采用了RxJava图示说明，其实RxJava编程思想虽然是响应式编程，但是其操作符转换和流式编程如出一辙，本篇文章主要讲述Stream流式编程的认识和运用，有兴趣的小伙伴可以继续深入了解一下Stream的工作原理。

我是i猩人，总结不易，转载注明出处，喜欢本篇文章的童鞋欢迎点赞、关注哦。