Question

我的问题与上述不同。我想计算键值的出现次数，并按降序对键和值进行排序。

我有这个哈希映射：

0=[1, 2], 1=[2, 3], 2=[4], 3=[4, 5], 4=[5], 5=[]

我希望有一个键和值列表，它们根据它的值计数按降序排序。最终的清单应该是 0=[1, 2], 1=[3, 2], 3=[4,5], 2=[4], 4=[5], 5=[]
键和值应根据以下内容排列： 0有两个值，1有两个值，3有两个值，2有一个值，4有一个值，5有没有等等。
注意：两个键和值都是根据计数排列的。

我只是根据值的数量

对键进行了排序

Map<Integer, Integer> map_degree = new HashMap<Integer, Integer>();

    for (Entry<Integer, ArrayList<Integer>> entry : list.entrySet()) {

        ArrayList<Integer> value=entry.getValue();
        int degree= value.size(); 
        int key=entry.getKey();
        map_degree.put(key,degree);

        }


       System.out.println("The mapping"+list);
       System.out.println("Before sorting" +   map_degree);
       System.out.println("After sorting descindeng order");
       Map<Integer, Integer> sortedVertex = sortByComparator(map_degree);
       System.out.println(sortedVertex); 





   }

   private static Map<Integer, Integer> sortByComparator(Map<Integer, Integer> map_degree)
   {

       LinkedList<Entry<Integer, Integer>> list_sorting = new LinkedList<Entry<Integer, Integer>>(map_degree.entrySet());

       // Sorting the list based on values
       Collections.sort(list_sorting, new Comparator<Entry<Integer, Integer>>()
       {
           public int compare(Entry<Integer, Integer> o1,
                   Entry<Integer, Integer> o2)
           {

               {    
                   // returns descending order
                   return o2.getValue().compareTo(o1.getValue());

               }
           }
       });



       // Maintaining insertion order with the help of LinkedList
       Map<Integer, Integer> sortedMap = new LinkedHashMap<Integer, Integer>();

       for (Entry<Integer, Integer> entry : list_sorting)
       {
           sortedMap.put(entry.getKey(), entry.getValue());
       }

       return sortedMap;

   }

输出是（键被排序并映射为值的计数）

Before sorting{0=2, 1=2, 2=1, 3=2, 4=1, 5=0}
After sorting descindeng order
{0=2, 1=2, 3=2, 2=1, 4=1, 5=0}

我如何订购密钥的值也是最终得到的 0=[1, 2], 1=[3, 2], 3=[4,5], 2=[4], 4=[5], 5=[] ?

Answer 1

试试这个。

    Map<Integer, List<Integer>> map = new HashMap<Integer, List<Integer>>() {{
        put(0, Arrays.asList(1, 2));
        put(1, Arrays.asList(2, 3));
        put(2, Arrays.asList(4));
        put(3, Arrays.asList(4, 5));
        put(4, Arrays.asList(5));
        put(5, Arrays.asList());
    }};
    System.out.println("Before " + map);
    Map<Integer, List<Integer>> sorted = map.entrySet().stream()
        .peek(e -> e.getValue().sort((a, b) -> map.get(b).size() - map.get(a).size()))      // sort values descending
        .sorted((a, b) -> b.getValue().size() - a.getValue().size())    // sort keys descending
        .collect(LinkedHashMap::new, (m, e) -> m.put(e.getKey(), e.getValue()), (m0, m1) -> m0.putAll(m1));
    System.out.println("After  " + sorted);

结果：

Before {0=[1, 2], 1=[2, 3], 2=[4], 3=[4, 5], 4=[5], 5=[]}
After  {0=[1, 2], 1=[3, 2], 3=[4, 5], 2=[4], 4=[5], 5=[]}

如何计算密钥的值并排序？

1 个答案: