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|
+--------------------+       +------+   +------+   +---+   +-------+

什么是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());
	}
}
-------------本文结束感谢您的阅读-------------