JAVA8学习9-自定义收集器（Characteristics 使用说明）

最新推荐文章于 2024-05-21 11:11:26 发布
最新推荐文章于 2024-05-21 11:11:26 发布
阅读量1.9k 收藏 7
点赞数 4
分类专栏： java 文章标签： java8 自定义收集器 Characteristics
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z_yemu/article/details/89401321
版权

9 自定义收集器

​ 在自定义收集器前，我们再确定下 Collector 接口函数接收参数和该实现的方法。

public interface Collector<T, A, R> {
  // A 结果类型，T 中间操作类型，R 最终返回类型，一般情况下，A=R
    Supplier<A> supplier(); // 源数据对象类型（中间操作对象类型）
    BiConsumer<A, T> accumulator();// T 中间操作类型
    BinaryOperator<A> combiner(); //并发 合并部分结果
    Function<A, R> finisher();// 可选，对结果集的转换
		Set<Characteristics> characteristics(); // 当前收集器的特性
  
    enum Characteristics {
        CONCURRENT,// 标识收集器是一个并发的
        UNORDERED,// 收集操作不能保证保留顺序
        IDENTITY_FINISH // 标识 finisher 就是 identity（同一性） 函数，类型转换要求必须成功。
    }
}

自定义一个set收集器,我们需要分别实现五个方法，事例代码：

package cn.zxhysy.jdk8.stream2;

import java.util.*;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collector;

import static java.util.stream.Collector.Characteristics.IDENTITY_FINISH;
import static java.util.stream.Collector.Characteristics.UNORDERED;

public class MySetCollector<T> implements Collector<T, Set<T>, Set<T>> {


    @Override
    public Supplier supplier() {
        System.out.println("suppliier invoked!");
        return HashSet::new;
    }

    @Override
    public BiConsumer<Set<T>, T> accumulator() {
        System.out.println("accmulator invoked!");

        return Set::add;
//        return HashSet::add;// 不可以写这个，因为类型可能与supplier中的类型冲突
    }

    @Override
    public BinaryOperator<Set<T>> combiner() {
        System.out.println("combiner invoked!");

        return (set1, set2) -> {
            set1.addAll(set2);
            return set1;
        };
    }

  // 声明 IDENTITY_FINISH 后方法不会执行，默认是Java底层自动实现。
    @Override
    public Function<Set<T>,Set<T>> finisher() {
        System.out.println("finisher invoked!");
//        return t -> t;
//        return Function.identity();
      	throw new UnsupportedOperationException();
    }

    @Override
    public Set<Characteristics> characteristics() {
        System.out.println("characteristics invoked");
        return Collections.unmodifiableSet(EnumSet.of(IDENTITY_FINISH, UNORDERED));
    }

    public static void main(String[] args) {
        List<String> list = Arrays.asList("hello", "world", "welcome", "hello");
        Set<String> collect = list.stream().collect(new MySetCollector<>());
        System.out.println(collect);
    }
}

java底层执行过程：

public final <R, A> R collect(Collector<? super P_OUT, A, R> collector) {
    A container;
  // 这里characteristics 会被调用第1次
    if (isParallel()
            && (collector.characteristics().contains(Collector.Characteristics.CONCURRENT))
            && (!isOrdered() || collector.characteristics().contains(Collector.Characteristics.UNORDERED))) {
        container = collector.supplier().get();
        BiConsumer<A, ? super P_OUT> accumulator = collector.accumulator();
        forEach(u -> accumulator.accept(container, u));
    }
    else {
        container = evaluate(ReduceOps.makeRef(collector));// 调用此处方法
    }
  // 这里characteristics 会被调用第二次
    return collector.characteristics().contains(Collector.Characteristics.IDENTITY_FINISH)
           ? (R) container
           : collector.finisher().apply(container);
}

