java8-Stream

Java基础

浏览数:120

2019-7-22

AD:资源代下载服务

流的编程模型

通常使用流操作集合,用更简便的用法,更高效方式实现对集合的操作

从源中获取流 –> 中间操作 —> 汇聚流

我们在Stream基础上添加了一系列的中间操作,进一步加工Stream,终止操作操作会把Stream从新汇聚起来,我们可以选择统计数量,平均值,也可以选择把他们转换会集合的状态,得到新的集合

获取流的三种方式:

  • Stream的静态方法of()
支持可变参数
public static<T> Stream<T> of(T... values); 
  • Arrays的静态方法
Arrays.stream(数组)
  • 通过集合的stream方法
List<Integer> list = Arrays.asList(1, 2, 3);
Stream stream4 = list.stream();

中间操作 与 汇聚操作

中间操作方法 作用
filter(Predicate pre) 过滤, 接受参数,返回boolean,满足条件的stream被保存下来
limit(long maxSize) 从开始截取保留maxSize个元素
skip(long n) 从开始舍弃n元素
distinct() 去重
sorted() 排序
map(Function<T,R> fun) 接受T,映射成R并返回
flatMap(Function<T,R> fun) 接受T,映射成R并返回, 并将流打平
IntStream.range(start,end) IntStream特有的方法,生成[start , end-1]的流
IntStream.rangeClosed(start,end) IntStream特有的方法,生成[start , end]的流
汇聚操作方法 作用
sum() 求和
max(Comparator<? super T> comparator); 最大值
min(Comparator<? super T> comparator); 最小值
count() 返回元素的个数
T reduce(T identity, BinaryOperator accumulator) 汇聚,初始值identity, 每两个元素执行BinaryOperator规定的行为添加在identity上, 最终返回identity, 如累加
T reduce(BinaryOperator accumulator) 汇聚,初始值0, 每两个元素执行BinaryOperator规定的行为
collect(Collector col); 最长用的汇聚

如果我们中间把Stream转换成了特化流, 如IntStream, 那么sum(),min(),max()全是已经帮我们实现好了的,不用重写比较器

举个例子: 将数组中的元素 先*2, 再累加求和

// list是源
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5,6);
System.out.println(list.stream().map(i->i*2).reduce(0,(I,J)->I+J));
System.out.println(list.stream().map(i->i*2).reduce(0,Integer::sum));
  • 从源中获取流
  • 中间操作map映射,接受一个Function函数入参,接受一个参数返回一个值,上面我们把i映射成了2*i,
  • 汇聚操作,有重载, 我们选择有初始值的,设为0 , 第二个参数是BinaryOperator 继承了Bifunction, 接受两个相同类型的参数,返回一个值,上面是每两个元素进行求和

collect()

 List<String> list1 = Arrays.asList("hi", "你好", "hello");
 List<String> collect = list1.stream().collect(Collectors.toList());

上面可以看到,通过Collectors.toList()把流转换从新汇聚成了集合, 当然不仅仅局限于List

Collectors 作用
Collectors.toSet() 流汇聚成set
Collectors.toList() 流汇聚成List
Collectors.toMap() 流汇聚成Map
Collectors.toCollection(Supplier) 流汇指定类型的集合,Supplier,一般是构造方法引用
Collectors.toConcurrentMap() 流汇聚成toConcurrentMap
Collectors.joining() 将每个stream拼接起来

汇聚操作分三步走:

  • 创建出需要汇聚成的最终需要返回的集合对象
  • 将流中的每一个元素添加到集合对象中
  • 将集合对象返回
list1.stream().collect(()->new ArrayList<String>(),
    (theList,list1Item)->theList.add(list1Item),
    (result,list)->result.addAll(list));

使用方法引用的方式去实现

list1.stream().collect(ArrayList::new,ArrayList::add,ArrayList::addAll);

分组

将一个集合使用流的方式分组groupingBy(), 返回值Map<String,List >

Map<String, List<student>> map = list.stream().collect(Collectors.groupingBy(item -> item.getName()));

groupingBy的重载方法

