KnowledgeBase、Programing

Java中如何对HashMap进行排序

2018-06-09 Docker 3条评论 214 views

=Start=

缘由：

Java中HashMap的值是没有顺序的，它是按照key的HashCode来实现的。对于这个无序的HashMap我们要怎么来实现排序呢？这里就整理总结一下，方便以后查阅、参考。

正文：

参考解答：

先说结论，如果着急的话可以先看这个/只看这个就够：

Java中对 HashMap 进行排序的一般步骤就是：

1、先根据 HashMap 的内容生成 list ；
2、再调用 Collections.sort(list[, new Comparator]) 对 list 进行就地排序；
2.1、内部进行的比较一般是通过 .compareTo() 方法进行的，但是也可以自行修改「大于返回1，小于返回-1，等于返回0」；
3、如果只要排序后的结果的话，可以直接用 list ；如果还要一个map的话，就新建一个LinkedHashMap来存放list的结果。

Java中的原生排序方法整理：

对基本类型排序 # Arrays.sort()
对对象数组排序 # 则要自己实现 java.util.Comparator 接口

//1. 数字排序
int[] intArray = new int[] { 4, 1, 3, -23 };
Arrays.sort(intArray);
System.out.println(Arrays.toString(intArray));
//输出： [-23, 1, 3, 4]

//2. 字符串排序，先大写后小写
String[] strArray = new String[] { "z", "a", "C" };
System.out.println(Arrays.toString(strArray));
//输出： [z, a, C]
Arrays.sort(strArray);
System.out.println(Arrays.toString(strArray));
//输出： [C, a, z]

//3. 严格按字母表顺序排序，也就是忽略大小写排序 Case-insensitive sort
Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);
System.out.println(Arrays.toString(strArray));
//输出： [a, C, z]

//4. 反向排序， Reverse-order sort
Arrays.sort(strArray, Collections.reverseOrder());
System.out.println(Arrays.toString(strArray));
//输出： [z, a, C]

//5. 忽略大小写反向排序 Case-insensitive reverse-order sort
Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);
Collections.reverse(Arrays.asList(strArray));
System.out.println(Arrays.toString(strArray));
//输出： [z, C, a]

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

//1. 数字排序

int[] intArray = new int[] { 4, 1, 3, -23 };

Arrays.sort(intArray);

System.out.println(Arrays.toString(intArray));

//输出： [-23, 1, 3, 4]

//2. 字符串排序，先大写后小写

String[] strArray = new String[] { "z", "a", "C" };

System.out.println(Arrays.toString(strArray));

//输出： [z, a, C]

Arrays.sort(strArray);

System.out.println(Arrays.toString(strArray));

//输出： [C, a, z]

//3. 严格按字母表顺序排序，也就是忽略大小写排序 Case-insensitive sort

Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);

System.out.println(Arrays.toString(strArray));

//输出： [a, C, z]

//4. 反向排序， Reverse-order sort

Arrays.sort(strArray, Collections.reverseOrder());

System.out.println(Arrays.toString(strArray));

//输出： [z, a, C]

//5. 忽略大小写反向排序 Case-insensitive reverse-order sort

Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);

Collections.reverse(Arrays.asList(strArray));

System.out.println(Arrays.toString(strArray));

//输出： [z, C, a]

Java中打印数组的方法，参考「链接」。

再放整理后的代码：

package com.ixyzero.learn.misc;

import java.util.*;
import java.util.Map.Entry;

/**
 * https://stackoverflow.com/questions/8119366/sorting-hashmap-by-values/13913206#13913206
 */
public class SortMapByValue
{
    public static boolean ASC = true;
    public static boolean DESC = false;

    public static void main(String[] args)
    {
        // Creating dummy unsorted map
        Map<String, Integer> unsortedMap = new HashMap<>();
        unsortedMap.put("B", 55);
        unsortedMap.put("A", 80);
        unsortedMap.put("D", 20);
        unsortedMap.put("C", 70);

        System.out.println("Before sorting......");
        printMap(unsortedMap);

        System.out.println("\nAfter sorting ascending order......");
        Map<String, Integer> sortedMapAsc = sortByValueComparator(unsortedMap, ASC);
        printMap(sortedMapAsc);

        System.out.println("\nAfter sorting descending order......");
        Map<String, Integer> sortedMapDesc = sortByValueComparator(unsortedMap, DESC);
        printMap(sortedMapDesc);

        System.out.println("\nAfter sorting descending order by key......");
        Map<String, Integer> sortedKeyMapDesc = sortByKeyComparator(sortedMapAsc, DESC);
        printMap(sortedKeyMapDesc);
    }

    private static Map<String, Integer> sortByKeyComparator(Map<String, Integer> unsortedMap, final boolean order)
    {

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

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

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

        return sortedMap;
    }


