Java Stream流中的实用操作，各种流操作的参考示例分析

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

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

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注Java）

正文

downstream.accumulator(),

downstream.combiner(),

downstream.finisher().andThen(finisher),

characteristics);

}

counting

========

/**

• 返回Collector中指定类型元素的数量

• @return Collector<T, ?, Long> 指定输入元素数量的收集器

*/

public static Collector<T, ?, Long> counting() {

return summingLong(e -> 1L);

}

groupingBy

==========

/**

• 返回一个对输入的指定类型的元素执行分组操作的Collector

• • 根据分组函数进行分组操作
• • 并将结果以Map类型返回

• @param classifier 指定的分组函数

• @return Collector<T, ?, Map<K, List>> Map类型的返回结果

*/

public static <T, K> Collector<T, ?, Map<K, List>> groupingBy(Function<? super T, ? extends K> classifier) {

return groupingBy(classifier, toList());

}

/**

• 返回一个对输入的指定类型的元素执行级联分组操作的Collector

• • 根据分组函数进行分组操作
• • 然后根据下游收集器对关联key的value值执行指定的规约操作

• @param classifier 指定的分组函数

• @param downstream 指定执行规约操作的下游收集器

• @return Collector<T, ?, Map<K, D>> 实现了级联分组操作的结果

*/

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

return groupingBy(classifier, HashMap::new, downstream);

}

/**

• 返回一个对输入的指定类型的元素执行级联分组操作的,并以指定的Map实现方式保存结果返回的Collector

• • 根据分组函数进行分组操作
• • 再根据下游收集器对关联key的value值执行指定的规约操作
• • 然后将结果保存到指定方式实现的Map中

• @param classifier 指定的分组函数

• @param mapFactory 指定的Map实现

• @param downstream 指定执行规约操作的下游收集器

• @return Collector<T, ?, M> 实现了级联分组操作的Collector结果

*/

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) {

Supplier downstreamSupplier = downstream.supplier();

BiConsumer<A, ? super T> downstreamAccumulator = downstream.accumulator();

BiConsumer<Map<K, A>, T> accumulator = (m, t) -> {

K key = Objects.requireNonNull(classifier.apply(t), “element cannot be mapped to a null key”);

A container = m.computeIfAbsent(key, k -> downstreamSupplier.get());

downstreamAccumulator.accept(container, t);

};

BinaryOperator<Map<K, A>> merger = Collectors.<K, A, Map<K, A>>mapMerger(downstream.combiner());

@SuppressWarnings(“unchecked”)

Supplier<Map<K, A>> mangledFactory = (Supplier<Map<K, A>>) mapFactory;

if (downstream.characteristics().contains(Collector.Characteristics.IDENTITY_FINISH)) {

return new CollectorImpl<>(mangledFactory, accumulator, merger, CH_ID);

}

else {

@SuppressWarnings(“unchecked”)

Function<A, A> downstreamFinisher = (Function<A, A>) downstream.finisher();

Function<Map<K, A>, M> finisher = intermediate -> {

intermediate.replaceAll((k, v) -> downstreamFinisher.apply(v));

@SuppressWarnings(“unchecked”)

M castResult = (M) intermediate;

return castResult;

};

return new CollectorImpl<>(mangledFactory, accumulator, merger, finisher, CH_NOID);

}

}

groupingByConcurrent

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

/**

• 返回一个对输入的指定类型的元素执行分组操作的并行Collector

• • 根据分组函数进行分组操作
• • 并将结果以Map类型返回

• @param classifier 指定的分组函数

• @return Collector<T, ?, ConcurrentMap<K, List>> 实现分组操作的并发无序的Collector

*/

public static <T, K> Collector<T, ?, ConcurrentMap<K, List>> groupingByConcurrent(Function<? super T, ? extends K> classifier) {

return groupingByConcurrent(classifier, ConcurrentHashMap::new, toList());

}

/**

• 返回一个对输入的指定类型的元素执行级联分组操作的并行Collector

• • 根据分组函数进行分组操作
• • 然后根据下游收集器对关联key的指定value值执行指定的规约操作

• @param classifier 指定的分组函数

• @downstream 指定执行规约操作的下游收集器

• @return Collector<T, ?, ConcurrentMap<K, D>> 实现分组操作的并发无序的Collector

*/