Collector<T, ?, Map<K, D>> groupingBy(Function<? super T, ? extends K> classifier,
                                          Collector<? super T, A, D> downstream)`

第二个参数Collector,我们同样使用Collectors的静态方法实现, 它可以针对每一个小组进行下一步操作, 如求总数counting(),求平均值averagingInt(ToIntFunction())

分区

分区和分组相伴相生:

Collectors: 
Collector<T, ?, Map<Boolean, List<T>>> partitioningBy(Predicate<? super T> predicate)

入参是Predicate类型的,接受一个参数,返回boolean值, 分区实际上就是根据条件分成两组,只不过现在称它是两个区
例:

// 80分以前的为一个区,其他为一个区
Map<Boolean, List<student>> collect1 = list.stream().collect(Collectors.partitioningBy(i -> i.getScore() > 80));

// 低于80分的个数   高于80分的个数
Map<Boolean, Long> collect2 = list.stream().collect(Collectors.partitioningBy(j -> j.getScore() > 80, Collectors.counting()));
System.out.println(collect2);

map中,ture为满足条的组, flase为不满足条件的组

flatMap流的打平

例: 将多个相同类型的集合,打平成一个Stream,获取新集合

Stream.of(Arrays.asList(1),Arrays.asList(2,3),Arrays.asList(4,5,6))
 .flatMap(Collection::stream).map(i->i*i).collect(Collectors.toList()).forEach(System.out::println)

例: 将一个集合中元素去重

List<String> list = Arrays.asList("hello welcome", "world hello", "hello welcome world");
list.stream().map(item->item.split(" ")).flatMap(Arrays::stream).distinct().forEach(System.out::println);

当我们执行到这里,list.stream().map(item->item.split(" ")) 它的返回值类型是: Stream<String[]> 可以看到,是把源集合根据 空格 分成了多个Stream, 每一个Stream中包含的是复杂类型,数组,这样,我们再去重的话,其实是在数组之间的去重,而不是元素之间,因此我们需要将Stream<String[]>打平,转换成Stream<String str>,这样再去重就达到了我们的目的

例: 交叉打印

List<String> list1 = Arrays.asList("hi", "你好", "hello");
List<String> list2 = Arrays.asList("wangwu", "zhaoliu", "zhangsan", "lisi");

list1.stream().map(item1->list2.stream().map(item2->item1+"  "+item2)).forEach(System.out::println);

如上,并未做出Stream的打平,我们将list1中的每一个元素item 映射成, item+list2中的每一个元素, 但是出现的map的嵌套, 它的返回值是 Stream<Stream > , 接下来的内部迭代,迭代出的是第二层的Stream对象

所以我们要向下面那样,把流打平:

list1.stream().flatMap(item1->list2.stream().map(item2->item1+ " "+item2)).forEach(System.out::println);

总结: 当出现下面的返回情况时,考虑flatMap,打平流

  • Stream<List list>
  • Stream<String[] array>
  • Stream<Stream >

Stream的其他方法

 Stream<String> generate = Stream.generate(UUID.randomUUID()::toString);
 generate.findFirst().ifPresent(System.out::println);
 
 // 若不加限制,创建出无限流
 Stream<Integer> stream = Stream.iterate(1, i -> i + 2).limit(6);

特化的流

方法名 作用
map(Function<T,R>) Function<T,R> 接受T类型,映射成R类型
mapToInt(ToIntFunction ) 统一泛型 Integer
mapToDouble(ToDoubleFunction ) 统一泛型 Double
mapToLong(ToLongFunction ) 统一泛型 Long

如: mapToInt(item->item.lenth)我们可以把item映射成它的长度,进而可以进行下一步过滤等

转换成了特定流之后,可以实现特定的方法可以使用它替我们实现了 min,max,sort,avg针对特定类型的操作

流的惰性求值

例:

list.stream().map(item -> {
    String result = item.substring(0, 1).toUpperCase() + item.substring(1);
    System.out.println("test");
    return result;
}).forEach(System.out::println);

list.stream().map(item -> {
    String result = item.substring(0, 1).toUpperCase() + item.substring(1);
    System.out.println("test");
    return result;
});

参照文章一开始图片, Stream来资源, 我们在Stream基础上添加了一系列的中间操作Map,把每一个item的首字母转换成大写,进一步加工Stream,终止操作操作ForEach会把Stream从新汇聚起来, 流的惰性求值体现在哪里呢? 就是说,只要Stream没有碰到终止操作,我们添加在它身上的中间操作都不会被执行, 就像上面,我们把forEach()去嗲,text不会被打印

另外,添加的终止操作是forEach,这意味着她会遍历全部的元素,每一个Stream都会尝试被我们的中间操作处理; 但是,不一定一直是这个样,若我们把forEach替换成 findFirst(), 毫无疑问,只要出现一个单位的stream,成功被全部的中间操作处理,操作就停止了

这也是流的执行流程,并不是说我们在中间添加100个中间操作,流中的每一个单位Stream都得循环100次再执行终止操作, 相反,只有一个循环,这个100个中间组成的一个循环

流陷阱

流是一次性的,流被使用后,不能重复使用,但是如果我们调用Stream的中间操作返回了新的Stream,却不出现异常

作者:赐我白日梦