    private static Map<String, Integer> sortByValueComparator(Map<String, Integer> unsortedMap, final boolean order)
    {

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

        // Sorting the list based on values
        Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
            public int compare(Map.Entry<String, Integer> o1, Map.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<>();
        for (Map.Entry<String, Integer> entry : list) {
            sortedMap.put(entry.getKey(), entry.getValue());
        }

        return sortedMap;
    }

    public static void printMap(Map<String, Integer> map)
    {
        for (Entry<String, Integer> entry : map.entrySet()) {
            System.out.println("Key: " + entry.getKey() + "\tValue: "+ entry.getValue());
        }
    }
}

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

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

package com.ixyzero.learn.misc;

import java.util.*;

import java.util.Map.Entry;

/**

* https://stackoverflow.com/questions/8119366/sorting-hashmap-by-values/13913206#13913206

*/

public class SortMapByValue

{

public static boolean ASC = true;

public static boolean DESC = false;

public static void main(String[] args)

{

// Creating dummy unsorted map

Map<String, Integer> unsortedMap = new HashMap<>();

unsortedMap.put("B", 55);

unsortedMap.put("A", 80);

unsortedMap.put("D", 20);

unsortedMap.put("C", 70);

System.out.println("Before sorting......");

printMap(unsortedMap);

System.out.println("\nAfter sorting ascending order......");

Map<String, Integer> sortedMapAsc = sortByValueComparator(unsortedMap, ASC);

printMap(sortedMapAsc);

System.out.println("\nAfter sorting descending order......");

Map<String, Integer> sortedMapDesc = sortByValueComparator(unsortedMap, DESC);

printMap(sortedMapDesc);

System.out.println("\nAfter sorting descending order by key......");

Map<String, Integer> sortedKeyMapDesc = sortByKeyComparator(sortedMapAsc, DESC);

printMap(sortedKeyMapDesc);

}

private static Map<String, Integer> sortByKeyComparator(Map<String, Integer> unsortedMap, final boolean order)

{

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

// Sorting the list based on values

Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {

public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {

if (order) {

return o1.getKey().toString().compareTo(o2.getKey().toString());

} else {

return o2.getKey().toString().compareTo(o1.getKey().toString());

}

}

});

// Maintaining insertion order with the help of LinkedList

Map<String, Integer> sortedMap = new LinkedHashMap<>();

for (Map.Entry<String, Integer> entry : list) {

sortedMap.put(entry.getKey(), entry.getValue());

}

return sortedMap;

}

private static Map<String, Integer> sortByValueComparator(Map<String, Integer> unsortedMap, final boolean order)

{

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

// Sorting the list based on values

Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {

public int compare(Map.Entry<String, Integer> o1, Map.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<>();

for (Map.Entry<String, Integer> entry : list) {

sortedMap.put(entry.getKey(), entry.getValue());

}

return sortedMap;

}

public static void printMap(Map<String, Integer> map)

{

for (Entry<String, Integer> entry : map.entrySet()) {

System.out.println("Key: " + entry.getKey() + "\tValue: "+ entry.getValue());

}

}

}

参考链接：

=END=

声明： 除非注明，ixyzero.com文章均为原创，转载请以链接形式标明本文地址，谢谢！
https://ixyzero.com/blog/archives/3973.html

《Java中如何对HashMap进行排序》上有3条评论

hi说道：

2018-06-09 21:59

java集合遍历的几种方式总结及比较
https://www.cnblogs.com/leskang/p/6031282.html
集合类的通用遍历方式，用迭代器迭代： Iterator it = list.iterator(); while(it.hasNext()) { Object obj = it.next(); }
Map的几种遍历方式 List的几种遍历方式数据元素是怎样在内存中存放的？每个遍历方法的实现原理是什么？各遍历方式对于不同的存储方式，性能如何？各遍历方式的适用于什么场合？
Java的最佳实践是什么？ if (list instanceof RandomAccess) { //使用传统的for循环遍历。 } else { //使用Iterator或者foreach。 }

回复
hi说道：

2018-06-25 20:58

jdk HashMap工作原理分析
http://fangjian0423.github.io/2016/03/29/jdk_hashmap/

jdk LinkedHashMap工作原理分析
http://fangjian0423.github.io/2016/03/29/jdk_linkedhashmap/

jdk TreeMap工作原理分析
http://fangjian0423.github.io/2016/04/07/jdk_treemap/

回复
hi说道：

2018-07-23 21:00

fastjson将json字符串转化成map的五种方法
https://blog.csdn.net/sinat_29774479/article/details/78730359

java 两个map对象的合并成一个map对象
https://blog.csdn.net/lolashe/article/details/8785111

Java中如何把一下字符串转换成map
https://www.cnblogs.com/zhaoyan001/p/6108370.html
java中string类型转换成map
https://www.cnblogs.com/chongyou/p/7466039.html

回复

发表评论取消回复

Read more, Write more, Think more, Know more.