Stream 是数据渠道,用于操作数据源生成的元素序列,集合讲的是数据,流讲的是计算,就像粮食加工厂一样 粮食就是集合,加工厂就是Stream,对粮食进行一系列的操作。
用来以 做什么而非怎么做 的方式来处理集合
举一个梨子
现在有一个集合
List<String> strings = Arrays.asList("王1福", "王2福", "王3福", "小王8");
里面混入了一个奇怪的小王8,我想知道里面除了小王8的个数
以前的我
int count = 0;
for (String string : strings) {
if (!string.equals("小王8")) {
count++;
}
}
System.out.println(count);
会了Stream的我
long count = strings.stream().filter((x) -> !x.equals("小王8")).count();
System.out.println(count);
有人肯定会说笨b你都说混入一个奇怪的小王8了你直接获取个数减1不就行了!
我:????
那我现在要给他们排序然后输出
以前的我
Collections.sort(strings);
for (String string : strings) {
System.out.println(string);
}
会了Stream的我
strings.stream().sorted(String::compareTo).forEach(System.out::println);
有人肯定会说这不差不多吗?感觉没啥区别啊
那我现在要 取前3个,跳过第一个,然后排序,然后遍历输出
以前的我
不想写
会了Stream的我
strings.stream().limit(3).skip(1).sorted(String::compareTo).forEach(System.out::println);
首先你需要了解Lambda表达式 请看这里Lambda入门
Stream 有三个阶段 1.创建流 2.中间操作,可多步骤 3.终止操作,从而产生结果
流表面上和集合很相似,都可以让我们,转换和获取数据,但是他们中间存在很明显的差异
1.流不存储元素。
2.流的操作不好修改数据源,在我一开始的例子中Collections.sort就修改了数据源
3.流的操作都是惰性的
1.集合创建流
Collection接口的stream
List<String> strings = Arrays.asList("王1福", "王2福", "王3福", "小王8");
Stream<String> stream = strings.stream();
2.数组创建流
Arrays.stream()
String [] strings1={"王1福", "王2福", "王3福", "小王8"};
Stream<String> stream1 = Arrays.stream(strings1);
public static<T> Stream<T> of(T... values) {
return Arrays.stream(values);
}
Stream<Object> empty = Stream.empty();
Stream<Integer> integerStream = Stream.of(1, 2, 3);
Stream<Integer> iterate = Stream.iterate(0, (x) -> ++x);
filter:过滤流中的某些元素
limit(n):获取n个元素
skip(n):跳过n元素,配合limit(n)可实现分页
distinct:通过流中元素的 hashCode() 和 equals() 去除重复元素
map:将元素转换成其他形式或提取信息,将其映射成新的元素,将流添加进流中 与list的add
List<String> strings = Arrays.asList("a", "b", "c", "d");
Stream<String> stream = strings.stream();
stream.map(String::toUpperCase).forEach(System.out::print);//ABCD
map 是的结果是包含了应用该函数后所以产生的所有结果的流,如果它返回的不是一个值而是一个流
@Test
public void one() {
//List strings = Arrays.asList("王1福", "王2福", "王3福", "小王8");
List<String> strings = Arrays.asList("aaa", "bbbb", "cbbb", "dbbb");
Stream<String> stream = strings.stream();
Stream<Stream<String>> streamStream = stream.map(this::letters);
streamStream.forEach((x) -> {
x.forEach(System.out::print);
System.out.println();
});
}
Stream<String> letters(String s) {
ArrayList<String> result = new ArrayList<>();
for (int i = 0; i < s.length(); i++) {
result.add(s.substring(i, i + 1));
}
return result.stream();
}
输出
aaa
bbbb
cbbb
dbbb
flatMap:接收一个函数作为参数,将流中的每个值都换成另一个流,然后把所有流连接成一个流。
@Test
public void one() {
//List strings = Arrays.asList("王1福", "王2福", "王3福", "小王8");
List<String> strings = Arrays.asList("aaa", "bbbb", "cbbb", "dbbb");
Stream<String> stream = strings.stream();
Stream<String> stringStream = stream.flatMap(this::letters);
stringStream.forEach(System.out::print);//aaabbbbcbbbdbbb
}
注意:一个流终止后就不能用了 否则会报IllegalStateException
//流已被操作或关闭
java.lang.IllegalStateException: stream has already been operated upon or closed
sorted():返回由此流的元素组成的流,根据自然顺序排序
sorted(Comparator com):定制排序,根据提供的 Comparator进行排序。
List<String> strings = Arrays.asList("a", "d", "b", "c");
//dcba
strings.stream().sorted((a1, a2) -> a2.compareTo(a1)).forEach(System.out::print);
allMatch:是否匹配所有的元素
noneMatch:一个匹配的元素都没有
anyMatch:至少匹配一个元素
findFirst:返回流中第一个元素
findAny:返回流中的任意元素
count:返回流中元素的总个数
max:返回流中元素最大值
min:返回流中元素最小值
reduce :可以将流中元素反复结合起来 得到一个值
List<Integer> strings = Arrays.asList(1, 2, 3, 4);
//起始值
int loadVar=0;
Integer reduce = strings.stream().reduce(loadVar, (x, y) -> x + y);
collect:收集然后将其转换为其他形式,用于汇总操作
常用的一些操作
List<Integer> strings = Arrays.asList(1, 2, 3, 4);
//总数 4
Long collect = strings.stream().collect(Collectors.counting());
//int相加 其他类型也有 10
Integer collect1 = strings.stream().collect(Collectors.summingInt(x -> x));
//转成集合 [1, 2, 3, 4]
List<Integer> toList = strings.stream().collect(Collectors.toList());
//转成map {1=1, 2=2, 3=3, 4=4}
Map<Integer, Integer> collect3 = strings.stream().collect(Collectors.toMap((x) -> x, (x) -> x));
//分组 {1=[1], 2=[2], 3=[3], 4=[4]}
Map<Integer, List<Integer>> collect2 = strings.stream().collect(Collectors.groupingBy(x -> x));
//分区 {false=[1, 2], true=[3, 4]}
Map<Boolean, List<Integer>> collect4 = strings.stream().collect(Collectors.partitioningBy((x) -> x > 2));
collect2.forEach((key, val) -> System.out.println(key + "--" + val));
一个内容分成多个数据块,并用多个线程分别处理每个数据块
parallel 转换为 并行流
.sequential 转化为顺序流
Instant now = Instant.now();
long reduce = LongStream.range(0, 1000000000).parallel().reduce(0, (x, y) -> x + y);
Instant end = Instant.now();
System.out.println("消耗时间"+ Duration.between(now,end).toMillis() +"值"+reduce);
并行流试用的场景
1.Stream.interate 返回的结果不行
2.数据量很大时,不然没有意义
3.流的操作不应该阻塞
只有对已经存在内存中的数据执行大量计算时,才应该使用并行流
参考
https://www.bilibili.com/video/BV1gJ41137p2?p=21
Java核心技术卷二