[Java]HashMap的两种排序方式

先将 Map 中的 key 和 value 全部取出来封装成 JavaBea 数组，再将这个数组排序，
排序完成后，重新写回 Map 中，写回时采用 LinkedHashMap 可以保证迭代的顺序。

下面的代码可以参考一下：

?





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

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashMap;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

public
class Test {

    public
static void main(String[] args) {

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

        map.put("ee", 3);

        map.put("b", 1);

        map.put("d", 2);

        map.put("eee", 3);

        map.put("A", 1);

        map.put("K", 2);

        map.put("ade", 1);

        map.put("c", 2);

        map.put("aee", 3);

        map.put("a", 1);

        map.put("faed", 2);

        map.put("bdd", 1);

        map.put("qec", 2);

        map.put("eade", 3);

        map.put("Aadf", 1);

        map.put("Kqe", 2);

        Map<String, Integer> sortMap = new
Test().sortMap(map);

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

            System.out.println(entry.getKey() + " --> "
+ entry.getValue());

        }

    }

    public
<K, V extends
Number> Map<String, V> sortMap(Map<String, V> map) {

        class
MyMap<M, N> {

            private
M key;

            private
N value;

            private
M getKey() {

                return
key;

            }

            private
void setKey(M key) {

                this.key = key;

            }

            private
N getValue() {

                return
value;

            }

            private
void setValue(N value) {

                this.value = value;

            }

        }

        List<MyMap<String, V>> list = new
ArrayList<MyMap<String, V>>();

        for
(Iterator<String> i = map.keySet().iterator(); i.hasNext(); ) {

            MyMap<String, V> my = new
MyMap<String, V>();

            String key = i.next();

            my.setKey(key);

            my.setValue(map.get(key));

            list.add(my);

        }

        Collections.sort(list, new
Comparator<MyMap<String, V>>() {

            public
int compare(MyMap<String, V> o1, MyMap<String, V> o2) {

                if(o1.getValue() == o2.getValue()) {

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

                }else{

                    return
(int)(o1.getValue().doubleValue() - o2.getValue().doubleValue());

                }

            }

        });

        Map<String, V> sortMap = new
LinkedHashMap<String, V>();

        for(int
i = 0, k = list.size(); i < k; i++) {

            MyMap<String, V> my = list.get(i);

            sortMap.put(my.getKey(), my.getValue());

        }

        return
sortMap;

    }

}

　　

Map<String, Integer> map = new
HashMap<String, Integer>();
map.put("d", 2);
map.put("c",
1);
map.put("b", 1);
map.put("a", 3);

List<Map.Entry<String, Integer>>
infoIds =
new
ArrayList<Map.Entry<String, Integer>>(map.entrySet());

//排序前
for (int i = 0; i < infoIds.size(); i++)
{
String id =
infoIds.get(i).toString();

System.out.println(id);
}
//d
2
//c 1
//b
1
//a 3

//排序
Collections.sort(infoIds, new
Comparator<Map.Entry<String, Integer>>() {

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

//return (o2.getValue() - o1.getValue());

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

//排序后
for (int i = 0; i < infoIds.size(); i++)
{
String id =
infoIds.get(i).toString();

System.out.println(id);
}
//根据key排序
//a
3
//b 1
//c
1
//d 2
//根据value排序
//a 3
//d
2
//b 1
//c
1

参考：
  http://bbs.csdn.net/topics/230054066

　　　　http://www.cnblogs.com/lovebread/archive/2009/11/23/1609121.html

时间： 2024-11-07 03:45:19

[Java]HashMap的两种排序方式的相关文章

HashMap的两种排序方式

Map<String, Integer> map = new HashMap<String, Integer>(); map.put("d", 2); map.put("c", 1); map.put("b", 1); map.put("a", 3); List<Map.Entry<String, Integer>> infoIds = new ArrayList<Map.

Java多线程的两种实现方式：继承Thread类 &amp; 实现Runable接口

------Java培训.Android培训.iOS培训..Net培训.期待与您交流! 创建和启动线程的两种传统方式: Java提供了线程类Thread来创建多线程的程序.其实,创建线程与创建普通的类的对象的操作是一样的,而线程就是Thread类或其子类的实例对象.每个Thread对象描述了一个单独的线程.要产生一个线程,有两种方法: ◆需要从Java.lang.Thread类派生一个新的线程类,重载它的run()方法: ◆实现Runnalbe接口,重载Runnalbe接口中的run()方法.

HashMap的两种遍历方式

HashMap存储的是键值对:key-value . java将HashMap的键值对作为一个整体对象(java.util.Map.Entry)进行处理,这优化了HashMap的遍历处理. 第一种:(只遍历一次,将key及value都放到entry中,效率高) Map map = new HashMap(); Iterator iter = map.entrySet().iterator(); while (iter.hasNext()) { java.util.Map.Entry entry

Java学习(九)：Java线程的两种实现方式

线程是程序中一个单一的顺序控制流程.进程内一个相对独立的.可调度的执行单元,是系统独立调度和分派CPU的基本单位指运行中的程序的调度单位.在单个程序中同时运行多个线程完成不同的工作,称为多线程. 进程(Process)是计算机中的程序关于某数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,是操作系统结构的基础. Java线程创建的两种方式: 1.继承Thread类 public class MyThread extends Thread { private String name;

Java多线程的两种实现方式的区别以及深刻同步问题中的锁对象

首先我们知道创建线程有两种方式: 1.继承Thread类:2.实现Runnable接口. 但是这两这并非完全一样的.下面谈谈区别: 因为Java并不支持多继承的(接口是可以多继承接口的.不过一般我们不提),但支持多实现.当一个类继承了父类,就不能再继承Thread类,只能通过实现接口的形式创建线程. 继承Runnable接口更加符合面向对象的思想.线程分为两部分,一是线程对象,二是线程任务.继承Thread类,线程对象和线程任务(run方法内的代码)耦合在一起.一旦创建了Thread类的子类对象

十四、Python的自定义排序 以及两种排序方式

data_list = [] data_list.append({'softname':'1','version':'1.2.2.2'}) data_list.append({'softname':'7','version':'1.2.2.2'}) data_list.append({'softname':'5','version':'1.2.2.2'}) data_list.append({'softname':'2','version':'1.2.2.2'}) data_list.appen

Java中的七种排序方式代码示例

package baseJava; /** * @title SortMethods.java * @author DonsenChen * @Date 2018年5月2日 上午10:16:03 * @Description */ public class SortMethods { public static void main(String[] args) { int[] arr = { 3, 7, 9, 1, 4, 8, 2, 6, 5 }; binarySort(arr); bubble

java map的两种遍历方式

1.1.  通过key得到value //得到所有的key值 Set<String> keySet = map.keySet(); //根据key值得到value值 for (String key : keySet) { System.out.println(key+":"+map.get(key)); } 1.2.  通过entry得到key和value //得到所有的entry Set<Entry<String, String>> entrySe

TreeSet的两种排序方式比较

前情: TreeSet可以对元素按照某种规则进行排序: 但是,当添加的是对象(Student)时,如何排序的呢? 会发现,无法进行排序. ①自然排序 原文地址:https://www.cnblogs.com/slimshady/p/10821096.html