修正Java HashMap重排代码：值降序保留，重复值按键升序排列

需求说明 #

输入一个按值降序排列的键值集合，仅对存在重复值的键值对按键升序重排，其余条目保持原有顺序：

• 示例1：输入{7=4, 17=2, 5=2} → 输出{7=4, 5=2, 17=2}（值为2的键按升序排列）
• 示例2：输入{7=4, 11=3, 18=3, 35=3, 2=2, 5=1, 10=1} → 输出与输入一致（值为3和1的键已按升序排列）

原代码问题分析 #

1. HashMap键唯一性限制：原main方法中连续put(11,3)和put(11,1)，导致键11的值被覆盖为1，直接丢失11=3条目。
2. 无序容器导致顺序混乱：用HashMap存储结果，无法保留原输入的整体值降序顺序。
3. 错误的重复值判断：仅判断value>1，忽略了值为1但出现多次的情况，且未统计每个值的出现次数来判定重复。
4. 排序方向错误：对键做了降序排序，不符合需求的升序要求。

修正后的代码 #

import java.util.*;
import java.util.stream.Collectors;

public class HashMapSort {
    public static void main(String[] args) {
        // 用LinkedHashMap保留输入的顺序，避免键覆盖（修正原重复键问题）
        LinkedHashMap<Integer, Integer> inputMap = new LinkedHashMap<>();
        inputMap.put(7, 4);
        inputMap.put(11, 3);
        inputMap.put(18, 3);
        inputMap.put(35, 3);
        inputMap.put(2, 2);
        inputMap.put(5, 1);
        inputMap.put(10, 1);
        System.out.println("Before rearranging: " + inputMap);
        
        LinkedHashMap<Integer, Integer> rearrangedMap = rearrangeHashMap(inputMap);
        System.out.println("After rearranging: " + rearrangedMap);
    }

    public static LinkedHashMap<Integer, Integer> rearrangeHashMap(LinkedHashMap<Integer, Integer> inputMap) {
        LinkedHashMap<Integer, Integer> result = new LinkedHashMap<>();
        
        // 统计每个值出现的次数，判断是否为重复值
        Map<Integer, Long> valueCount = inputMap.values().stream()
                .collect(Collectors.groupingBy(v -> v, Collectors.counting()));
        
        // 按值分组，收集每个值对应的键列表
        Map<Integer, List<Integer>> valueToKeys = new HashMap<>();
        for (Map.Entry<Integer, Integer> entry : inputMap.entrySet()) {
            int key = entry.getKey();
            int value = entry.getValue();
            valueToKeys.computeIfAbsent(value, k -> new ArrayList<>()).add(key);
        }
        
        // 获取原输入中去重后的降序值列表，保留原顺序
        List<Integer> uniqueValues = inputMap.values().stream()
                .distinct()
                .collect(Collectors.toList());
        
        // 按原顺序处理每个值对应的键
        for (int value : uniqueValues) {
            List<Integer> keys = valueToKeys.get(value);
            // 重复值按键升序排序，非重复值保持原顺序
            if (valueCount.get(value) > 1) {
                Collections.sort(keys);
            }
            // 将键值对按顺序放入结果
            for (int key : keys) {
                result.put(key, value);
            }
        }
        
        return result;
    }
}

修正说明 #

1. 使用LinkedHashMap：输入和结果都用LinkedHashMap严格保留顺序，确保整体值降序的结构不变。
2. 修复键覆盖问题：将原重复键11=1替换为10=1，符合HashMap键唯一的特性；若确实需要重复键，可改用List<Map.Entry<Integer, Integer>>存储输入。
3. 正确判断重复值：通过统计每个值的出现次数，覆盖所有值的重复情况（包括值为1的情况）。
4. 按需求排序：对重复值对应的键列表做升序排序，非重复值保持原输入顺序。
5. 保留原整体顺序：提取原输入中去重后的value列表，确保处理顺序与原输入的降序一致。

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