public static <T, K, A, D> Collector<T, ?, ConcurrentMap<K, D>> groupingByConcurrent(Function<? super T, ? extends K> classifier, Collector<? super T, A, D> downstream) {

return groupingByConcurrent(classifier, ConcurrentHashMap::new, downstream);

}

/**

• 返回一个对输入的指定类型的元素执行级联分组操作的并行Collector

• • 根据分组函数进行分组操作
• • 再根据下游收集器对关联key的指定value值执行指定的规约操作
• • 然后将结果保存到指定方式实现的Map中

• @param classifier 指定的分组函数

• @param mapFactory 指定的Map实现

• @downstream 指定执行规约操作的下游收集器

• @return Collector<T, ?, ConcurrentMap<K, D>> 实现分组操作的并发无序的Collector

*/

public static <T, K, A, D, M extends ConcurrentMap<K, D>> Collector<T, ?, M> groupingByConcurrent(Function<? super T, ? extends K> classifier, Supplier mapFactory, Collector<? super T, A, D> downstream) {

Supplier downstreamSupplier = downstream.supplier();

BiConsumer<A, ? super T> downstreamAccumulator = downstream.accumulator();

BinaryOperator<ConcurrentMap<K, A>> merger = Collectors.<K, A, ConcurrentMap<K, A>>mapMerger(downstream.combiner());

@SuppressWarnings(“unchecked”)

Supplier<ConcurrentMap<K, A>> mangledFactory = (Supplier<ConcurrentMap<K, A>>) mapFactory;

BiConsumer<ConcurrentMap<K, A>, T> accumulator;

if (downstream.characteristics().contains(Collector.Characteristics.CONCURRENT)) {

accumulator = (m, t) -> {

K key = Objects.requireNonNull(classifier.apply(t), “element cannot be mapped to a null key”);

A resultContainer = m.computeIfAbsent(key, k -> downstreamSupplier.get());

downstreamAccumulator.accept(resultContainer, t);

};

}

else {

accumulator = (m, t) -> {

K key = Objects.requireNonNull(classifier.apply(t), “element cannot be mapped to a null key”);

A resultContainer = m.computeIfAbsent(key, k -> downstreamSupplier.get());

synchronized (resultContainer) {

downstreamAccumulator.accept(resultContainer, t);

}

};

}

if (downstream.characteristics().contains(Collector.Characteristics.IDENTITY_FINISH)) {

return new CollectorImpl<>(mangledFactory, accumulator, merger, CH_CONCURRENT_ID);

}

else {

@SuppressWarnings(“unchecked”)

Function<A, A> downstreamFinisher = (Function<A, A>) downstream.finisher();

Function<ConcurrentMap<K, A>, M> finisher = intermediate -> {

intermediate.replaceAll((k, v) -> downstreamFinisher.apply(v));

@SuppressWarnings(“unchecked”)

M castResult = (M) intermediate;

return castResult;

};

return new CollectorImpl<>(mangledFactory, accumulator, merger, finisher, CH_CONCURRENT_NOID);

}

}

joining

=======

/**

• 返回一个根据接收元素的顺序将元素连接成一个String字符串的Collector

• @return Collector<CharSequence, ?, String> 根据接收元素的顺序将元素连接成一个字符串的Collector

*/

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);

}

/**

• 返回一个根据接收元素的顺序将元素连接成一个String字符串并以指定的分隔符分割的Collector

• @param delimiter 用于每个元素之间的分割符

• @return Collector<CharSequence, ?, String> 根据接收元素的顺序将元素连接成一个字符串并以指定分割符分割的Collector

*/

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

return joining(delimiter, “”, “”);

}

/**

• 返回一个根据接收元素的顺序将元素连接成一个String字符串并以指定的分隔符分割和指定前缀和后缀的Collector

• @param delimiter 用于每个元素之间的分割符

• @param prefix 指定的前缀

• @param suffix 指定的后缀

• @return Collector<CharSequence, ?, String> 根据接收元素的顺序将元素连接成一个字符串并以指定分割符分割和指定的前缀和后缀的Collector

*/

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

return new CollectorImpl<>(

() -> new StringJoiner(delimiter, prefix, suffix),

StringJoiner::add, StringJoiner::merge,

StringJoiner::toString, CH_NOID);

}

mapping

=======

/**

• 在累积元素之前应用映射函数将类型为U的收集器调整为类型为T的收集器

• mapping操作对多级规约操作最有用

• @param mapper 映射函数

• @param downstream 下游收集器

• @return Collector<T, ?, R> 执行映射函数操作后的收集器

*/