public static <T, I> TerminalOp<T, I>
makeRef(Collector<? super T, I, ?> collector) {
    Supplier<I> supplier = Objects.requireNonNull(collector).supplier();//此处调用
    BiConsumer<I, ? super T> accumulator = collector.accumulator();// 调用
    BinaryOperator<I> combiner = collector.combiner();// 调用
    class ReducingSink extends Box<I>
            implements AccumulatingSink<T, I, ReducingSink> {
        @Override
        public void begin(long size) {
            state = supplier.get();
        }

        @Override
        public void accept(T t) {
            accumulator.accept(state, t);
        }

        @Override
        public void combine(ReducingSink other) {
            state = combiner.apply(state, other.state);
        }
    }
    return new ReduceOp<T, I, ReducingSink>(StreamShape.REFERENCE) {
        @Override
        public ReducingSink makeSink() {
            return new ReducingSink();
        }

        @Override
        public int getOpFlags() {
            return collector.characteristics().contains(Collector.Characteristics.UNORDERED)
                   ? StreamOpFlag.NOT_ORDERED
                   : 0;
        }
    };
}
9.1 Characteristics 使用说明：

  1. IDENTITY_FINISH 表明 finisher 就是 identity 函数，可以省略。如果设置，则必须是从A（中间结果类型）到R（最终结果类型）的未经检查的强制转换成功，不然就会报类型转换错误，一般如果A和R的类型一致，就可以设置，此时设置之后，就不会调用finisher，java自己进行强转

  2. CONCURRENT 表示此收集器是并发的，简单点说，加CONCURRENT ，意味着使用 parallelStream，产生多少个线程了，都只有一个中间容器， accumulator 在执行时，由于中间容器在只有一个的情况下，要求不能有一边查询和一边修改的操作，不然会抛 ConcurrentModificationException 异常，且由于只有一个中间容器，所以不调用 combiner 定义的回调方法的。不加上CONCURRENT ，就是产生的多个线程多个容器，执行combiner合并容器。

    ConcurrentModificationException：异常原因, it is not generally permissible for one thread to modify a Collection while another thread is iterating over it. 简单点说，多线程时，并发调同一对象，有的在执行添加，有的在执行查询，所以就会抛出异常。

  3. UNORDERED 指示集合操作不承诺保留输入元素的遭遇顺序。 （如果结果容器没有内在顺序，例如Set，则可能是这样。）

下面例子说明：

package cn.zxhysy.jdk8.stream2;

import java.util.*;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collector;

public class MySetCollection2<T> implements Collector<T, Set<T>, Map<T, T>> {

    @Override
    public Supplier<Set<T>> supplier() {
        System.out.println("suppliier invoked!");

        return () -> {
            // 查看中间容器有几个
            System.out.println("supplier ------------------");
            return new HashSet<>();
        };
    }

    @Override
    public BiConsumer<Set<T>, T> accumulator() {
        System.out.println("accmulator invoked!");

        return (set, item)->{
            // 开启并发， 打印 set 有几率产生异常 ConcurrentModificationException
            // 异常原因在于，一个在遍历，一个在添加，导致异常
            System.out.println("accumulatro:"+ set + ", " +Thread.currentThread().getName());
            set.add(item);
        };
    }

    @Override
    public BinaryOperator<Set<T>> combiner() {
        System.out.println("combiner invoked!");

        return (set1, set2) ->{
            System.out.println("set1："+ set1);
            System.out.println("set2："+ set2);
            set1.addAll(set2);
            return set1;
        };
    }

    @Override
    public Function<Set<T>, Map<T, T>> finisher() {
        System.out.println("finisher invoked!");

        return set -> {
            Map<T, T> map = new HashMap<>(set.size());
            set.forEach(item -> map.put(item, item));
            return map;
        };
    }

    @Override
    public Set<Characteristics> characteristics() {
        System.out.println("characteristics invoked!");

        // 通过添加 CONCURRENT UNORDERED IDENTITY_FINISH 来看差异
        // Characteristics.CONCURRENT Characteristics.UNORDERED Characteristics.IDENTITY_FINISH
        return Collections.unmodifiableSet(EnumSet.of(Characteristics.UNORDERED));
    }

