使用Java在HashMap类中按值排序


Sorting by values in HashMap class using Java

我正在尝试按值排序结果哈希图。

这是hashmap的键和值：

1
2
3
4
map.put("ertu", 5);
map.put("burak", 4);
map.put("selin", 2);
map.put("can", 1);

我试图得到这样的结果：

1
2
3
4
1 = can
2 = selin
4 = burak
5 = ertu

号

这是我的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
import java.util.*;

public class mapTers {

    public static void main(String[] args) {

        HashMap<String, Integer> map = new HashMap<String, Integer>();

        map.put("ertu", 5);
        map.put("burak", 4);
        map.put("selin", 2);
        map.put("can", 1);

        Integer dizi[] = new Integer[map.size()];

        Set anahtarlar = map.keySet();

        Iterator t = anahtarlar.iterator();

        int a = 0;

        while (t.hasNext()) {
            dizi[a] = map.get(t.next());
            a++;
        }

        Arrays.sort(dizi);

        for (int i = 0; i < map.size(); i++) {
            while (t.hasNext()) {
                if (dizi[i].equals(map.get(t.next()))) {
                    System.out.println(dizi[i] +" =" + t.next());
                }
            }
        }
    }
}

您可以按如下方式对条目进行排序(但请注意，这不会对地图本身进行排序，而且也无法对HashMap进行排序)-

1
2
3
4
5
6
7
List<Map.Entry<String, Integer>> entryList = new ArrayList<Map.Entry<String, Integer>>(map.entrySet());
Collections.sort(entryList, new Comparator<Map.Entry<String, Integer>>() {
    @Override
    public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) {
        return o1.getValue().compareTo(o2.getValue());
    }
});
相关讨论

每次调用t.next()时，迭代器的指针都向前移动。最后，迭代器到达末尾。您需要重置迭代器。另外，调用t.next()两次会移动指针两次。

我的解决方案是：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import java.util.*;
public class mapTers
{
  public static void main(String[] args)
  {
    HashMap<String, Integer> map = new HashMap<String, Integer>();
    map.put("ertu", 5);
    map.put("burak", 4);
    map.put("selin", 2);
    map.put("can", 1);
    Integer dizi[] = new Integer[map.size()];
    Set anahtarlar = map.keySet();
    Iterator t = anahtarlar.iterator();
    int a = 0;
    while (t.hasNext())
    {
      dizi[a] = map.get(t.next());
      a++;
    }
    Arrays.sort(dizi);
    for (int i = 0; i < map.size(); i++)
    {
      t = anahtarlar.iterator();
      while (t.hasNext())
      {
        String temp = (String)t.next();
        if (dizi[i].equals(map.get(temp)))
        {
          System.out.println(dizi[i] +" =" + temp);
        }
      }
    }
  }
}

。

相关讨论

你不能从一个Map中做到这一点。至少不是直接的。

检索键/条目，以更合适的结构获取所有映射数据(提示：封装两个属性并存储在可排序(hint2:SortedSet和List中的类)并排序。

不要忘记扩展Comparable和实现compareTo，否则创建Comparator。

对于这个问题，您可能有错误的数据结构。或者：

  • 反转映射，使整数成为键，字成为值，使映射成为SortedMap，或
  • 使用像google guava这样的库提供的双向映射。

    • 反向映射

    1
    2
    3
    4
    5
    6
    7
    private final SortedMap<Integer, String> TRANSLATIONS;
    static {
        SortedMap<Integer, String> map = new TreeMap<>();
        map.put(1,"can");
        // ...
        TRANSLATIONS = Collections.unmodifiableSortedMap(map);
    }

    番石榴

    1
    2
    3
    4
    5
    6
    7
    private final BiMap TRANSLATIONS =
       new ImmutableBiMap.Builder<String, Integer>()
            .put("ertu", 5);
            .put("burak", 4);
            .put("selin", 2);
            .put("can", 1);
            .build();

    。

    然后，根据需要迭代键集或值集的排序版本。例如，

    1
    TRANSLATIONS.inverse.get(4); //"burak"

    。

    我只是好奇。你的字符串使用什么语言？

    相关讨论

    这是以下解决方案之一：https://stackoverflow.com/a/13913206/1256583

    只要把未排序的地图传进去，你就会得到排序的地图。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    private static Map<String, Integer> sortByComparator(Map<String, Integer> unsortMap, final boolean order) {

        List<Entry<String, Integer>> list = new LinkedList<Entry<String, Integer>>(unsortMap.entrySet());

        // Sorting the list based on values
        Collections.sort(list, new Comparator<Entry<String, Integer>>() {
            public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) {
                if (order) {
                    return o1.getValue().compareTo(o2.getValue());
                }
                else {
                    return o2.getValue().compareTo(o1.getValue());

                }
            }
        });

        // Maintaining insertion order with the help of LinkedList
        Map<String, Integer> sortedMap = new LinkedHashMap<String, Integer>();
        for (Entry<String, Integer> entry : list) {
            sortedMap.put(entry.getKey(), entry.getValue());
        }

        return sortedMap;
    }

    号

    要打印，请对条目集执行简单的迭代：

    1
    2
    3
    4
    5
    public static void printMap(Map<String, Integer> map) {
        for (Entry<String, Integer> entry : map.entrySet()) {
            System.out.println("Key :" + entry.getKey() +" Value :"+ entry.getValue());
        }
    }