public static <T, U, A, R> Collector<T, ?, R> mapping(Function<? super T, ? extends U> mapper, Collector<? super U, A, R> downstream) {

BiConsumer<A, ? super U> downstreamAccumulator = downstream.accumulator();

return new CollectorImpl<>(downstream.supplier(),

(r, t) -> downstreamAccumulator.accept(r, mapper.apply(t)),

downstream.combiner(), downstream.finisher(),

downstream.characteristics());

}

maxBy

=====

/**

• 返回一个根据给定的比较器Comparator生成最大元素的Collector,使用Optional描述

• @param comparator 指定的比较器

• @return Collector<T, ?, Optional> 根据比较器生成最大元素的Collector

*/

public static Collector<T, ?, Optional> maxBy(Comparator<? super T> comparator) {

return reducing(BinaryOperator.maxBy(comparator));

}

minBy

=====

/**

• 返回一个根据给定的比较器Comparator生成最小元素的Collector,使用Optional描述

• @param comparator 指定的比较器

• @return Collector<T, ?, Optional> 根据比较器生成最小元素的Collector

*/

public static Collector<T, ?, Optional> (Comparator<? super T> comparator) {

return reducing(BinaryOperator.minBy(comparator));

}

partitioningBy

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

/**

• 返回一个根据指定规则分类的Collector,结果保存到Map<Boolean, List>中

• @param predicate 指定的分类规则

• @return Collector<T, ?, Map<Boolean, List>> 按照指定规则进行分类,并将结果保存到Map<Boolean, List>的收集器

*/

public static Collector<T, ?, Map<Boolean, List>> partitioningBy(Predicate<? super T> predicate) {

return partitioningBy(predicate, toList());

}

/**

• 返回一个根据指定规则分类的Collector,并将结果值按照下游收集器执行规约操作,然后将规约后的结果保存到Map<Boolean, D>中

• @param predicate 指定的分类规则

• @param downstream 指定的执行规约操作的下游收集器

• @return Collector<T, ?, Map<Boolean, D>> 按照指定规则进行分类,并将结果值按照下游收集器执行规约操作,然后将规约后的结果保存到Map<Boolean, D>的收集器

*/

public static <T, D, A> Collector<T, ?, Map<Boolean, D>> partitioningBy(Predicate<? super T> predicate, Collector<? super T, A, D> downstream) {

BiConsumer<A, ? super T> downstreamAccumulator = downstream.accumulator();

BiConsumer<Partition, T> accumulator = (result, t) ->

downstreamAccumulator.accept(predicate.test(t) ? result.forTrue : result.forFalse, t);

BinaryOperator op = downstream.combiner();

BinaryOperator<Partition> merger = (left, right) ->

new Partition<>(op.apply(left.forTrue, right.forTrue),

op.apply(left.forFalse, right.forFalse));

Supplier<Partition> supplier = () ->

new Partition<>(downstream.supplier().get(),

downstream.supplier().get());

if (downstream.characteristics().contains(Collector.Characteristics.IDENTITY_FINISH)) {

return new CollectorImpl<>(supplier, accumulator, merger, CH_ID);

}

else {

Function<Partition, Map<Boolean, D>> finisher = par ->

new Partition<>(downstream.finisher().apply(par.forTrue),

downstream.finisher().apply(par.forFalse));

return new CollectorImpl<>(supplier, accumulator, merger, finisher, CH_NOID);

}

}

reducing

========

/**

• 返回一个按照指定的规约操作获得结果的Colletor.结果以Optional描述

• @param op 指定的规约操作

• @return Collector<T, ?, Optional> 按照指定的规约操作执行的结果

*/

public static Collector<T, ?, Optional> reducing(BinaryOperator op) {

class OptionalBox implements Consumer {

T value = null;

boolean present = false;

@Override

public void accept(T t) {

if (present) {

value = op.apply(value, t);

}

else {

value = t;

present = true;

}

}

}

return new CollectorImpl<T, OptionalBox, Optional>(

OptionalBox::new, OptionalBox::accept,

(a, b) -> { if (b.present) a.accept(b.value); return a; },

a -> Optional.ofNullable(a.value), CH_NOID);

}

/**

• 返回一个使用指定标识,按照指定的规约操作获得结果的Colletor

• @param identity 指定的标识,也是结果为空时的返回值

• @param op 指定的规约操作

• @return Collector<T, ?, T> 按照指定的规约操作执行的结果,当结果为空时返回指定的标识identity

*/

