jdk8新特性之五Stream API

引言

Java 8 API添加了一个新的抽象称为流Stream,可以让你以一种声明的方式处理数据。
Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。
Stream API可以极大提高Java程序员的生产力,让程序员写出高效率、干净、简洁的代码。
这种风格将要处理的元素集合看作一种流, 流在管道中传输, 并且可以在管道的节点上进行处理, 比如筛选, 排序,聚合等。
元素流在管道中经过中间操作(intermediate operation)的处理,最后由最终操作(terminal operation)得到前面处理的结果。

1
2
3
+--------------------+       +------+   +------+   +---+   +-------+
| stream of elements +-----> |filter+-> |sorted+-> |map+-> |collect|
+--------------------+ +------+ +------+ +---+ +-------+

java8新特性

  1. jdk8新特性之一Lambda表达式
  2. jdk8新特性之二方法引用
  3. jdk8新特性之三函数式接口
  4. jdk8新特性之四默认方法
  5. jdk8新特性之五Stream API
  6. jdk8新特性之六Optional类
  7. jdk8新特性之七Nashorn JavaScript
  8. jdk8新特性之八日期时间API
  9. jdk8新特性之九Base64

什么是Stream?

Stream(流) 是一个来自数据源的元素队列并支持聚合操作

  • 元素是特定类型对象,形成一个队列。java中的Stream并不会存储元素,而是按需计算。
  • 数据由于 流的来源。可以是集合,数组,I/O channel , 产生器generator等。
  • 聚合操作 类似SQL语句一样操作,比如filter,map.reduce.find,match,sorted等。
    和以前的Collection操作不同,Stream操作还有两个基础特征:
  • Pipelinling:中间操作都会返回流对象本身。这样多个操作可以串联成一个管道,如同流式风格(fluent style)。这样做可以对操作进行优化,比如延迟执行(laziness)和短路(short-circuiting)。
  • 内部迭代:以前对集合遍历读书通过iterator或者for-each的方式,显式的在集合外部进行迭代,这叫做外部迭代。Stream提供了内部迭代方式,通过访问者模式(Visitor)实现。

生成流

有两种生成流的方法:
stream()-为集合创建串行流。
parallelStream()-为集合创建并行流。

1
2
3
4
5
6
7
8
9
10
11
12
List<String> list=Arrays.asList("a","b","c","d","e","f","g");
//创建串行流
Stream<String> stream=list.stream();
//创建并行流
Stream<String> stream2=list.parallelStream();
//串行流与并行流的区别:并行流简单理解就是多线程异步任务的一种实现。
//下面看看具体实例,串行流与并行流打印输出效果:
System.out.print("串行流:");
stream.forEach(str-> System.out.print(str));
System.out.println("");
System.out.print("并行流:");
stream2.forEach(str-> System.out.print(str));

运行输出结果为:

1
2
串行流:abcdefg
并行流:edgfbac

我们发现,使用parallelStream后,结果并不按照集合原有顺序输出。为了进一步证明该操作是并行的,我们打印出线程信息。

1
stream2.forEach(str-> System.out.println(Thread.currentThread().getName()+"->"+str));

运行输出结果为:

1
2
3
4
5
6
7
main->e
ForkJoinPool.commonPool-worker-1->b
ForkJoinPool.commonPool-worker-2->g
ForkJoinPool.commonPool-worker-1->c
main->d
ForkJoinPool.commonPool-worker-2->f
ForkJoinPool.commonPool-worker-3->a

通过例子可以确信parallelStream是利用多线程进行的,这可以很大程度简化我们使用并发操作。

forEach

Stream 提供了新的方法forEach来迭代流中的每个数据。

1
2
3
4
//使用foreach输出10个随机数
Random random=new Random();
System.out.println("随机10个数字:");
random.ints(10).forEach(System.out::println);

map

map 方法用于映射每个元素到对于的结果。

1
2
3
4
5
6
//map代码片段
List<Integer> muns=Arrays.asList(1,2,3,4,5,6,7,8,9);
//集合元素中值*2
muns=muns.stream().map(n-> n*2).collect(Collectors.toList());
System.out.println("使用map处理后结果:");
muns.stream().forEach(n->System.out.println(n));

filter

filter方法用于通过设置的条件过滤出元素。

1
2
3
4
List<Integer> muns=Arrays.asList(1,2,3,4,5,6,7,8,9);
System.out.println("使用filter处理后结果:");
//过滤元素大于5的数字,输出的数字是6-9
muns.stream().filter(n -> n>5).forEach(n->System.out.println(n));

limit

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

1
2
3
4
List<Integer> muns=Arrays.asList(1,2,3,4,5,6,7,8,9);
System.out.println("使用limit处理后结果:");
///获取前5条数据
muns.stream().limit(5).forEach(n->System.out.println(n));

sorted

sorted 方法用于对流进行自然排序。

1
2
3
4
5
List<Integer> muns2=Arrays.asList(1,3,5,4,10,6,2,8,7);
System.out.println("使用sorted把元素升序:");
//进行自然序排序
muns2.stream().sorted().forEach(System.out::println);
System.out.println("使用sorted把元素逆序:"); muns2.stream().sorted(Comparator.reverseOrder()).forEach(System.out::println);

也可以对集合中对象某个属性进行排序:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//创建实体,并且给年龄赋值
TestVo vo1=new TestVo();
vo1.setAge(18);

TestVo vo2=new TestVo();
vo2.setAge(15);

TestVo vo3=new TestVo();
vo3.setAge(20);

List<TestVo> voList=Arrays.asList(vo1,vo2,vo3);
System.out.println("对年龄进行升序:");
//对年龄进行升序
voList.stream().sorted(Comparator.comparing(TestVo :: getAge)).forEach(v-> System.out.println(v.getAge()));
System.out.println("对年龄进行降序:");
//对年龄进行降序
voList.stream().sorted(Comparator.comparing(TestVo :: getAge).reversed()).forEach(v-> System.out.println(v.getAge()));

Collectors

Collectors 类实现了很多归约操作,例如将流转换成集合和聚合元素。Collectors可用于返回列表或字符串:

1
2
3
4
5
6
List<String> list3=Arrays.asList("now","store","list","","e","f","g");
//对集合进行为空筛选并返回集合
List<String> filtered=list3.stream().filter(str -> !str.isEmpty()).collect(Collectors.toList());
System.out.println("筛选列表: " + filtered);
String strarray=list3.stream().filter(str ->! str.isEmpty()).collect(Collectors.joining(","));
System.out.println("合并字符串: " + strarray);

统计

一些产生统计结果的收集器也非常有用。它们主要用于int、double、long等基本类型上,它们可以用来产生类似如下的统计结果。

1
2
3
4
5
6
List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
IntSummaryStatistics stats=numbers.stream().mapToInt(x -> x).summaryStatistics();
System.out.println("列表中最大的数:"+stats.getMax());
System.out.println("列表中最小的数:"+stats.getMin());
System.out.println("所有数之和 : " + stats.getSum());
System.out.println("平均数 : " + stats.getAverage());

Stream 完整实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
package com.adanblog.demo;

import java.util.Arrays;
import java.util.Comparator;
import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;
import java.util.stream.Stream;import org.omg.Messaging.SyncScopeHelper;

/**
* java8新特性之五Stream
* @author www.adanblog.com
*
*/
public class StreamTest {
public static void main(String[] args) {
List<String> list=Arrays.asList("a","b","c","d","e","f","g");
//创建串行流
Stream<String> stream=list.stream();
//创建并行流
Stream<String> stream2=list.parallelStream();
//串行流与并行流的区别:并行流简单理解就是多线程异步任务的一种实现。
//下面看看具体实例,串行流与并行流打印输出效果:
System.out.print("串行流:");
stream.forEach(str-> System.out.print(str));
System.out.println("");
System.out.print("并行流:");
stream2.forEach(str-> System.out.print(str));
//验证并行流
//stream2.forEach(str-> System.out.println(Thread.currentThread().getName()+"->"+str));
System.out.println("");

//使用foreach输出10个随机数
Random random=new Random();
System.out.println("随机10个数字:");
random.ints(10).forEach(System.out::println);


//map代码片段
List<Integer> muns=Arrays.asList(1,2,3,4,5,6,7,8,9);
//集合元素中值*2
muns=muns.stream().map(n-> n*2).collect(Collectors.toList());
System.out.println("使用map处理后结果:");
muns.stream().forEach(n->System.out.println(n));

System.out.println("使用filter处理后结果:");
//过滤元素大于5的数字
muns.stream().filter(n->n>5).forEach(n->System.out.println(n));

System.out.println("使用limit处理后结果:");
///获取前5条数据
muns.stream().limit(5).forEach(n->System.out.println(n));

System.out.println("使用sorted把元素升序:");
List<Integer> muns2=Arrays.asList(1,3,5,4,10,6,2,8,7);
//进行自然序排序
muns2.stream().sorted().forEach(System.out::println);
System.out.println("使用sorted把元素逆序:");
muns2.stream().sorted(Comparator.reverseOrder()).forEach(System.out::println);

//创建实体,并且给年龄赋值
TestVo vo1=new TestVo();
vo1.setAge(18);

TestVo vo2=new TestVo();
vo2.setAge(15);

TestVo vo3=new TestVo();
vo3.setAge(20);

List<TestVo> voList=Arrays.asList(vo1,vo2,vo3);
System.out.println("对年龄进行升序:");
//对年龄进行升序
voList.stream().sorted(Comparator.comparing(TestVo :: getAge)).forEach(v-> System.out.println(v.getAge()));
System.out.println("对年龄进行降序:");
//对年龄进行降序
voList.stream().sorted(Comparator.comparing(TestVo :: getAge).reversed()).forEach(v-> System.out.println(v.getAge()));

List<String> list3=Arrays.asList("now","store","list","","e","f","g");
//对集合进行为空筛选并返回集合
List<String> filtered=list3.stream().filter(str -> !str.isEmpty()).collect(Collectors.toList());
System.out.println("筛选列表: " + filtered);
String strarray=list3.stream().filter(str ->! str.isEmpty()).collect(Collectors.joining(","));
System.out.println("合并字符串: " + strarray);

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
IntSummaryStatistics stats=numbers.stream().mapToInt(x -> x).summaryStatistics();
System.out.println("列表中最大的数:"+stats.getMax());
System.out.println("列表中最小的数:"+stats.getMin());
System.out.println("所有数之和 : " + stats.getSum());
System.out.println("平均数 : " + stats.getAverage());
}
}
-------------本文结束感谢您的阅读-------------