JDK1.8新特性——Collector接口和Collectors工具类
JDK1.8新特性——Collector接口和Collectors工具类
摘要:本文主要学习了在Java1.8中新增的Collector接口和Collectors工具类,以及使用它们在处理集合时的改进和优化。
部分内容来自以下博客:
https://www.jianshu.com/p/7eaa0969b424
流式处理
JDK1.8中新增的流式处理提供了一种高效且易于使用的处理数据的方式,它可以对集合执行非常复杂的查找、过滤和映射数据等操作,极大的简化了对于集合的使用。借助流式处理,可以像使用SQL语句一样对集合进行操作。
JDK1.8通过内部迭代来实现对流的处理,一个流式处理可以分为三个部分:转换成流、中间操作、终止操作。
转换成流
对于集合,可以使用集合类中的stream()方法或者parallelStream()方法将集合转换成流。
中间操作
中间操作可以对流进行处理并返回处理后的流对象,多个中间操作可以连接起来形成一个流水线,直到执行终止操作结束流的执行。
终止操作
终止操作会对经过中间操作后得到的流进行处理,返回任何不是流的数据。
Collector接口
在对流进行的终止操作中,有一个方法是collect,其作用是收集元素并进行处理,最终返回处理后的非流对象。
查看其方法定义如下:
<R, A> R collect(Collector<? super T, A, R> collector);
可以看到,collect方法要求传入一个Collector接口的实例对象,Collector可以看做是用来处理流的工具,在Collectors里面封装了很多Collector工具。
全局变量
Collector主要包含五个参数,它的行为也是由这五个参数来定义的,如下所示:
// supplier参数用于生成结果容器,容器类型为A。
Supplier<A> supplier();
// accumulator用于归纳元素,泛型T就是元素,它会将流中的元素同结果容器A发生操作。
BiConsumer<A, T> accumulator();
// combiner用于合并两个并行执行的结果,将其合并为最终结果A。
BinaryOperator<A> combiner();
// finisher用于将之前完整的结果R转为A。
Function<A, R> finisher();
// characteristics表示当前Collector的特征值,是一个不可变的Set。
Set<Characteristics> characteristics();
枚举
Characteristics这个特征值是一个枚举:
enum Characteristics {
// 多线程并行。
CONCURRENT,
// 无序。
UNORDERED,
// 无需转换结果。
IDENTITY_FINISH
}
构造方法
Collector拥有两个of方法用于生成Collector实例,其中一个拥有上面所有五个参数,另一个四个参数,不包括finisher参数。
// 四参方法,用于生成一个Collector,T代表流中的元素,R代表最终的结果。因为没有finisher参数,所以需要有IDENTITY_FINISH特征值。
public static<T, R> Collector<T, R, R> of(Supplier<R> supplier,
BiConsumer<R, T> accumulator,
BinaryOperator<R> combiner,
Characteristics... characteristics) {
Objects.requireNonNull(supplier);
Objects.requireNonNull(accumulator);
Objects.requireNonNull(combiner);
Objects.requireNonNull(characteristics);
Set<Characteristics> cs = (characteristics.length == 0)
? Collectors.CH_ID
: Collections.unmodifiableSet(EnumSet.of(Collector.Characteristics.IDENTITY_FINISH,
characteristics));
return new Collectors.CollectorImpl<>(supplier, accumulator, combiner, cs);
} // 五参方法,用于生成一个Collector,T代表流中的元素,A代表中间结果,R代表最终结果,finisher用于将A转换为R。
public static<T, A, R> Collector<T, A, R> of(Supplier<A> supplier,
BiConsumer<A, T> accumulator,
BinaryOperator<A> combiner,
Function<A, R> finisher,
Characteristics... characteristics) {
Objects.requireNonNull(supplier);
Objects.requireNonNull(accumulator);
Objects.requireNonNull(combiner);
Objects.requireNonNull(finisher);
Objects.requireNonNull(characteristics);
Set<Characteristics> cs = Collectors.CH_NOID;
if (characteristics.length > 0) {
cs = EnumSet.noneOf(Characteristics.class);
Collections.addAll(cs, characteristics);
cs = Collections.unmodifiableSet(cs);
}
return new Collectors.CollectorImpl<>(supplier, accumulator, combiner, finisher, cs);
}
Collectors工具类
Collectors是一个工具类,是JDK预实现Collector的工具类,它内部提供了多种Collector。
toCollection方法
将流中的元素全部放置到一个集合中返回,这里使用Collection,泛指多种集合。
方法:
public static <T, C extends Collection<T>> Collector<T, ?, C> toCollection(Supplier<C> collectionFactory) {
return new CollectorImpl<>(
collectionFactory, Collection<T>::add,
(r1, r2) -> { r1.addAll(r2); return r1; },
CH_ID);
}
实例:
public static void main(String[] args) {
List<String> list = Arrays.asList("123", "521", "100", "228", "838", "250", "345");
System.out.println(list);// [123, 521, 100, 228, 838, 250, 345]
LinkedList<String> newList = list.stream().collect(Collectors.toCollection(LinkedList::new));
System.out.println(newList);// [123, 521, 100, 228, 838, 250, 345]
}
toList方法
将流中的元素放置到一个List集合中返回,默认为ArrayList。
方法:
public static <T>
Collector<T, ?, List<T>> toList() {
return new CollectorImpl<>(
(Supplier<List<T>>) ArrayList::new, List::add,
(left, right) -> { left.addAll(right); return left; },
CH_ID);
}
实例:
public static void main(String[] args) {
List<String> list = Arrays.asList("123", "521", "100", "228", "838", "250", "345");
System.out.println(list);// [123, 521, 100, 228, 838, 250, 345]
List<String> newList = list.stream().collect(Collectors.toList());
System.out.println(newList);// [123, 521, 100, 228, 838, 250, 345]
}
toSet方法
将流中的元素放置到一个Set集合中返回,默认为HashSet。
方法:
public static <T> Collector<T, ?, Set<T>> toSet() {
return new CollectorImpl<>(
(Supplier<Set<T>>) HashSet::new, Set::add,
(left, right) -> { left.addAll(right); return left; },
CH_UNORDERED_ID);
}
实例:
public static void main(String[] args) {
List<String> list = Arrays.asList("123", "521", "100", "228", "838", "250", "345");
System.out.println(list);// [123, 521, 100, 228, 838, 250, 345]
Set<String> newSet = list.stream().collect(Collectors.toSet());
System.out.println(newSet);// [100, 123, 521, 345, 228, 838, 250]
}
toMap方法
根据传入的键生成器和值生成器,将生成的键和值保存到一个Map中返回,键和值的生成都依赖于元素,可以指定出现重复键时的处理方案和保存结果的Map。
还有支持并发toConcurrentMap方法,同样有三种重载方法,与toMap基本一致,只是它最后使用的Map是并发ConcurrentHashMap。
方法:
// 指定键和值的生成方式,遇到键冲突的情况默认抛出异常,默认使用HashMap。
public static <T, K, U> Collector<T, ?, Map<K,U>> toMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper) {
return toMap(keyMapper, valueMapper, throwingMerger(), HashMap::new);
}
// 指定键和值的生成方式,遇到键冲突的情况使用传入的方法处理,默认使用HashMap。
public static <T, K, U> Collector<T, ?, Map<K,U>> toMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper,
BinaryOperator<U> mergeFunction) {
return toMap(keyMapper, valueMapper, mergeFunction, HashMap::new);
}
// 指定键和值的生成方式,遇到键冲突的情况使用传入的方法处理,使用传入的Map类型返回数据。前两种方式最终还是调用此方法来返回Map数据。
public static <T, K, U, M extends Map<K, U>> Collector<T, ?, M> toMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper,
BinaryOperator<U> mergeFunction,
Supplier<M> mapSupplier) {
BiConsumer<M, T> accumulator = (map, element) -> map.merge(
keyMapper.apply(element),
valueMapper.apply(element),
mergeFunction);
return new CollectorImpl<>(mapSupplier, accumulator, mapMerger(mergeFunction), CH_ID);
}
实例:
public static void main(String[] args) {
Map<String, String> newMap = null;
List<String> list = Arrays.asList("123", "521", "100", "228", "838", "250", "345");
System.out.println(list);// [123, 521, 100, 228, 838, 250, 345]
// 123和100的键都是1,导致冲突,默认抛出异常,使用limit截取前两个元素。
newMap = list.stream().limit(2).collect(Collectors.toMap(e -> e.substring(0, 1), e -> e));
System.out.println(newMap);// {1=123, 5=521}
// 传入主键冲突时的处理方法,保留先插入的值,默认使用HashMap,对主键由小到大排序。
newMap = list.stream().collect(Collectors.toMap(e -> e.substring(0, 1), e -> e, (m, n) -> m));
System.out.println(newMap);// {1=123, 2=228, 3=345, 5=521, 8=838}
// 传入主键冲突时的处理方法,保留新插入的值,默认使用LinkedHashMap,对主键按照插入顺序排序。
newMap = list.stream().collect(Collectors.toMap(e -> e.substring(0, 1), e -> e, (m, n) -> n, LinkedHashMap::new));
System.out.println(newMap);// {1=100, 5=521, 2=250, 8=838, 3=345}
}
joining方法
将流中的元素全部以字符串的方式连接到一起,可以指定连接符,也可以指定前后缀。
方法:
// 将流中的元素全部以字符串的方式连接到一起,不使用连接符,也不指定前后缀。
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);
}
// 将流中的元素全部以字符串的方式连接到一起,使用指定的连接符,不指定前后缀。
public static Collector<CharSequence, ?, String> joining(CharSequence delimiter) {
return joining(delimiter, "", "");
}
// 将流中的元素全部以字符串的方式连接到一起,使用指定的连接符,使用指定的前后缀。
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);
}
实例:
public static void main(String[] args) {
String str = null;
List<String> list = Arrays.asList("123", "521", "100", "228", "838", "250", "345");
System.out.println(list);// [123, 521, 100, 228, 838, 250, 345]
str = list.stream().collect(Collectors.joining());
System.out.println(str);//
str = list.stream().collect(Collectors.joining("-"));
System.out.println(str);// 123-521-100-228-838-250-345
str = list.stream().collect(Collectors.joining("-", "<", ">"));
System.out.println(str);// <123-521-100-228-838-250-345>
}
mapping方法
将流中的元素按照传入的方法进行处理,并将结果按照指定的格式返回。
方法:
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());
}
实例:
public static void main(String[] args) {
List<Score> scoreList = new ArrayList<Score>();
scoreList.add(new Score("2019", "10", "张三", 1));
scoreList.add(new Score("2019", "11", "李四", 1));
scoreList.add(new Score("2019", "12", "王五", 1));
List<String> names = scoreList.stream().collect(Collectors.mapping(Score::getName, Collectors.toList()));
System.out.println(names);// [张三, 李四, 王五]
}
collectingAndThen方法
该方法是按照传入的collector处理完之后,对归纳的结果进行再处理。
方法:
public static<T,A,R,RR> Collector<T,A,RR> collectingAndThen(
Collector<T,A,R> downstream,
Function<R,RR> finisher) {
Set<Collector.Characteristics> characteristics = downstream.characteristics();
if (characteristics.contains(Collector.Characteristics.IDENTITY_FINISH)) {
if (characteristics.size() == 1)
characteristics = Collectors.CH_NOID;
else {
characteristics = EnumSet.copyOf(characteristics);
characteristics.remove(Collector.Characteristics.IDENTITY_FINISH);
characteristics = Collections.unmodifiableSet(characteristics);
}
}
return new CollectorImpl<>(downstream.supplier(),
downstream.accumulator(),
downstream.combiner(),
downstream.finisher().andThen(finisher),
characteristics);
}
实例:
public static void main(String[] args) {
List<String> list = Arrays.asList("123", "521", "100", "228", "838", "250", "345");
System.out.println(list);// [123, 521, 100, 228, 838, 250, 345]
Integer size = list.stream().collect(Collectors.collectingAndThen(Collectors.toList(), List::size));
System.out.println(size);//
}
counting方法
该方法主要用来计数。
方法:
public static <T> Collector<T, ?, Long> counting() {
return reducing(0L, e -> 1L, Long::sum);
}
实例:
public static void main(String[] args) {
List<String> list = Arrays.asList("123", "521", "100", "228", "838", "250", "345");
System.out.println(list);// [123, 521, 100, 228, 838, 250, 345]
Long count = list.stream().collect(Collectors.counting());
System.out.println(count);//
}
reducing方法
对流中的元素做统计归纳,有三个重载方法,和Stream里的三个reduce方法对应,二者是可以替换使用的,作用完全一致。
方法:
// 返回一个可以直接产生Optional类型结果的Collector,没有初始值。
public static <T> Collector<T, ?, Optional<T>> reducing(BinaryOperator<T> op) {
class OptionalBox implements Consumer<T> {
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<T>>(
OptionalBox::new, OptionalBox::accept,
(a, b) -> { if (b.present) a.accept(b.value); return a; },
a -> Optional.ofNullable(a.value), CH_NOID);
}
// 返回一个可以直接产生结果的Collector,指定初始值。
public static <T> Collector<T, ?, T> reducing(T identity, BinaryOperator<T> 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);
}
// 返回一个可以直接产生结果的Collector,指定初始值,在返回结果之前先使用传入的方法将流进行转换。
public static <T, U> Collector<T, ?, U> reducing(
U identity,
Function<? super T, ? extends U> mapper,
BinaryOperator<U> 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);
}
实例:
public static void main(String[] args) {
List<String> list = Arrays.asList("123", "521", "100", "228", "838", "250", "345");
System.out.println(list);// [123, 521, 100, 228, 838, 250, 345]
Optional<Integer> optional = list.stream().limit(4).map(String::length).collect(Collectors.reducing(Integer::sum));
System.out.println(optional);// Optional[12]
Integer integer = list.stream().limit(3).map(String::length).collect(Collectors.reducing(0, Integer::sum));
System.out.println(integer);//
Integer sum = list.stream().limit(4).collect(Collectors.reducing(0, String::length, Integer::sum));
System.out.println(sum);//
}
minBy方法和maxBy方法
生成一个用于获取最小值或者最大值的Optional结果的Collector。
方法:
public static <T> Collector<T, ?, Optional<T>> minBy(Comparator<? super T> comparator) {
return reducing(BinaryOperator.minBy(comparator));
}
public static <T> Collector<T, ?, Optional<T>> maxBy(Comparator<? super T> comparator) {
return reducing(BinaryOperator.maxBy(comparator));
}
实例:
public static void main(String[] args) {
List<String> list = Arrays.asList("123", "521", "100", "228", "838", "250", "345");
System.out.println(list);// [123, 521, 100, 228, 838, 250, 345]
Optional<String> max = list.stream().collect(Collectors.maxBy((m, n) -> Integer.valueOf(m) - Integer.valueOf(n)));
System.out.println(max);// Optional[838]
Optional<String> min = list.stream().collect(Collectors.minBy((m, n) -> Integer.valueOf(m) - Integer.valueOf(n)));
System.out.println(min);// Optional[100]
}
summingInt方法、summingLong方法和summingDouble方法
生成一个用于求元素和的Collector,首先将元素转换类型,然后再求和。
参数的作用就是将元素转换为指定的类型,最后结果与转换后类型一致。
方法:
public static <T> 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);
}
public static <T> 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);
}
public static <T> Collector<T, ?, Double> summingDouble(ToDoubleFunction<? super T> mapper) {
return new CollectorImpl<>(
() -> new double[3],
(a, t) -> { sumWithCompensation(a, mapper.applyAsDouble(t));
a[2] += mapper.applyAsDouble(t); },
(a, b) -> { sumWithCompensation(a, b[0]);
a[2] += b[2]; return sumWithCompensation(a, b[1]); },
a -> computeFinalSum(a), CH_NOID);
}
实例:
public static void main(String[] args) {
List<String> list = Arrays.asList("123", "521", "100", "228", "838", "250", "345");
System.out.println(list);// [123, 521, 100, 228, 838, 250, 345]
Integer intCollect = list.stream().collect(Collectors.summingInt(Integer::parseInt));
System.out.println(intCollect);//
Long longCollect = list.stream().collect(Collectors.summingLong(Long::parseLong));
System.out.println(longCollect);//
Double doubleCollect = list.stream().collect(Collectors.summingDouble(Double::parseDouble));
System.out.println(doubleCollect);// 2405.0
}
summarizingInt方法、summarizingLong方法和summarizingDouble方法
这三个方法适用于汇总的,返回值分别是IntSummaryStatistics、LongSummaryStatistics和DoubleSummaryStatistics。
在这些返回值中包含有流中元素的指定结果的数量、和、最大值、最小值、平均值。
方法:
public static <T> 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(r); return l; }, CH_ID);
}
public static <T> 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(r); return l; }, CH_ID);
}
public static <T> 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(r); return l; }, CH_ID);
}
实例:
public static void main(String[] args) {
List<String> list = Arrays.asList("123", "521", "100", "228", "838", "250", "345");
System.out.println(list);// [123, 521, 100, 228, 838, 250, 345]
IntSummaryStatistics intSummaryStatistics = list.stream().collect(Collectors.summarizingInt(Integer::parseInt));
System.out.println(intSummaryStatistics);// {count=7, sum=2405, min=100, average=343.571429, max=838}
LongSummaryStatistics longSummaryStatistics = list.stream().collect(Collectors.summarizingLong(Long::parseLong));
System.out.println(longSummaryStatistics);// {count=7, sum=2405, min=100, average=343.571429, max=838}
DoubleSummaryStatistics doubleSummaryStatistics = list.stream().collect(Collectors.summarizingDouble(Double::parseDouble));
System.out.println(doubleSummaryStatistics);// {count=7, sum=2405.000000, min=100.000000, average=343.571429, max=838.000000}
}
averagingInt方法、averagingLong方法和averagingDouble方法
生成一个用于求元素平均值的Collector,首先将元素转换类型,然后再求平均值。
参数的作用就是将元素转换为指定的类型,求平均值涉及到除法操作,结果一律为Double类型。
方法:
public static <T> Collector<T, ?, Double> averagingInt(ToIntFunction<? super T> mapper) {
return new CollectorImpl<>(
() -> new long[2],
(a, t) -> { a[0] += mapper.applyAsInt(t); a[1]++; },
(a, b) -> { a[0] += b[0]; a[1] += b[1]; return a; },
a -> (a[1] == 0) ? 0.0d : (double) a[0] / a[1], CH_NOID);
}
public static <T> Collector<T, ?, Double> averagingLong(ToLongFunction<? super T> mapper) {
return new CollectorImpl<>(
() -> new long[2],
(a, t) -> { a[0] += mapper.applyAsLong(t); a[1]++; },
(a, b) -> { a[0] += b[0]; a[1] += b[1]; return a; },
a -> (a[1] == 0) ? 0.0d : (double) a[0] / a[1], CH_NOID);
}
public static <T> Collector<T, ?, Double> averagingDouble(ToDoubleFunction<? super T> mapper) {
return new CollectorImpl<>(
() -> new double[4],
(a, t) -> { sumWithCompensation(a, mapper.applyAsDouble(t)); a[2]++; a[3]+= mapper.applyAsDouble(t); },
(a, b) -> { sumWithCompensation(a, b[0]); sumWithCompensation(a, b[1]); a[2] += b[2]; a[3] += b[3]; return a; },
a -> (a[2] == 0) ? 0.0d : (computeFinalSum(a) / a[2]), CH_NOID);
}
实例:
public static void main(String[] args) {
List<String> list = Arrays.asList("123", "521", "100", "228", "838", "250", "345");
System.out.println(list);// [123, 521, 100, 228, 838, 250, 345]
double intAverage = list.stream().collect(Collectors.averagingInt(Integer::parseInt));
System.out.println(intAverage);// 343.57142857142856
double longAverage = list.stream().collect(Collectors.averagingLong(Long::parseLong));
System.out.println(longAverage);// 343.57142857142856
double doubleAverage = list.stream().collect(Collectors.averagingDouble(Double::parseDouble));
System.out.println(doubleAverage);// 343.57142857142856
}
groupingBy方法
生成一个拥有分组功能的Collector,有三个重载方法。
方法:
// 只需一个分组参数classifier,内部自动将结果保存到一个Map中,每个Map键的类型即classifier的结果类型,默认将组的元素保存在List中。
public static <T, K> Collector<T, ?, Map<K, List<T>>> groupingBy(
Function<? super T, ? extends K> classifier) {
return groupingBy(classifier, toList());
}
// 在上面方法的基础上增加了对流中元素的处理方式的Collector,默认是List。
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的生成方法,默认是HashMap。
public static <T, K, D, A, M extends Map<K, D>> Collector<T, ?, M> groupingBy(
Function<? super T, ? extends K> classifier,
Supplier<M> mapFactory,
Collector<? super T, A, D> downstream) {
Supplier<A> 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);
}
}
实例:
public static void main(String[] args) {
List<String> list = Arrays.asList("123", "521", "100", "228", "838", "250", "345");
System.out.println(list);// [123, 521, 100, 228, 838, 250, 345]
Map<String, List<String>> groupByFirst = list.stream().collect(Collectors.groupingBy(e -> e.substring(0, 1)));
System.out.println(groupByFirst);// {1=[123, 100], 2=[228, 250], 3=[345], 5=[521], 8=[838]}
Map<String, Set<String>> groupByLast = list.stream().collect(Collectors.groupingBy(e -> e.substring(e.length() - 1), Collectors.toSet()));
System.out.println(groupByLast);// {0=[100, 250], 1=[521], 3=[123], 5=[345], 8=[228, 838]}
Map<Integer, Set<String>> groupByLength = list.stream().collect(Collectors.groupingBy(String::length, HashMap::new, Collectors.toSet()));
System.out.println(groupByLength);// {3=[100, 123, 521, 345, 228, 838, 250]}
}
partitioningBy方法
将流中的元素按照给定的校验规则的结果分为两个部分,放到Map中返回,键是Boolean类型,值为元素的列表List。
方法:
// 只需一个校验参数predicate。
public static <T> Collector<T, ?, Map<Boolean, List<T>>> partitioningBy(Predicate<? super T> predicate) {
return partitioningBy(predicate, toList());
}
// 在上面方法的基础上增加了对流中元素的处理方式的Collector,默认的处理方法就是Collectors.toList()。
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<A>, T> accumulator = (result, t) ->
downstreamAccumulator.accept(predicate.test(t) ? result.forTrue : result.forFalse, t);
BinaryOperator<A> op = downstream.combiner();
BinaryOperator<Partition<A>> merger = (left, right) ->
new Partition<>(op.apply(left.forTrue, right.forTrue),
op.apply(left.forFalse, right.forFalse));
Supplier<Partition<A>> 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<A>, 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);
}
}
实例:
public static void main(String[] args) {
List<String> list = Arrays.asList("123", "521", "100", "228", "838", "250", "345");
System.out.println(list);// [123, 521, 100, 228, 838, 250, 345]
Map<Boolean, List<String>> moreThan = list.stream().collect(Collectors.partitioningBy(e -> Integer.parseInt(e) > 300));
System.out.println(moreThan);// {false=[123, 100, 228, 250], true=[521, 838, 345]}
Map<Boolean, Set<String>> lessThan = list.stream().collect(Collectors.partitioningBy(e -> Integer.parseInt(e) < 300, Collectors.toSet()));
System.out.println(lessThan);// {false=[521, 345, 838], true=[100, 123, 228, 250]}
}
JDK1.8新特性——Collector接口和Collectors工具类的更多相关文章
- JDK1.8新特性(一): 接口的默认方法default
前言 今天在学习mysql分区优化时,发现一个博客专家大神,对其发布的文章简单学习一下: 一:简介 我们通常所说的接口的作用是用于定义一套标准.约束.规范等,接口中的方法只声明方法的签名,不提供相应的 ...
- jdk1.8新特性之接口default方法
众所周知,default是java的关键字之一,使用场景是配合switch关键字用于条件分支的默认项.但自从java的jdk1.8横空出世以后,它就被赋予了另一项很酷的能力——在接口中定义非抽象方法. ...
- JDK1.8新特性(一) ----Lambda表达式、Stream API、函数式接口、方法引用
jdk1.8新特性知识点: Lambda表达式 Stream API 函数式接口 方法引用和构造器调用 接口中的默认方法和静态方法 新时间日期API default Lambda表达式 L ...
- JDK1.8新特性之(三)--函数式接口
在上一篇文章中我们介绍了JDK1.8的新特性有以下几项. 1.Lambda表达式 2.方法引用 3.函数式接口 4.默认方法 5.Stream 6.Optional类 7.Nashorm javasc ...
- jdk1.8新特性 : 接口中可以有普通方法(非静态方法)和静态方法 , 颠覆了之前我的理解 : 接口中只能有共有常量和抽象方法的概念,后面必须要加一句jdk1.7和1..7之前
看到jdk某些接口中存在default方法,于是... http://shaomeng95.iteye.com/blog/998820 为什么接口只能是公有常量? public interfac ...
- JDK1.8新特性——Stream API
JDK1.8新特性——Stream API 摘要:本文主要学习了JDK1.8的新特性中有关Stream API的使用. 部分内容来自以下博客: https://blog.csdn.net/icarus ...
- JDK1.7新特性
jdk1.7新特性 1 对集合类的语言支持: 2 自动资源管理: 3 改进的通用实例创建类型推断: 4 数字字面量下划线支持: 5 switch中使用string: 6 二进制字面量: 7 简化可变参 ...
- jdk1.6新特性
1.Web服务元数据 Java 里的Web服务元数据跟微软的方案基本没有语义上的区别,自从JDK5添加了元数据功能(Annotation)之后,SUN几乎重构了整个J2EE体 系, 由于变化很大,干脆 ...
- JDK1.8 新特性
jdk1.8新特性知识点: Lambda表达式 函数式接口 *方法引用和构造器调用 Stream API 接口中的默认方法和静态方法 新时间日期API https://blog.csdn.net/qq ...
随机推荐
- 【已解决】前端到后端400错误(The server cannot or will not process the request due to...)
看到400错误,一般是请求无效.出现该异常一般有三种情况: 第一种情况: 前端提交的内容在后端一般都用String类型来接收,用Date类型接收会报错. 第二种情况: 在提交表单的时候,填写的数据类型 ...
- css 揭秘-读书笔记
css 揭秘 [希]Lea verou 著 css 魔法 译 该书涵盖7大主题,47个css技巧,是css进阶必备书籍,开阔思路,探寻更优雅的解决方案.这本书完全用css渲染出的html写成的(布局. ...
- Ajax跨域请求,设置content
在使用Ajax跨域请求时,如果设置Header的ContentType为application/json,会分两次发送请求.第 一次先发送Method为OPTIONS的请求到服务器,这个请求会询问服务 ...
- JS基础语法---Math对象的案例
系统Max求最大值: var result= Math.max(10,20,30,40); console.log(result); 练习1:自己定义一个对象,实现系统的max的方法 //例子:自 ...
- 团队展示&选题
团队展示 1.队名:螺旋升天队 2.队员学号: 李光证 3117004660 (队长) 卢俊杰 3117004662 吴子昊 3117004671 陈浩民 3117004646 陈俊铭 3117004 ...
- hadoop访问50070
http://ip:50070 注意id必须是namenode节点才能访问,datanode不能访问
- Redis 找出大 key
系统: CentOS 7.4 64bit yum install python-pip gcc gcc-c++ python-devel git tmux -y pip install rdbtool ...
- EOJ Monthly 2019.11 E. 数学题(莫比乌斯反演+杜教筛+拉格朗日插值)
传送门 题意: 统计\(k\)元组个数\((a_1,a_2,\cdots,a_n),1\leq a_i\leq n\)使得\(gcd(a_1,a_2,\cdots,a_k,n)=1\). 定义\(f( ...
- 关于网站登录后的页面操作所携带的不同cookie值
对于课堂派网站,登录后的页面操作只需要携带PHPSESSID或者cookie中间那部分即可,两个都带也可,SERVERID不知道是干啥的,每次响应的都会变. 代码实现: cookie = None c ...
- LeetCode解题笔记 - 3. Longest Substring Without Repeating Characters
Given a string, find the length of the longest substring without repeating characters. Examples: Giv ...