Question

我有一个HashMap定义如下

Map<String, ArrayList<String>>  map = new HashMap<String, ArrayList<String>>();

然后我将数据库中的数据存储在此hashmap中，并在控制台上显示如下内容，其中条目位于---＆gt;左侧。 ID是ID，右边的条目是此ID使用的标签

165767--->[dual-boot, windows, uninstall, ati, graphics, multiple-monitors]
6873 --->[kubuntu, re-installation]
34228--->[11.10, unity, launcher, libreoffice, icons]

我想根据他们使用的标签数量降序排序ID，即基于 map.get（key）.size（），以便输出应为ID 165767然后是34228，然后是6873，依此类推。

我尝试使用 TreeMap 进行此操作，但我无法根据大小而不是key的值来确定如何执行此操作，以及按降序排列。

Answer 1

这会创建一个已排序的ID列表。

List<String> sortedIds = new ArrayList<String>(map.getKeys());
Collections.sort(sortedIds, new Comparator<String>() {
    public int compare(String a, String b) {
        return map.get(b).size() - map.get(a).size();
    }
});

并不是说你永远不会维护SortedMap（如TreeMap），按可变值排序（如ArrayList的长度）。由于排序顺序用于查找值，如果"id123"变得大于"id456"而没有收集知道它，则可能会导致非常大的问题。

Answer 2

编辑：

我的输出应该根据标签的数量而不是大小来排序 ID

Map<String, ArrayList<String>>  map = new TreeMap<String, ArrayList<String>>();


map.put("165767",new ArrayList<String>(Arrays.asList("dual-boot", "dual-boot", "windows", "uninstall", "ati", "graphics", "multiple-monitors")));
map.put("6873",new ArrayList<String>(Arrays.asList("kubuntu", "kubuntu", "re-installation")));
map.put("0000000000000000",new ArrayList<String>(Arrays.asList("test","test", "test")));
map.put("0125",new ArrayList<String>(Arrays.asList("dual-boot", "windows", "uninstall", "ati", "graphics", "multiple-monitors")));


for(ArrayList<String> l : map.values()){
    Set<String> hs = new HashSet<>();
    hs.addAll(l);
    l.clear();
    l.addAll(hs);
}

List<ArrayList<String>> l = new ArrayList<>(map.values());
Collections.sort(l, new Comparator<ArrayList<String>>(){
    public int compare(ArrayList<String> s1, ArrayList<String> s2){
        return Integer.compare(s2.size(), s1.size());                
    }});

for(ArrayList<String> a : l){
    Iterator<Entry<String, ArrayList<String>>> iter = map.entrySet().iterator();
    while (iter.hasNext()) {
        Entry<String, ArrayList<String>> e = iter.next();
        if(e.getValue().equals(a)){

            System.out.println(e.getKey() + "-" + a);
            iter.remove();
        }
    }
}

输出：

0125-[uninstall, dual-boot, graphics, windows, ati, multiple-monitors]
165767-[uninstall, dual-boot, graphics, windows, ati, multiple-monitors]
6873-[re-installation, kubuntu]
0000000000000000-[test]

Answer 3

我有一个类似的场景，这段代码对我有用（有时我有空）：

     private static Map<Object,List<Object>> sortByArraySizeDesc(Map<Object,List<Object>> map) {
         List<List<Object>> list = new LinkedList(map.entrySet());
         Collections.sort(list, new Comparator() {
              public int compare(Object o1, Object o2) { 
                  if (o1 == null && o2 == null) { return 0; }
                  else if (o1 == null) { return 1;}
                  else if (o2 == null) { return -1; }
                  int size1 = ((List) ((Map.Entry) (o1)).getValue()).size();
                  int size2 = ((List) ((Map.Entry) (o2)).getValue()).size();
                  return size2 - size1;
              }
         });

        Map res = new LinkedHashMap();
        for (Iterator it = list.iterator(); it.hasNext();) {
            Map.Entry entry = (Map.Entry)it.next();
            res.put(entry.getKey(), entry.getValue());
        }
        return res;
    }

基于HashMap </string>中的ArrayList <string>的大小排序

3 个答案: