Question

我已经声明了这样的HashMap：

Map<Integer,ArrayList<Integer>> numbers = new HashMap<Integer,ArrayList<Integer>>();

它的输出如下：

{64=[61, 68, 77], 65=[63, 66, 66, 70], 66=[69, 75, 2], 2=[4], 67=[65, 77], 4=[2]}

如何计算其密钥的值？

因此，64将是3,65将是4,66将是3

然后获得一个具有前3个值的键所以这种情况下的输出就像65 64 66

Answer 1

首先：你不能对HashMap进行排序，它本质上没有排序，出于性能原因，你应该使用LinkedHashMap，这是一个java8示例，可以解决你的问题：

class SortALinkedHashMapByTheSizeOfItsContainedArrayList {
LinkedHashMap<Integer,ArrayList<Integer>> numbers = new LinkedHashMap<>();

 void sortTheMap(){
    numbers.entrySet().stream()
            .sorted(Map.Entry.comparingByValue())
            .forEach(entry -> entry.getValue().size() );

 }
}

Answer 2

这样的事情：

Map<Integer, List<Integer>> numbers = new HashMap<Integer, List<Integer>>();
numbers.put(64, Arrays.asList(61, 68, 77));
numbers.put(65, Arrays.asList(63, 66, 66, 70));
numbers.put(66, Arrays.asList(69, 75, 2));
numbers.put(67, Arrays.asList(65, 77));
numbers.put(2, Arrays.asList(4));
numbers.put(4, Arrays.asList(2));

List<Integer> topValues = numbers.entrySet().stream()
       .collect(
               Collectors.toMap(
                    Map.Entry::getKey,
                    entry -> entry.getValue().size()
                ) // get a map where key=original key and value list size
       )  // {64=3, 65=4, 2=1, 66=3, 67=2, 4=1}
       .entrySet()
       .stream() // sort map by value - list size
       .sorted( Map.Entry.<Integer,Integer>comparingByValue().reversed())
       .limit(3) // get top 3 
       .map(Map.Entry::getKey)
       .collect(Collectors.toList());

System.out.println(topValues); // [65, 64, 66]

作为第一步，我们将地图Map<Integer, List<Integer>> numbers转换为新的临时地图Map<Integer,Integer>，其中键是原始地图的关键，值是列表大小。所以原来的地图 {64=[61, 68, 77], 65=[63, 66, 66, 70], 66=[69, 75, 2], 2=[4], 67=[65, 77], 4=[2]}将成为{64=3, 65=4, 2=1, 66=3, 67=2, 4=1}然后我们将按降序对临时地图进行排序，并获得前3个元素。作为最后一步，我们将获得前3个键，并将它们添加到topValues列表中。

我希望这会有所帮助。

Answer 3

您可以使用反向排序的TreeMap根据价值的大小订购Map个密钥：

    SortedMap<Integer,ArrayList<Integer>> sizes = new TreeMap<Integer,ArrayList<Integer>>(Collections.reverseOrder());
    for (Integer key : numbers.keySet()) {
        int size = numbers.get(key).size();
        if (sizes.get(size) == null) {
            sizes.put(size, new ArrayList<Integer>());
        }
        sizes.get(size).add(key);
    }
    System.out.println(sizes.values());

这将打印：

[[65], [64, 66], [67], [2, 4]]

如果要删除[]，可以循环sizes.values()并仅打印每个包含列表的内容，或者只打印sizes.values().toString().replace("[","").replace("]",""))以从打印的字符串中删除它们。

Answer 4

Java 8版。这将按升序排序;对于降序，可以取消对Collections.reverseOrder（）的调用。

public static <K, V extends Comparable<? super V>> Map<K, V> sortByValue(Map<K, V> map) {
    return map.entrySet()
              .stream()
              .sorted(Map.Entry.comparingByValue(/*Collections.reverseOrder()*/))
              .collect(Collectors.toMap(
                Map.Entry::getKey, 
                Map.Entry::getValue, 
                (e1, e2) -> e1, 
                LinkedHashMap::new
              ));
}

Answer 5

迭代Map并获取Key之后，根据键返回列表获取值并获取列表大小并保留在新映射中，如果迭代完成后迭代新映射。

如何使用Java中的值来对HashMap进行排序

5 个答案: