我来给你一步步拆解这个需求的实现逻辑，核心思路是用分组替代去重，再对分组结果做处理：

前提确认 #

首先要保证你的A类的equals和hashCode不包含count字段——只有这样，才能把"逻辑上相同"的对象归为一组，实现累加count的效果。如果这两个方法目前包含count，需要先修改，只基于判断"重复"的核心属性（比如假设A有id字段）来实现。

另外，给A补充必要的getter和构造器，方便后续操作：

import java.util.Objects;

class A {
    int count = 0;
    private int id; // 示例：用于判断重复的核心属性

    // 基础构造器
    public A(int id) {
        this.id = id;
    }

    // 带count的构造器，用于生成累加后的新对象
    public A(int id, int count) {
        this.id = id;
        this.count = count;
    }

    // Getter方法
    public int getCount() {
        return count;
    }

    public int getId() {
        return id;
    }

    // equals和hashCode仅基于id，不包含count
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        A a = (A) o;
        return id == a.id;
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}

核心实现代码 #

import java.util.Collection;
import java.util.Comparator;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        Collection<A> collection1 = ...; // 初始化你的第一个集合
        Collection<A> collection2 = ...; // 初始化你的第二个集合

        List<A> result = Stream.concat(collection1.stream(), collection2.stream())
                // 1. 分组并累加count：逻辑相同的对象归为一组，count求和
                .collect(Collectors.toMap(
                        Function.identity(), // 用A对象本身作为分组key（依赖equals/hashCode）
                        A::getCount, // 提取每个对象的count作为初始值
                        Integer::sum // 重复key时，累加两个count值
                ))
                // 2. 将分组结果转换为新的A对象（保留原属性，设置累加后的count）
                .entrySet().stream()
                .map(entry -> new A(entry.getKey().getId(), entry.getValue()))
                // 3. 按count排序：这里是降序，升序去掉.reversed()即可
                .sorted(Comparator.comparingInt(A::getCount).reversed())
                // 4. 收集为最终List
                .collect(Collectors.toList());
    }
}

关键步骤解释 #

1. 合并流：用Stream.concat把两个集合的流合并，和你原本的思路一致。
2. 分组累加：通过Collectors.toMap实现分组，核心是利用equals/hashCode识别重复对象，并用Integer::sum完成count的累加，这一步直接替代了distinct()的去重逻辑。
3. 生成新对象：因为分组的key是原集合中的对象（count是初始值），所以我们需要创建新的A实例，把累加后的count赋值进去，避免修改原集合的对象（如果允许修改原对象，也可以直接给key的count赋值，但不推荐）。
4. 排序收集：用Comparator.comparingInt按count排序，最后收集成List。

内容的提问来源于stack exchange，提问作者nafas