    public static void main(String[] args) {
        for(int i = 0; i< 100; i++){
            List<String> list = Arrays.asList("hello", "world", "welcome", "hello", "a", "b", "c", "d", "e", "f", "g");
            Set<String> set = new HashSet<>();
            set.addAll(list);
//        Map<String, String> map = set.parallelStream().collect(new MySetCollection2<>());
            // 并行流，与上面等价
            Map<String, String> map = set.stream().parallel().collect(new MySetCollection2<>());
            // 串行流
//        Map<String, String> map = set.stream().sequential().collect(new MySetCollection2<>());
            System.out.println(map);
        }
    }
}
z_yemu
关注
  • 4
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[Java8新特性]Collector接口的组成详解
lingfy1234的博客
06-14 1880
1.Collector常常出现的地方 java8引入了stream，Collector是与stream一起出现的，配合stream使用的好帮手，如果用过stream，我们应该都有写过这样的代码 例子1： lists.stream()....collect(Collectors.toList()); 例子2： lists.stream().collect(groupingBy(String::length)); 这两个例子中，toList()和groupingBy返回的都是一个Collector对象,
java 8如何自定义收集器（collector）详解
08-30
Java 8 自定义收集器（Collector） Java 8 中的 Collector 是一个功能强大且灵活的工具，允许用户自定义收集器来满足特定的需求。在本文中，我们将详细介绍如何自定义收集器，以满足特定的业务需求。 Collector ...
Java 8 的一些新特性
weixin_34361881的博客
05-17 152
函数式接口 Predicate java.util.function.Predicate @FunctionalInterface public interface Predicate<T> { // 函数式接口，布尔返回值 boolean test(T t); default Predicate<T> and(Predicate<? s...
java8（中)
否命题的博客
08-14 1278
大多数例子来着Java8实战这本书籍中，附上作者的github https://github.com/java8流的操作符常见的操作符 List<String> threehighCalorcDishNames = menu .stream() .filter(dish -> dish.getCalories() > 30)
Java 8 新特性详解及应用示例
最新发布
艾利克斯冰的博客
05-21 629
随着Java平台的不断演进，Java 11引入了模块系统，Java 17及后续版本继续深化模块化、提升性能、增强安全性，并拥抱最新技术趋势，比如对Valhalla项目（价值类型和泛型特化）、Loom项目（虚拟线程）的探索，预示着Java将继续其在现代软件开发领域的领导地位。未来版本将更加注重提升开发者的生产效率、应用的性能与安全性，同时保持语言的简洁与一致性，确保Java生态系统的持续繁荣与发展。总之，Java 8不仅是Java发展史上的一个重要转折点，也是推动整个生态系统向前迈进的关键力量。
Java8关于Stream的收集器和Collector接口
litte_frog的博客
03-08 519
  从Stream类中的collect作为本文的开始。现在有一个装有Frog对象的List集合，从这个list中将frog对象的size值提取成一个新的集合，可以通过如下方法实现： List&amp;amp;amp;amp;lt;Double&amp;amp;amp;amp;gt; sizeList = frogList.stream() .map(Frog::getSize) .collect(...
java8学习笔记3_流与自定义收集器使用陷阱总结
dcj199411的专栏
05-13 949
 上一篇讲解了Java8中的流与收集器的使用方式，这篇记录一下自定义收集器可能会遇到的问题和使用陷阱。  Collector接口里定义了一个枚举类Characteristics，里面有三个值：CONCURRENT , UNORDERED, IDENTITY_FINISH。当自定义收集器的时候，就需要实现characteristics这个方法，返回一个Set&amp;amp;lt;Characteristics&amp;amp;...
[四] java8 函数式编程 收集器浅析 收集器Collector常用方法 运行原理 内部实现
noteless的博客
08-21 216
Collector常见用法     常用形式为:   .collect(Collectors.toList()) collect()是Stream的方法 Collectors  是收集器Collector 的工厂方法,提供了一些常用的收集器  比如   常用收集器概要 收集器 行为 toList() 将元素收集到一个  List...
Java8中Stream详细用法大全
xuexuexuexuexuex的博客
09-02 1705
Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。特点：不是数据结构，不会保存数据。不会修改原来的数据源，它会将操作后的数据保存到另外一个对象中。（保留意见：毕竟peek方法可以修改流中元素）
怎么在java中创建一个自定义的collector
01-20
怎么在java中创建一个自定义的collector 简介 在之前的java collectors文章里面，我们讲到了stream的collect方法可以调用Collectors里面的toList()或者toMap()方法，将结果转换为特定的集合类。 今天我们介绍一下...
java-object-xpath:使用XPath查询遍历任何对象
05-10
一个Java库，允许使用XPath查询访问对象字段。 例子 class Characteristic { String key; String value; } class Gear { String id; List< Characteristic> characteristics; } class Vehicle { List< Gear> ...
Java收集器接口.pdf
07-02
在Java编程中，`Collector`接口是Java 8引入的一个重要特性，它是Stream API的核心组成部分，主要用于实现数据的收集操作，比如将Stream转换为集合、计算聚合结果等。`Collector`接口定义了四个核心方法和一个可选...
GraphicsEditor:使用Java的图形编辑器软件
04-11
我们正在使用Java实现“图形编辑器软件”。 该软件将使我们能够在软件窗口上直观地操作图像或模型。 要求 - Creating several types of geometric objects such as circles, ellipses, rectangles, lines, polygons...
010Java新特性004Collector接口和Collectors工具类
执笔未来的博客
10-08 375
本文主要学习了在JDK1.8中新增的Collector接口和Collectors工具类，以及使用它们在处理集合时的改进和优化。
Java 8 自定义流Collector实现
neweastsun的专栏
04-21 5578
Java 8 自定义 流的 Collector实现 前文我们看到 Java 8 Collectors提供了很多内置实现。但有时我们需要实现一些特定功能满足业务需要，本文带你学习如何自定义Collector的实现，计算字符串流中所有单词的长度。 需求说明 加入我们的字符串流，每个字符串对象有方法length()————返回单词长度。我们想创建自定义Collector,实现reduce操作，计算流中所...
java8读书笔记：探究java8流收集数据原理，经典实战教程
2401_84166702的博客
04-11 665
上述三个条件必须同时满足，才能并行执行，否则串行执行。代码@3：并行执行收集动作。代码@4：串行执行收集动作。代码@5：如果收集器收集行为集合中包含Characteristics.IDENTITY_FINISH，则直接返回原始值，否则使用Collector.finishier()方式对计算的值进行函数式计算。收集器行为，表示收集其中的累积函数是否支持并行执行。收集器行为，表示整个收集期间，没有顺序要求。
java8新特性(四) Collector（收集器）
热门推荐
戏流年的博客
04-15 1万+
导航 引例 Collector 什么是Collector Collector工作原理 特征值 自定义Collector Collectors详解 求值 均值：averaging 元素个数：counting 最值：maxBy、minBy 和：summing、summarizing 分组 groupingBy groupingByConcurrent partition...
2021最新 JDK17 之 JAVA基础 Stream 流
猫头虎：授渔优于赠鱼，兴趣引领智慧，探索之乐尤显珍贵。商务合作：Libin9iOak，共赴知识与乐趣的探索之旅！
11-05 2034
目录 1、什么是Stream Java 8之前的集合类库主要依赖于 外部迭代（external iteration）。 Collection实现 Iterable接口，从而使得用户可以依次遍历集合的元素。比如我们需要把一个集合中的形状都设置成红色，那么可以这么写： for (Shape shape : shapes) { shape.setColor(RED); } 这个例子演示了外部迭代：for-each循环调用 shapes的 iterator()方法进行依次遍历。外部循环的代码非常直接，但它
Java8中重要的收集器Collector
charming的专栏
03-29 8146
Collector介绍Java8的stream api能很方便我们对数据进行统计分类等工作,函数式编程的风格让我们方便并且直观地编写统计代码。例如：Stream<Integer> stream = Stream.iterate(1, item -> item+2).limit(6); // stream.filter(item -> item > 2).mapToInt(item ->
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值