Java集合之LinkedHashMap、TreeMap介绍

LinkedHashMap

LinkedHashMap使用双向链表来维护key-value对的次序（只需要考虑key测次序），该链表负责维护Map的迭代顺序，迭代顺序与key-value对的插入顺序保持一致。

LinkedHashMap可以避免对HashMap、Hashtable里的key-value对进行排序（只要插入key-value对时保持顺序即可），同时又可避免使用TreeMap所增加的成本。

LinkedHashMap需要维护元素的插入顺序，因此性能略低于HashMap的性能；
原因：它以链表来维护内部顺序，所以在迭代访问Map里的全部元素时将有较好的性能。LinkedHashMap可以记住key-value对的添加顺序。

示例：

package com.map;

import java.util.LinkedHashMap;

public class LinkedHashMapTest {

    public static void main(String[] args) {
        LinkedHashMap map = new LinkedHashMap<>();
        map.put("java", 1);
        map.put("C++", 1);
        map.put("C#", 2);
        System.out.println(map);
        //{java=1, C++=1, C#=2}
    }
}

SortedMap接口和TreeMap实现类

Map接口派生出一个SortedMap子接口，SortedMap接口也有一个TreeMap实现类。
TreeMap就是一个红黑树数据结构，每个key-value对即作为红黑树的一个节点。TreeMap存储key-value对节点时，需要根据key对节点进行排序。TreeMap可以保证所有的key-value对处于有序状态。

TreeMap两种排序方式：自然排序、定制排序。类似于TreeSet中判断两个元素相等的标准，TreeMap判断两个元素相等的标准是：
两个key通过compareTo()方法返回0，TreeMap即认为这两个key是相等的。

如果使用自定义类作为TreeMap的key,且想让TreeMap良好的工作，则重写该类的equals()方法和compareTo()方法时应保持一致的返回结果：两个key通过equals()方法比较返回true时，它们通过compareTo()方法比较应该返回0。如果equals()方法与compareTo()方法返回不一致，TreeMap与Map接口的规则就会冲突。

注意：
Set和Map的关系十分密切，Java源码就是先实现了HashMap和TreeMap等集合，然后通过包装一个所有的value都为null的Map集合实现了Set集合类。

TreeMap方法：

• Map.Entry firstEntry()
  返回该Map中最小的key所对应的key-value对，如果该Map为空，则返回null。
• Object firstKey()
  返回该Map中最小的key值，如果该Map为空，则返回null。
• Object lastKey()
  返回该Map中最大的key值，如果该Map为空或不存在这样的key，则返回null。
• Map.Entry higherEntry(Object key)
  返回该Map中位于key后一位的key-value对（即大于制定key的最小key所对应的key-value对）。如果该Map为空，则返回null。
• Object higherKey(Object key)
  返回该Map中位于key后一位的key-value对（即大于制定key的最小key所对应的key-value对）。如果该Map为空或不存在这样的key-value对，则返回null。
• Map.Entry lowerEntry(Object key)
  返回该Map中位于key前一位的key-value对（即小于制定key的最大key所对应的key-value对）。如果该Map为空，则都返回null。
• Object lowerKey(Object key)
  返回该Map中位于key前一位的key-value对（即小于制定key的最大key所对应的key-value对）。如果该Map为空或不存在这样的key，则都返回null。
• NavigableMap subMap(Object fromKey ,boolean fromInclusive,Object toKey,boolean toInclusive)
  返回该Map的子Map,其key的范围是从fromKey（是否包含取决于第二个参数）到toKey（是否包含取决于第四个参数）。
• SortedMap subMap(Objecy fromKey,Object toKey)
  返回该Map的子Map，其key的范围是从fromKey（包括）到toKey（不包括）。
• SortedMap tailMap(Object fromKey)
  返回该Map的子Map，其key的范围是大于fromKey（包括）的所有key。
• NavigableMap tailMap(Object fromKey,boolean inclusive)
  返回该Map的子Map，其key的范围是大于fromKey（是否包括取决于第二个参数）的所有key。
• SortedMap headMap(Object toKey)
  返回该Map的子Map，其key的范围是小于toKey（不包括）的所有key。
• NavigableMap headMap(Object toKey,boolean inclusive)
  返回该Map的子Map，其key的范围是小于toKey（是否包括取决于第二个参数）的所有key。

示例：

package com.map;

import java.util.TreeMap;

public class TreeMapTest {

    public static void main(String[] args) {
        TreeMap map = new TreeMap();
        map.put(new R(3), "Java轻量级应用");
        map.put(new R(-3), "Html轻量级应用");
        map.put(new R(5), "Java实战");
        System.out.println(map);
        //{count ==-3=Html轻量级应用, count ==3=Java轻量级应用, count ==5=Java实战}

        //返回TreeMap第一个Entry对象
        System.out.println(map.firstEntry());//count ==-3=Html轻量级应用
        //返回最后一个key
        System.out.println(map.lastKey());//count ==5
        //返回TreeMap的比new R(2)大的最小key值
        System.out.println(map.higherKey(new R(2)));//count ==3
        //返回TreeMap的比new R(2)小的最小key值
        System.out.println(map.lowerEntry(new R(2)));//count ==-3=Html轻量级应用
        //返回TreeMap子TreeMap
        System.out.println(map.subMap(new R(-5), new R(4)));//{count ==-3=Html轻量级应用, count ==3=Java轻量级应用}
    }
}

class R implements Comparable{

    int count;
    public R(   int count){
        this.count = count;
    }
    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        if(obj == this)
            return true;

        if(obj !=null &&obj.getClass() == R.class){
            R r = (R) obj ;
            return r.count == count;
        }
        return false;
    }

    @Override
    public String toString() {
        return "count ==" + count;
    }
    @Override
    public int compareTo(Object obj) {
        R r = (R) obj;
        return count > r .count ? 1 : count < r.count ? -1 : 0;
    }

}