public static Collector<T, ?, T> reducing(T identity, BinaryOperator op) {

return new CollectorImpl<>(

boxSupplier(identity),

(a, t) -> { a[0] = op.apply(a[0], t); },

(a, b) -> { a[0] = op.apply(a[0], b[0]); return a; },

a -> a[0],

CH_NOID);

}

/**

• 返回一个使用指定标识,按照指定的映射操作和规约操作获得结果的Colletor

• @param identity 指定的标识,也是结果为空时的返回值

• @param mapper 指定的映射操作

• @param op 指定的规约操作

• @return Collector<T, ?, Optional> 按照指定的映射操作和规约操作执行的结果,当结果为空时返回指定的标识identity

*/

public static <T, U> Collector<T, ?, U> reducing(U identity, Function<? super T, ? extends U> mapper, BinaryOperator op) {

return new CollectorImpl<>(

boxSupplier(identity),

(a, t) -> { a[0] = op.apply(a[0], mapper.apply(t)); },

(a, b) -> { a[0] = op.apply(a[0], b[0]); return a; },

a -> a[0], CH_NOID);

}

summarizingDouble

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

/**

• 返回一个使用double类型映射每一个输入元素并返回结果值汇总信息的Collector

• @param mapper 指定的映射操作

• @return Collector<T, ?, DoubleSummaryStatistics> 汇总信息的规约操作

*/

public static Collector<T, ?, DoubleSummaryStatistics> summarizingDouble(ToDoubleFunction<? super T> mapper) {

return new CollectorImpl<T, DoubleSummaryStatistics, DoubleSummaryStatistics>(

DoubleSummaryStatistics::new,

(r, t) -> r.accept(mapper.applyAsDouble(t)),

(l, r) -> { l.combine®; return l; }, CH_ID);

}

summarizingInt

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

/**

• 返回一个使用int类型映射每一个输入元素并返回结果值汇总信息的Collector

• @param mapper 指定的映射操作

• @return Collector<T, ?, IntSummaryStatistics> 汇总信息的规约操作

*/

public static Collector<T, ?, IntSummaryStatistics> summarizingInt(ToIntFunction<? super T> mapper) {

return new CollectorImpl<T, IntSummaryStatistics, IntSummaryStatistics>(

IntSummaryStatistics::new,

(r, t) -> r.accept(mapper.applyAsInt(t)),

(l, r) -> { l.combine®; return l; }, CH_ID);

}

summarizingLong

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

/**

• 返回一个使用long类型映射每一个输入元素并返回结果值汇总信息的Collector

• @param mapper 指定的映射操作

• @return Collector<T, ?, IntSummaryStatistics> 汇总信息的规约操作

*/

public static Collector<T, ?, LongSummaryStatistics> summarizingLong(ToLongFunction<? super T> mapper) {

return new CollectorImpl<T, LongSummaryStatistics, LongSummaryStatistics>(

LongSummaryStatistics::new,

(r, t) -> r.accept(mapper.applyAsLong(t)),

(l, r) -> { l.combine®; return l; }, CH_ID);

}

summingDouble

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

/**

• 返回一个使用double类型映射每一个输入元素并返回元素之和的Collector

• 如果不存在元素则返回0

• @param mapper 指定的映射操作

• @return Collector<T, ?, Double> 执行元素求和规约操作的Collector

*/

public static Collector<T, ?, Double> summingDouble(ToDoubleFunction<? super T> mapper) {

/*

• 在为收集操作分配的数组中:

• 索引0 - 运行和的高位

• 索引1 - 补偿计算的和的低阶位求和

• 索引2 - 当存在无穷大结果和时正确的符号

*/

return new CollectorImpl<>(

() -> new double[3],

(a, t) -> { double val = mapper.applyAsDouble(t);

sumWithCompensation(a, val);

a[2] += val;},

(a, b) -> { sumWithCompensation(a, b[0]);

a[2] += b[2];

return sumWithCompensation(a, b[1]); },

a -> computeFinalSum(a),

CH_NOID);

}

summingInt

==========

/**

• 返回一个使用int类型映射每一个输入元素并返回元素之和的Collector

• 如果不存在元素则返回0

• @param mapper 指定的映射操作

• @return Collector<T, ?, Integer> 执行元素求和规约操作的Collector

*/

