Android中统计自定义对象列表中的重复项

嘿，我来帮你搞定Android开发中统计Message列表重复项的问题～首先得明确：自定义对象的重复需要你先定义判定规则——比如是根据id字段唯一标识重复，还是多个字段（比如useridfrom+useridto+subject）组合起来才算重复？下面我会分情况给你具体实现方案：

一、最常见：按单个字段（比如id）统计重复 #

方法1：用HashMap手动统计（兼容所有Java版本） #

这种方法简单直观，适合所有项目：

// 获取你的消息列表
List<Message> messages = getMessages();
// 用HashMap存「判定字段」和「出现次数」
Map<String, Integer> duplicateCountMap = new HashMap<>();

// 第一步：遍历列表，统计每个id的出现次数
for (Message msg : messages) {
    // 这里用id作为重复判定依据，可替换成你需要的字段
    String key = msg.getId();
    // 不存在就设为0，然后+1；存在就直接+1
    duplicateCountMap.put(key, duplicateCountMap.getOrDefault(key, 0) + 1);
}

// 第二步：提取重复项（次数>1的）
List<Message> duplicateMessages = new ArrayList<>();
for (Message msg : messages) {
    String key = msg.getId();
    if (duplicateCountMap.get(key) > 1) {
        duplicateMessages.add(msg);
        // 可选：如果不想重复添加同一个重复项，把计数设为0避免重复加入
        duplicateCountMap.put(key, 0);
    }
}

// 也可以直接打印重复的字段和次数
for (Map.Entry<String, Integer> entry : duplicateCountMap.entrySet()) {
    if (entry.getValue() > 1) {
        Log.d("Duplicate", "Message id: " + entry.getKey() + " 重复次数: " + entry.getValue());
    }
}

方法2：用Java 8+ Stream API（更简洁） #

如果你的项目支持Java 8及以上，用Stream会更优雅：

List<Message> messages = getMessages();

// 按id分组，统计每个id的出现次数
Map<String, Long> idCountMap = messages.stream()
    .collect(Collectors.groupingBy(Message::getId, Collectors.counting()));

// 筛选出重复的Message对象（次数>1）
List<Message> duplicates = messages.stream()
    .filter(msg -> idCountMap.get(msg.getId()) > 1)
    // 可选：如果要去重（每个重复项只留一个实例），必须重写Message的equals和hashCode！
    .distinct()
    .collect(Collectors.toList());

二、按多个字段组合统计重复 #

如果需要多个字段同时相同才算重复（比如useridfrom+useridto+subject），可以这样做：

方案1：用组合字符串作为Key #

List<Message> messages = getMessages();
Map<String, Integer> countMap = new HashMap<>();

for (Message msg : messages) {
    // 把多个字段拼接成唯一字符串作为Key
    String key = msg.getUseridfrom() + "_" + msg.getUseridto() + "_" + msg.getSubject();
    countMap.put(key, countMap.getOrDefault(key, 0) + 1);
}

// 后续提取重复项的逻辑和上面一样，这里就不重复写啦

方案2：自定义Key类（更规范） #

如果字段较多，拼接字符串容易出错，可以创建一个自定义Key类，重写equals和hashCode：

// 自定义Key类，包含用来判定重复的字段
class MessageDuplicateKey {
    private String useridfrom;
    private String useridto;
    private String subject;

    // 构造方法
    public MessageDuplicateKey(String useridfrom, String useridto, String subject) {
        this.useridfrom = useridfrom;
        this.useridto = useridto;
        this.subject = subject;
    }

    // 重写equals和hashCode，确保字段相同时判定为相等
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        MessageDuplicateKey that = (MessageDuplicateKey) o;
        return Objects.equals(useridfrom, that.useridfrom) &&
               Objects.equals(useridto, that.useridto) &&
               Objects.equals(subject, that.subject);
    }

    @Override
    public int hashCode() {
        return Objects.hash(useridfrom, useridto, subject);
    }
}

// 统计逻辑
List<Message> messages = getMessages();
Map<MessageDuplicateKey, Integer> countMap = new HashMap<>();

for (Message msg : messages) {
    MessageDuplicateKey key = new MessageDuplicateKey(
        msg.getUseridfrom(),
        msg.getUseridto(),
        msg.getSubject()
    );
    countMap.put(key, countMap.getOrDefault(key, 0) + 1);
}

重要提示：重写equals和hashCode的必要性 #

如果需要用contains、distinct等方法直接判断Message对象是否相等，必须重写Message类的equals和hashCode方法，否则会默认用对象的内存地址判断，达不到预期。比如按id重写：

public class Message {
    @SerializedName("id") @Expose private String id;
    // 其他字段...

    // getter、setter...

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Message message = (Message) o;
        return Objects.equals(id, message.id);
    }

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

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