Java对Map排序

1.  Collections静态类

类java.util.Collections提供了一些静态方法实现了基于List容器的一些常用算法。

2.  常用Map之间的区别

HashMap：

最常用的Map,它根据键的HashCode 值存储数据,根据键可以直接获取它的值，具有很快的访问速度。HashMap最多只允许一条记录的键为Null(多条会覆盖);允许多条记录的值为 Null。非同步的。

TreeMap：

能够把它保存的记录根据键(key)排序,默认是按升序排序，也可以指定排序的比较器，当用Iterator 遍历TreeMap时，得到的记录是排过序的。TreeMap不允许key的值为null。非同步的。

Hashtable：

与 HashMap类似,不同的是：key和value的值均不允许为null;它支持线程的同步，即任一时刻只有一个线程能写Hashtable,因此也导致了Hashtale在写入时会比较慢。

LinkedHashMap：

保存了记录的插入顺序，在用Iterator遍历LinkedHashMap时，先得到的记录肯定是先插入的.在遍历的时候会比HashMap慢。key和value均允许为空，非同步的。 

3.  排序思想

Collections的sort方法可以对实现List接口的容器中的元素排序。因此，我们只需要把Map里面的Key-Vaule整对存放在List容器中，并且实现一个比较器， 然后调用Collections.sort()方法就可以实现对Map中的元素排序。

4.  Map.Entry<Object, Object>

Map.Entry<Object, Object>是Map的内部类，它的对象用来表示一个Key-Vaule对，因此，List容器中应该存放的是Map.Entry<Object, Object>的对象。

5.  实现步骤

例如：Map<Integer, Double> map = new HashMap<Integer, Double>();

(1) 将Map里面的Key-Vaule整对存放在List容器中

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

map.entrySet()获取Map.Entry<Integer, Double>的集合(Set)

(2)实现一个比较器（对Value排序）

写一个类实现继承Comparator<T>接口即可

class MapCompatator implements Comparator<Map.Entry<Integer, Double>>

继承Comparator接口需要实现compare(Object o1, Object o2)方法

public int compare(Map.Entry<Integer, Double> o1, Map.Entry<Integer, Double> o2)
{
    if (o1.getValue() > o2.getValue())
    {
        return 1;
    } else if (o1.getValue() < o2.getValue())
    {
        return -1;
    } else
    {
        return 0;
    }
}

(3)实现一个比较器（对Key排序）

如果要对Key进行排序，只需要把getVaule()方法换成getKey()方法即可

(4)比较（升序）

Comparator<Map.Entry<Integer, Double>> comparator = new MapCompatator();

Collections.sort(list, comparator);

(5)比较（降序）

(4)排序结果为升序，如果需要降序的序列，仅需要对排序结果再调用Collections类中的reverse()方法即可，而不需要重新改变比较器的代码。

Collections.reverse(list);

6.  一个完整的例子

import java.util.*; 

public class MapSort
{

    public static void main(String[] args)
    {
        Map<String, Integer> map = new HashMap<String, Integer>();
        Random m = new Random();
        for (int i = 0; i < 10; i++)
        {
            map.put(i+"", m.nextInt(100));
        }
        List<Map.Entry<String, Integer>> list = new ArrayList<Map.Entry<String, Integer>>(map.entrySet());
        System.out.println("排序前：" + list);
        Comparator<Map.Entry<String, Integer>> comparator = new MapCompatator();
        Collections.sort(list, comparator);
        System.out.println("排序后（升序）：" + list);
        Collections.reverse(list);
        System.out.println("排序后（降序）：" + list);

    }
}

class MapCompatator implements Comparator<Map.Entry<String, Integer>>
{

    public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2)
    {
        if (o1.getValue() > o2.getValue())
        {
            return 1;
        } else if (o1.getValue() < o2.getValue())
        {
            return -1;
        } else
        {
            return 0;
        }
    }
}

其中的一个结果为：

run:

排序前：[0=14, 1=16, 2=71, 3=13, 4=75, 5=64, 6=62, 7=45, 8=47, 9=86]

排序后（升序）：[3=13, 0=14, 1=16, 7=45, 8=47, 6=62, 5=64, 2=71, 4=75, 9=86]

排序后（降序）：[9=86, 4=75, 2=71, 5=64, 6=62, 8=47, 7=45, 1=16, 0=14, 3=13]

成功构建 (总时间: 1 秒)