map key value的排序问题

  一、简单描述

Map是键值对的集合接口，它的实现类主要包括：HashMap,TreeMap,HashTable以及LinkedHashMap等。

        TreeMap：能够把它保存的记录根据键(key)排序,默认是按升序排序，也可以指定排序的比较器，该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。

        HashMap的值是没有顺序的，它是按照key的HashCode来实现的，根据键可以直接获取它的值，具有很快的访问速度。HashMap最多只允许一条记录的键为Null(多条会覆盖);允许多条记录的值为 Null。非同步的。

        Map.Entry返回Collections视图。

        注：map简单的UML

二、排序的具体实现

（1）较简单的排序方式(直接根据key值进行比较)，按key值排序

 Map<String, String> map = new TreeMap<String, String>(new
		 Comparator<String>() {
		 public int compare(String obj1, String obj2) {
		 return obj1.compareTo(obj2);
		 }
		 });
		 map.put("b", "1111");
		 map.put("d", "2222");
		 map.put("c", "3333");
		 map.put("a", "4444");
		
		 for (Entry entry : map.entrySet()) {
		 System.err.println(entry.getKey() + "========" + entry.getValue());
		 }

TreeMap 接收的comparator的接口默认是key值的排序，源代码如下：

/**
     * Constructs a new, empty tree map, ordered according to the given
     * comparator.  All keys inserted into the map must be <em>mutually
     * comparable</em> by the given comparator: {@code comparator.compare(k1,
     * k2)} must not throw a {@code ClassCastException} for any keys
     * {@code k1} and {@code k2} in the map.  If the user attempts to put
     * a key into the map that violates this constraint, the {@code put(Object
     * key, Object value)} call will throw a
     * {@code ClassCastException}.
     *
     * @param comparator the comparator that will be used to order this map.
     *        If {@code null}, the {@linkplain Comparable natural
     *        ordering} of the keys will be used.
     */
    public TreeMap(Comparator<? super K> comparator) {
        this.comparator = comparator;
    }

（2） 根据Map.Entry进行排序，即可实现key值的排序,也可以实现value值的排序

Map<String, String> map = new HashMap();
		map.put("1", "b");
		map.put("2", "a");
		map.put("4", "e");
		map.put("5", "c");
		map.put("3", "d");
		Set<Map.Entry<String, String>> keyEntries = new TreeSet<Map.Entry<String, String>>(
				(Comparator<Map.Entry<String, String>>) (c1, c2) -> c1.getKey().compareTo(c2.getKey()));
		keyEntries.addAll(map.entrySet());
		for (Entry<String, String> entry : keyEntries) {
			System.err.println(entry.getKey() + "----" + entry.getValue());
		}


		Set<Map.Entry<String, String>> valueEntries = new TreeSet<Map.Entry<String, String>>(
				(Comparator<Map.Entry<String, String>>) (c1, c2) -> c1.getValue().compareTo(c2.getValue()));
		valueEntries.addAll(map.entrySet());
		for (Entry<String, String> entry : valueEntries) {
			System.err.println(entry.getKey() + "----" + entry.getValue());
		}

注：java8 在Map接口中的Entry接口中实现了根据key、value排序的接口，源代码如下：

 public static <K extends Comparable<? super K>, V> Comparator<Map.Entry<K,V>> comparingByKey() {
            return (Comparator<Map.Entry<K, V>> & Serializable)
                (c1, c2) -> c1.getKey().compareTo(c2.getKey());
        }
   public static <K, V extends Comparable<? super V>> Comparator<Map.Entry<K,V>> comparingByValue() {
            return (Comparator<Map.Entry<K, V>> & Serializable)
                (c1, c2) -> c1.getValue().compareTo(c2.getValue());
        }

（3） 当要比较的key或者value 是一个对象的时候，你可以定义一个comparator进行排序， java8 在Map接口中的Entry接口有两个接收comparator的方法，源码如下：

 public static <K, V> Comparator<Map.Entry<K, V>> comparingByKey(Comparator<? super K> cmp) {
            Objects.requireNonNull(cmp);
            return (Comparator<Map.Entry<K, V>> & Serializable)
                (c1, c2) -> cmp.compare(c1.getKey(), c2.getKey());
        }
    public static <K, V> Comparator<Map.Entry<K, V>> comparingByValue(Comparator<? super V> cmp) {
            Objects.requireNonNull(cmp);
            return (Comparator<Map.Entry<K, V>> & Serializable)
                (c1, c2) -> cmp.compare(c1.getValue(), c2.getValue());
        }
    }

例子：

Map<String, Person> personMap = new HashMap<String, Person>();
		personMap.put("a", new Person(1, "aaa"));
		personMap.put("acd", new Person(4, "acd"));
		personMap.put("abc", new Person(3, "abc"));
		personMap.put("eda", new Person(2, "eda"));
		Set<Map.Entry<String, Person>> valueEntries = new TreeSet(Map.Entry.comparingByValue(new Comparator<Person>() {
			@Override
			public int compare(Person p1, Person p2) {
				return p1.id - p2.id;
			}
		}));
		// Set<Map.Entry<String, Person>> valueEntries = new
		// TreeSet<Map.Entry<String, Person>>(
		// new Comparator<Map.Entry<String, Person>>() {
		//
		// @Override
		// public int compare(Entry<String, Person> o1, Entry<String, Person>
		// o2) {
		// Person p1 = o1.getValue();
		// Person p2 = o2.getValue();
		// return p1.id - p2.id;
		// }
		// });
		valueEntries.addAll(personMap.entrySet());
		for (Entry<String, Person> entry : valueEntries) {
			System.err.println(entry.getKey() + "----" + entry.getValue().id);
		}

结束语：这是学习源代码时个人的见解，如有不对的地方，请指正，不尽感激