Java 提效神器 Stream 的冷门技巧

2401_84048554

于 2024-05-15 01:01:02 发布

阅读量321

点赞数 5

分类专栏：程序员文章标签： java rpc 开发语言

本文链接：https://blog.csdn.net/2401_84048554/article/details/138877573

版权

程序员专栏收录该内容

455 篇文章 0 订阅

订阅专栏

long count = values.parallelStream().sorted().count();

IntStream.range(a,b)

====================

可以直接生成从 a 到 b 的整数这里还是遵循编程语言的大多数约定，那就是含头不含尾。

IntStream.range(0, 10)

.forEach(System.out::println);

输出的结果是

new Random().ints()

===================

获取一系列的随机值，这个接口出来的数据是连续不断的，所以需要用limit来限制一下。

new Random().ints().limit(10).forEach(System.out::println);

Supplier

========

Supplier stringSupplier=String::new;

stringSupplier.get();

该接口就一个抽象方法get方法,不用传入任何参数,直接返回一个泛型T的实例.就如同无参构造一样

Consumer

========

1. accept方法

============

该函数式接口的唯一的抽象方法,接收一个参数,没有返回值.

2. andThen方法

=============

在执行完调用者方法后再执行传入参数的方法.

public class ConsumerTest {

public static void main(String[] args) {

Consumer consumer = (x) -> {

int num = x * 2;

System.out.println(num);

};

Consumer consumer1 = (x) -> {

int num = x * 3;

System.out.println(num);

};

consumer.andThen(consumer1).accept(10);

}

先执行了 consumer.accept(10) 然后执行了 consumer1.accept(10)

ifPresent

=========

针对一个optional 如果有值的话就执行否则不执行。

IntStream

.builder()

.add(1)

.add(3)

.add(5)

.add(7)

.add(11)

.build()

.average()

.ifPresent(System.out::println);

average 执行结果就是一个 optional

Collect

=======

他有两种调用方式

R collect(Supplier supplier,

BiConsumer<R, ? super T> accumulator,

BiConsumer<R, R> combiner);

<R, A> R collect(Collector<? super T, A, R> collector);

下面主要介绍一下这两种方式的使用方法：

1. 函数

======

第一种调用方式的接口如下

R collect(Supplier supplier,

BiConsumer<R, ? super T> accumulator,

BiConsumer<R, R> combiner);

supplier 这个参数就是提供一个容器，可以看到最后 collect 操作的结果是一个 R 类型变量，而 supplier 接口最后需要返回的也是一个 R 类型的变量，所以说这里返回的是收集元素的容器。
accumulator 参数，看到这个函数的定义是传入一个 R 容器，后面则是 T 类型的元素，需要将这个 T 放到 R 容器中，即这一步是用来将元素添加到容器中的操作。
conbiner 这个参数是两个容器，即当出现多个容器的时候容器如何进行聚合。

一个简单的例子：

String concat = stringStream.collect(StringBuilder::new, StringBuilder::append,StringBuilder::append).toString();

//等价于上面,这样看起来应该更加清晰

String concat = stringStream.collect(() -> new StringBuilder(),(l, x) -> l.append(x), (r1, r2) -> r1.append(r2)).toString();

2. Collector 接口

================

第二种方案是更高级的用法采用了 Collector 接口：

<R, A> R collect(Collector<? super T, A, R> collector);

可以看到他返回的还是一个 R 类型的变量，也就是容器。

Collector接口是使得collect操作强大的终极武器,对于绝大部分操作可以分解为旗下主要步骤,提供初始容器->加入元素到容器->并发下多容器聚合->对聚合后结果进行操作

static class CollectorImpl<T, A, R> implements Collector<T, A, R> {

private final Supplier supplier;

private final BiConsumer<A, T> accumulator;

private final BinaryOperator combiner;

private final Function<A, R> finisher;

private final Set characteristics;

CollectorImpl(Supplier supplier,

BiConsumer<A, T> accumulator,

BinaryOperator combiner,

Function<A,R> finisher,

Set characteristics) {

this.supplier = supplier;

this.accumulator = accumulator;

this.combiner = combiner;

this.finisher = finisher;

this.characteristics = characteristics;

}

CollectorImpl(Supplier supplier,

BiConsumer<A, T> accumulator,

BinaryOperator combiner,

Set characteristics) {

this(supplier, accumulator, combiner, castingIdentity(), characteristics);

}

@Override

public BiConsumer<A, T> accumulator() {

return accumulator;

}

@Override

public Supplier supplier() {

return supplier;

}

@Override

public BinaryOperator combiner() {

return combiner;

}

@Override

public Function<A, R> finisher() {

return finisher;

}

@Override

public Set characteristics() {

return characteristics;

}

可以看到我们可以直接 new CollectorImpl 然后将这些函数传入，另外还有一种简单的方式就是使用 Collector.of()依然可以直接传入函数。和 new CollectorImpl 是等价的。

3. 工具函数

========

1. toList()

============

容器: ArrayList::new

加入容器操作: List::add

多容器合并: left.addAll(right); return left;

public static

Collector<T, ?, List> toList() {

return new CollectorImpl<>((Supplier<List>) ArrayList::new, List::add,

(left, right) -> { left.addAll(right); return left; },

CH_ID);

}

2.joining()

===========

容器: StringBuilder::new

加入容器操作: StringBuilder::append

多容器合并: r1.append(r2); return r1;

聚合后的结果操作: StringBuilder::toString

public static Collector<CharSequence, ?, String> joining() {

return new CollectorImpl<CharSequence, StringBuilder, String>(

StringBuilder::new, StringBuilder::append,

(r1, r2) -> { r1.append(r2); return r1; },

StringBuilder::toString, CH_NOID);

}

3.groupingBy()

==============

roupingBy是toMap的一种高级方式,弥补了toMap对值无法提供多元化的收集操作,比如对于返回Map<T,List>这样的形式toMap就不是那么顺手,那么groupingBy的重点就是对Key和Value值的处理封装.分析如下代码,其中classifier是对key值的处理,mapFactory则是指定Map的容器具体类型,downstream为对Value的收集操作.

public static <T, K, D, A, M extends Map<K, D>>

Collector<T, ?, M> groupingBy(Function<? super T, ? extends K> classifier,

Supplier mapFactory,

Collector<? super T, A, D> downstream) {

…

}

一个简单的例子

//原生形式

Lists.newArrayList().stream()

.collect(() -> new HashMap<Integer,List>(),

(h, x) -> {

List value = h.getOrDefault(x.getType(), Lists.newArrayList());

value.add(x);

h.put(x.getType(), value);

HashMap::putAll

);

//groupBy形式

Lists.newArrayList().stream()

.collect(Collectors.groupingBy(Person::getType, HashMap::new, Collectors.toList()));

//因为对值有了操作,因此我可以更加灵活的对值进行转换

Lists.newArrayList().stream()

.collect(Collectors.groupingBy(Person::getType, HashMap::new, Collectors.mapping(Person::getName,Collectors.toSet())));

// 还有一种比较简单的使用方式只需要传递一个参数按照key来划分

Map<Integer, List> personsByAge = persons

.stream()

.collect(Collectors.groupingBy(p -> p.age));

4.reducing()

============

reducing是针对单个值的收集,其返回结果不是集合家族的类型,而是单一的实体类T

容器: boxSupplier(identity),这里包裹用的是一个长度为1的Object[]数组,至于原因自然是不可变类型的锅

加入容器操作: a[0] = op.apply(a[0], t)

多容器合并: a[0] = op.apply(a[0], b[0]); return a;

聚合后的结果操作: 结果自然是Object[0]所包裹的数据a -> a[0]

优化操作状态字段: CH_NOID

public static Collector<T, ?, T>

reducing(T identity, BinaryOperator op) {

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Java开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
yOperator op) {

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

[外链图片转存中…(img-dum6LUED-1715706050637)]

[外链图片转存中…(img-kVof9NYK-1715706050638)]

[外链图片转存中…(img-7PLb5DDf-1715706050638)]

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

2401_84048554

关注

5
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
Java 提效神器 Stream 的冷门技巧

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
复制链接

扫一扫