public static Collector<T, ?, Integer> summingInt(ToIntFunction<? super T> mapper) {

return new CollectorImpl<>(

() -> new int[1],

(a, t) -> { a[0] += mapper.applyAsInt(t); },

(a, b) -> { a[0] += b[0]; return a; },

a -> a[0], CH_NOID);

}

summingLong

===========

/**

• 返回一个使用long类型映射每一个输入元素并返回元素之和的Collector

• 如果不存在元素则返回0

• @param mapper 指定的映射操作

• @return Collector<T, ?, Integer> 执行元素求和规约操作的Collector

*/

public static Collector<T, ?, Long> summingLong(ToLongFunction<? super T> mapper) {

return new CollectorImpl<>(

() -> new long[1],

(a, t) -> { a[0] += mapper.applyAsLong(t); },

(a, b) -> { a[0] += b[0]; return a; },

a -> a[0], CH_NOID);

}

toCollection

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

/**

• 返回一个将接收的元素按照接收顺序放入生成的集合的Collector

• @param collectionFactory 指定的生成的集合

• @return Collector<T, ?, C> 将接收的元素按照接收顺序生成集合的Collector

*/

public static <T, C extends Collection> Collector<T, ?, C> toCollection(Supplier collectionFactory) {

return new CollectorImpl<>(collectionFactory, Collection::add,

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

CH_ID);

}

toConcurrentMap

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

/**

• 返回一个将接收的元素放入并发的Map中的并发Collector,其中Map的key和value按照指定的映射函数生成

• @param keyMapper 键的映射器

• @param valueMapper 值的映射器

• @return Collector<T, ?, ConcurrentMap<K,U>> 将接收的元素按照放入并发的Map中的并发无序Collector

*/

public static <T, K, U> Collector<T, ?, ConcurrentMap<K,U>> toConcurrentMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper) {

return new CollectorImpl<>(ConcurrentHashMap::new,

uniqKeysMapAccumulator(keyMapper, valueMapper),

uniqKeysMapMerger(),

CH_CONCURRENT_ID);

}

/**

• 返回一个将接收的元素放入并发的Map中的并发Collector,其中Map的key和value按照指定的映射函数生成

• 如果存在重复的键值,则会应用指定的合并函数

• @param keyMapper 键的映射器

• @param valueMapper 值的映射器

• @param mergeFunction 指定的合并函数

• @return Collector<T, ?, ConcurrentMap<K,U>> 将接收的元素按照放入并发的Map中的并发Collector

*/

public static <T, K, U> Collector<T, ?, ConcurrentMap<K,U>> toConcurrentMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator mergeFunction) {

return toConcurrentMap(keyMapper, valueMapper, mergeFunction, ConcurrentHashMap::new);

}

/**

• 返回一个将接收的元素放入指定方式实现的并发Map中的并发Collector,其中Map的key和value按照指定的映射函数生成

• 如果存在重复的键值,则会应用指定的合并函数

• @param keyMapper 键的映射器

• @param valueMapper 值的映射器

• @param mergeFunction 指定的合并函数

• @param mapFactory 指定的Map实现方式

• @return Collector<T, ?, M> 将接收的元素按照放入指定方式实现的并发Map中的并发Collector

*/

public static <T, K, U, M extends ConcurrentMap<K, U>> Collector<T, ?, M> toConcurrentMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper,BinaryOperator mergeFunction,Supplier mapFactory) {

BiConsumer<M, T> accumulator

= (map, element) -> map.merge(keyMapper.apply(element),

valueMapper.apply(element), mergeFunction);

return new CollectorImpl<>(mapFactory, accumulator, mapMerger(mergeFunction), CH_CONCURRENT_ID);

}

toList

======

/**

• 返回一个将接收的元素按照接收的顺序放入List中的收集器Collector

• @return Collector<T, ?, List> 包含输入元素的List类型的收集器Collector

*/

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

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

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

CH_ID);

}

toMap

=====

/**

• 返回一个将接收的元素放入Map中的Collector,其中Map的key和value按照指定的映射函数生成

• @param keyMapper 键映射函数

• @param valueMapper 值映射函数

• @return Collector<T, ?, Map<K,U>> 将接收的元素放入Map中的Collector

*/

public static <T, K, U> Collector<T, ?, Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper) {

return new CollectorImpl<>(HashMap::new,

uniqKeysMapAccumulator(keyMapper, valueMapper),

uniqKeysMapMerger(),

CH_ID);

}

