hashMap,treeMap,LinkedHashMap的默认排序

来源：互联网发布：sz.java.tedu.cn v 编辑：程序博客网时间：2024/06/18 16:31

一、简单描述

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引用(循环双向链表的前后引用)；

0 0