一、简单描述
Map是键值对的集合接口，它的实现类主要包括：HashMap,TreeMap,HashTable以及LinkedHashMap等。
TreeMap：能够把它保存的记录根据键(key)排序,默认是按升序排序，也可以指定排序的比较器，该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。
HashMap的值是没有顺序的，它是按照key的HashCode来实现的，根据键可以直接获取它的值，具有很快的访问速度。HashMap最多只允许一条记录的键为Null(多条会覆盖);允许多条记录的值为 Null。非同步的。
Map.Entry返回Collections视图。
注：map简单的UML
伦理片 http://www.dotdy.com/ HashMap是按照插入key的hashcode值进行数组排序的，插入排序，不保证稳定性。
TreeMap 接收的comparator的接口默认是key值的排序，源代码如下：
Java代码 /** * 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; }
注：java8 在Map接口中的Entry接口中实现了根据key、value排序的接口，源代码如下：
Java代码 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()); }
LinkedHashMap重写了Entry实现类，实现成双向链表的类型结构，会存取borfer和after的元素，插入的时候把当前元素插入到链表头部，
继承自HashMap，一个有序的Map接口实现，这里的有序指的是元素可以按插入顺序或访问顺序排列；
与HashMap的异同：同样是基于散列表实现，区别是，LinkedHashMap内部多了一个双向循环链表的维护，该链表是有序的，可以按元素插入顺序或元素最近访问顺序(LRU)排列，
简单地说：LinkedHashMap=散列表+循环双向链表
Java代码 package java.util; import java.io.*; public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V> { private static final long serialVersionUID = 3801124242820219131L; /** * 双向循环链表， 头结点(空节点) */ private transient Entry<K,V> header; /** * accessOrder为true时，按访问顺序排序，false时，按插入顺序排序 */ private final boolean accessOrder; /** * 生成一个空的LinkedHashMap,并指定其容量大小和负载因子， * 默认将accessOrder设为false，按插入顺序排序 */ public LinkedHashMap(int initialCapacity, float loadFactor) { super(initialCapacity, loadFactor); accessOrder = false; } /** * 生成一个空的LinkedHashMap,并指定其容量大小，负载因子使用默认的0.75， * 默认将accessOrder设为false，按插入顺序排序 */ public LinkedHashMap(int initialCapacity) { super(initialCapacity); accessOrder = false; } /** * 生成一个空的HashMap,容量大小使用默认值16，负载因子使用默认值0.75 * 默认将accessOrder设为false，按插入顺序排序. */ public LinkedHashMap() { super(); accessOrder = false; } /** * 根据指定的map生成一个新的HashMap,负载因子使用默认值，初始容量大小为Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,DEFAULT_INITIAL_CAPACITY) * 默认将accessOrder设为false，按插入顺序排序. */ public LinkedHashMap(Map<? extends K, ? extends V> m) { super(m); accessOrder = false; } /** * 生成一个空的LinkedHashMap,并指定其容量大小和负载因子， * 默认将accessOrder设为true，按访问顺序排序 */ public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) { super(initialCapacity, loadFactor); this.accessOrder = accessOrder; } /** * 覆盖HashMap的init方法，在构造方法、Clone、readObject方法里会调用该方法 * 作用是生成一个双向链表头节点，初始化其前后节点引用 */ @Override void init() { header = new Entry<>(-1, null, null, null); header.before = header.after = header; } /** * 覆盖HashMap的transfer方法，性能优化，这里遍历方式不采用HashMap的双重循环方式 * 而是直接通过双向链表遍历Map中的所有key-value映射 */ @Override void transfer(HashMap.Entry[] newTable, boolean rehash) { int newCapacity = newTable.length; //遍历旧Map中的所有key-value for (Entry<K,V> e = header.after; e != header; e = e.after) { if (rehash) e.hash = (e.key == null) ? 0 : hash(e.key); //根据新的数组长度，重新计算索引， int index = indexFor(e.hash, newCapacity); //插入到链表表头 e.next = newTable[index]; //将e放到索引为i的数组处 newTable[index] = e; } } /** * 覆盖HashMap的transfer方法，性能优化，这里遍历方式不采用HashMap的双重循环方式 * 而是直接通过双向链表遍历Map中的所有key-value映射, */ public boolean containsValue(Object value) { // Overridden to take advantage of faster iterator if (value==null) { for (Entry e = header.after; e != header; e = e.after) if (e.value==null) return true; } else { for (Entry e = header.after; e != header; e = e.after) if (value.equals(e.value)) return true; } return false; } /** * 通过key获取value，与HashMap的区别是：当LinkedHashMap按访问顺序排序的时候，会将访问的当前节点移到链表尾部(头结点的前一个节点) */ public V get(Object key) { Entry<K,V> e = (Entry<K,V>)getEntry(key); if (e == null) return null; e.recordAccess(this); return e.value; } /** * 调用HashMap的clear方法，并将LinkedHashMap的头结点前后引用指向自己 */ public void clear() { super.clear(); header.before = header.after = header; } /** * LinkedHashMap节点对象 */ private static class Entry<K,V> extends HashMap.Entry<K,V> { // 节点前后引用 Entry<K,V> before, after; //构造函数与HashMap一致 Entry(int hash, K key, V value, HashMap.Entry<K,V> next) { super(hash, key, value, next); } /** * 移除节点，并修改前后引用 */ private void remove() { before.after = after; after.before = before; } /** * 将当前节点插入到existingEntry的前面 */ private void addBefore(Entry<K,V> existingEntry) { after = existingEntry; before = existingEntry.before; before.after = this; after.before = this; } /** * 在HashMap的put和get方法中，会调用该方法，在HashMap中该方法为空 * 在LinkedHashMap中，当按访问顺序排序时，该方法会将当前节点插入到链表尾部(头结点的前一个节点)，否则不做任何事 */ void recordAccess(HashMap<K,V> m) { LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m; //当LinkedHashMap按访问排序时 if (lm.accessOrder) { lm.modCount++; //移除当前节点 remove(); //将当前节点插入到头结点前面 addBefore(lm.header); } } void recordRemoval(HashMap<K,V> m) { remove(); } } //迭代器 private abstract class LinkedHashIterator<T> implements Iterator<T> { //初始化下个节点引用 Entry<K,V> nextEntry = header.after; Entry<K,V> lastReturned = null; /** * 用于迭代期间快速失败行为 */ int expectedModCount = modCount; //链表遍历结束标志，当下个节点为头节点的时候 public boolean hasNext() { return nextEntry != header; } //移除当前访问的节点 public void remove() { //lastReturned会在nextEntry方法中赋值 if (lastReturned == null) throw new IllegalStateException(); //快速失败机制 if (modCount != expectedModCount) throw new ConcurrentModificationException(); LinkedHashMap.this.remove(lastReturned.key); lastReturned = null; //迭代器自身删除节点，并不是其他线程修改Map结构，所以这里要修改expectedModCount expectedModCount = modCount; } //返回链表下个节点的引用 Entry<K,V> nextEntry() { //快速失败机制 if (modCount != expectedModCount) throw new ConcurrentModificationException(); //链表为空情况 if (nextEntry == header) throw new NoSuchElementException(); //给lastReturned赋值，最近一个从迭代器返回的节点对象 Entry<K,V> e = lastReturned = nextEntry; nextEntry = e.after; return e; } } //key迭代器 private class KeyIterator extends LinkedHashIterator<K> { public K next() { return nextEntry().getKey(); } } //value迭代器 private class ValueIterator extends LinkedHashIterator<V> { public V next() { return nextEntry().value; } } //key-value迭代器 private class EntryIterator extends LinkedHashIterator<Map.Entry<K,V>> { public Map.Entry<K,V> next() { return nextEntry(); } } // 返回不同的迭代器对象 Iterator<K> newKeyIterator() { return new KeyIterator(); } Iterator<V> newValueIterator() { return new ValueIterator(); } Iterator<Map.Entry<K,V>> newEntryIterator() { return new EntryIterator(); } /** * 创建节点，插入到LinkedHashMap中，该方法覆盖HashMap的addEntry方法 */ void addEntry(int hash, K key, V value, int bucketIndex) { super.addEntry(hash, key, value, bucketIndex); // 注意头结点的下个节点即header.after，存放于链表头部，是最不经常访问或第一个插入的节点， //有必要的情况下(如容量不够,具体看removeEldestEntry方法的实现，这里默认为false，不删除)，可以先删除 Entry<K,V> eldest = header.after; if (removeEldestEntry(eldest)) { removeEntryForKey(eldest.key); } } /** * 创建节点，并将该节点插入到链表尾部 */ void createEntry(int hash, K key, V value, int bucketIndex) { HashMap.Entry<K,V> old = table[bucketIndex]; Entry<K,V> e = new Entry<>(hash, key, value, old); table[bucketIndex] = e; //将该节点插入到链表尾部 e.addBefore(header); size++; } /** * 该方法在创建新节点的时候调用， * 判断是否有必要删除链表头部的第一个节点(最不经常访问或最先插入的节点，由accessOrder决定) */ protected boolean removeEldestEntry(Map.Entry<K,V> eldest) { return false; } }
重写了Iterator的实现LinkedHashIterator，遍历的时候按照双向链表的顺序进行遍历，不是按照桶里数组的顺序进行遍历（HashMap）.
AbstractMap中的toString方法即调用的entrySet()方法，进行的遍历打印的值。
图解：
第一张图是LinkedHashMap的全部数据结构，包含散列表和循环双向链表，由于循环双向链表线条太多了，不好画，简单的画了一个节点(黄色圈出来的)示意一下，注意左边的红色箭头引用为Entry节点对象的next引用(散列表中的单链表)，绿色线条为Entry节点对象的before, after引用(循环双向链表的前后引用)；