/**

• 返回一个将接收的元素放入Map中的Collector,其中Map的key和value按照指定的映射函数生成

• 如键重复,则使用指定的合并函数合并

• @param keyMapper 键映射函数

• @param valueMapper 值映射函数

• @param mergeFunction 指定的合并函数

• @return Collector<T, ?, Map<K,U>> 将接收的元素放入Map中的Collector

*/

public static <T, K, U> Collector<T, ?, Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator mergeFunction) {

return toMap(keyMapper, valueMapper, mergeFunction, HashMap::new);

}

/**

• 返回一个将接收的元素放入指定实现方式的Map中的Collector,其中Map的key和value按照指定的映射函数生成

• 如键重复,则使用指定的合并函数合并

• @param keyMapper 键映射函数

• @param valueMapper 值映射函数

• @param mergeFunction 指定的合并函数

• @param mapFactory 指定的Map实现方式

• @return Collector<T, ?, Map<K,U>> 将接收的元素放入指定实现方式的Map中的Collector

*/

public static <T, K, U, M extends Map<K, U>> <T, ?, M> toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator mergeFunction, mapFactory) {

BiConsumer<M, T> accumulator

= (map, element) -> map.merge(keyMapper.apply(element),

valueMapper.apply(element), mergeFunction);

return new CollectorImpl<>(mapFactory, accumulator, mapMerger(mergeFunction), CH_ID);

}

toSet

=====

/**

• 返回一个将接收的元素放入Set中的收集器Collector

• @return Collector<T, ?, Set> 将接收的元素放入Set中的Collector

*/

public static Collector<T, ?, Set> toSet() {

return new CollectorImpl<>((Supplier<Set>) HashSet::new, Set::add,

(left, right) -> {

if (left.size() < right.size()) {

right.addAll(left); return right;

} else {

left.addAll(right); return left;

}

},

CH_UNORDERED_ID);

}

统计

==

• 产生统计结果的收集器,主要用于int,double,long等类型

List numbers = Arrays.asList(3, 2, 3, 7, 3, 5);

IntSummaryStatistics stats = numbers.stream().mapToInt((x) -> x).summaryStatistics();

System.out.println(“列表中最大的数:” + stats.getMax());

最后

Java架构进阶面试及知识点文档笔记

这份文档共498页，其中包括Java集合，并发编程，JVM，Dubbo,Redis，Spring全家桶，MySQL，Kafka等面试解析及知识点整理

Java分布式高级面试问题解析文档

其中都是包括分布式的面试问题解析，内容有分布式消息队列，Redis缓存，分库分表，微服务架构，分布式高可用，读写分离等等！

互联网Java程序员面试必备问题解析及文档学习笔记

Java架构进阶视频解析合集

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

==

/**

• 返回一个将接收的元素放入Set中的收集器Collector

• @return Collector<T, ?, Set> 将接收的元素放入Set中的Collector

*/

public static Collector<T, ?, Set> toSet() {

return new CollectorImpl<>((Supplier<Set>) HashSet::new, Set::add,

(left, right) -> {

if (left.size() < right.size()) {

right.addAll(left); return right;

} else {

left.addAll(right); return left;

}

},

CH_UNORDERED_ID);

}

统计

==

• 产生统计结果的收集器,主要用于int,double,long等类型

List numbers = Arrays.asList(3, 2, 3, 7, 3, 5);

IntSummaryStatistics stats = numbers.stream().mapToInt((x) -> x).summaryStatistics();

System.out.println(“列表中最大的数:” + stats.getMax());

最后

Java架构进阶面试及知识点文档笔记

这份文档共498页，其中包括Java集合，并发编程，JVM，Dubbo,Redis，Spring全家桶，MySQL，Kafka等面试解析及知识点整理

[外链图片转存中…(img-fW1foDbW-1713605903025)]

Java分布式高级面试问题解析文档

其中都是包括分布式的面试问题解析，内容有分布式消息队列，Redis缓存，分库分表，微服务架构，分布式高可用，读写分离等等！

[外链图片转存中…(img-125O1NVh-1713605903026)]

互联网Java程序员面试必备问题解析及文档学习笔记

[外链图片转存中…(img-znoNJVq2-1713605903026)]

Java架构进阶视频解析合集

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-g0FCd7H6-1713605903027)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！