Java按值对HashMap进行排序，并将其添加到新的Map对象中

我有一个HashMap，我尝试按它的值（从大到小）排序。我想要一个新的映射对象，它是新排序的哈希映射的克隆（或者是直接对哈希映射本身排序的方法）。以下是我的代码：

import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;

public class Repetition {
    public static Map<Object, Integer> countRepititions(Object[] e) {
        Map<Object, Integer> occurrences = new HashMap<>();
        for (int i = 0; i < e.length; i++) {
            occurrences.putIfAbsent(e[i], 0);
            occurrences.computeIfPresent(e[i], (k, v) -> v + 1);
        }

        return occurrences.entrySet().stream()
                                     .sorted((e1, e2) -> e2.getValue().compareTo(e1.getValue()))
                                     .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, HashMap::new));
    }

    public static void main(String[] args) {
        Object[] arr = { "cat", "dog", "cat", "cow", "cow", "cow" };

        System.out.println(countRepititions(arr)); //should be cow, cat, dog
    }
}

import java.util.HashMap；
导入java.util.Map；
导入java.util.stream.collector；
公共课留级{
公共静态映射计数描述（对象[]e）{
映射出现次数=新建HashMap（）；
for（int i=0；iv+1）；
}
返回实例。entrySet（）.stream（）
.sorted（（e1，e2）->e2.getValue（）.compareTo（e1.getValue（））
.collect（Collectors.toMap（Map.Entry:：getKey，Map.Entry:：getValue，（e1，e2）->e1，HashMap:：new））；
}
公共静态void main（字符串[]args）{
对象[]arr={“猫”、“狗”、“猫”、“牛”、“牛”}；
System.out.println（countRepititions（arr））；//应该是cow、cat、dog
}
}

问题在于输出是原始哈希映射的输出，而不是排序后的哈希映射。如果有人能帮助我，我将不胜感激

编辑：

---

我通过使用LinkedHashMap修改了当前代码。

您想使用保持顺序（适合排序）的

LinkedHashMap

。该解决方案需要两个流：

public static Map<Object, Long> countRepititions(Object[] e) {
  return Arrays.stream(e)
      .collect(Collectors.groupingBy(
              Function.identity(),                                   // object as key
              Collectors.counting()))                                // count is value
      .entrySet().stream()
      .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder())) // reversed order
      .collect(Collectors.toMap(
              Map.Entry::getKey,                                     // preserve keys
              Map.Entry::getValue,                                   // preserve values
              (l, r) -> l,                                           // merge function
              LinkedHashMap::new));                                  // LinkedHashMap
}

publicstaticmap countrepitions（Object[]e）{
返回数组.stream（e）
.collect（收集器.groupingBy(
Function.identity（），//对象作为键
Collectors.counting（））//count是值
.entrySet（）.stream（）
.sorted（Map.Entry.comparingByValue（Comparator.reverseOrder（））//反向顺序
.collect（collector.toMap）(
Map.Entry:：getKey，//保留键
Map.Entry:：getValue，//保留值
（l，r）->l，//合并函数
LinkedHashMap:：new））；//LinkedHashMap
}

打印出此类返回的地图将导致：

{cow=3，cat=2，dog=1}

---

您希望使用保留顺序（适合排序）的

LinkedHashMap

。该解决方案需要两个流：

public static Map<Object, Long> countRepititions(Object[] e) {
  return Arrays.stream(e)
      .collect(Collectors.groupingBy(
              Function.identity(),                                   // object as key
              Collectors.counting()))                                // count is value
      .entrySet().stream()
      .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder())) // reversed order
      .collect(Collectors.toMap(
              Map.Entry::getKey,                                     // preserve keys
              Map.Entry::getValue,                                   // preserve values
              (l, r) -> l,                                           // merge function
              LinkedHashMap::new));                                  // LinkedHashMap
}

publicstaticmap countrepitions（Object[]e）{
返回数组.stream（e）
.collect（收集器.groupingBy(
Function.identity（），//对象作为键
Collectors.counting（））//count是值
.entrySet（）.stream（）
.sorted（Map.Entry.comparingByValue（Comparator.reverseOrder（））//反向顺序
.collect（collector.toMap）(
Map.Entry:：getKey，//保留键
Map.Entry:：getValue，//保留值
（l，r）->l，//合并函数
LinkedHashMap:：new））；//LinkedHashMap
}

打印出此类返回的地图将导致：

{cow=3，cat=2，dog=1}

---

A

HashMap

无法排序。请澄清您的要求：映射的要点是：它们通常没有排序。以下是挑战的要求：A

HashMap

无法排序。请澄清您的要求：映射的要点是：它们通常没有排序。以下是对挑战：