Java8 自定义收集器（自定义 Collector）

最新推荐文章于 2023-12-22 14:41:54 发布

小曦曦大神

最新推荐文章于 2023-12-22 14:41:54 发布

阅读量253

点赞数

分类专栏： JAVA 文章标签： java steam

本文链接：https://blog.youkuaiyun.com/chengxi1014/article/details/114600916

版权

JAVA 专栏收录该内容

9 篇文章

订阅专栏

本文通过一个具体的示例详细介绍了如何使用Java 8的Stream API结合Collector接口将List集合转换为Map集合的过程。具体步骤包括创建容器、将元素累积到容器中、容器合并以及最终结果的转换。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

package com.example;


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 Run {
    static class User {
        String name;
        int age;

        public User(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }
    }

    public static void main(String[] args) {
        List<User> users = Arrays.asList(
                new User("张三", 1),
                new User("李四", 2),
                new User("王五", 3)
        );

        /**
         * Collector<T, A, R>
         * Collector接口有三个泛型，它们的含义如下：
         *
         * T：输入的元素类型
         * A：累积结果的容器类型
         * R：最终生成的结果类型
         *
         * 下面实现 把 list 中的每个User 的name拿出来 作为新 Map的key，user作为value
         */

        Map<String, User> collect = users.stream().collect(new Collector<User, Map<String, User>, Map<String, User>>() {

            @Override
            public Supplier<Map<String, User>> supplier() {
                return new Supplier<Map<String, User>>() {
                    @Override
                    public Map<String, User> get() {
                        System.out.println("supplier：创建容器");
                        return new HashMap<>();
                    }
                };
            }

            @Override
            public BiConsumer<Map<String, User>, User> accumulator() {
                return new BiConsumer<Map<String, User>, User>() {
                    @Override
                    public void accept(Map<String, User> stringUserMap, User user) {
                        System.out.println("accumulator：放入容器 " + stringUserMap + user);
                        stringUserMap.put(user.getName(), user);
                    }
                };
            }

            @Override
            public BinaryOperator<Map<String, User>> combiner() {
                return new BinaryOperator<Map<String, User>>() {
                    @Override
                    public Map<String, User> apply(Map<String, User> stringUserMap, Map<String, User> stringUserMap2) {
                        System.out.println("combiner: 并行加入" + stringUserMap + stringUserMap2);
                        stringUserMap.putAll(stringUserMap2);
                        return stringUserMap;
                    }
                };
            }

            @Override
            public Function<Map<String, User>, Map<String, User>> finisher() {
                return new Function<Map<String, User>, Map<String, User>>() {
                    @Override
                    public Map<String, User> apply(Map<String, User> stringUserMap) {
                        System.out.println("finisher: 完成转换" + stringUserMap);
                        return stringUserMap;
                    }
                };
            }

            @Override
            public Set<Characteristics> characteristics() {
                HashSet<Characteristics> set = new HashSet<>();
                set.add(Characteristics.CONCURRENT);
                System.out.println("characteristics： 获取特征");
                return set;
            }
        });
        System.out.println("-----------------------------------");
        System.out.println(collect);
    }
}

结果

characteristics： 获取特征
supplier：创建容器
accumulator：放入容器 {}com.example.Run$User@1540e19d
accumulator：放入容器 {张三=com.example.Run$User@1540e19d}com.example.Run$User@677327b6
accumulator：放入容器 {李四=com.example.Run$User@677327b6, 张三=com.example.Run$User@1540e19d}com.example.Run$User@14ae5a5
characteristics： 获取特征
finisher: 完成转换{李四=com.example.Run$User@677327b6, 张三=com.example.Run$User@1540e19d, 王五=com.example.Run$User@14ae5a5}
-----------------------------------
{李四=com.example.Run$User@677327b6, 张三=com.example.Run$User@1540e19d, 王五=com.example.Run$User@14ae5a5}