hashMap,treeMap,LinkedHashMap的默认排序

阅读更多

一、简单描述

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

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

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

        Map.Entry返回Collections视图。

        注：map简单的UML

 

 HashMap是按照插入key的hashcode值进行数组排序的，插入排序，不保证稳定性。

 

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

 

/** 
     * Constructs a new, empty tree map, ordered according to the given 
     * comparator.  All keys inserted into the map must be mutually 
     * comparable 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 comparator) {  
        this.comparator = comparator;  
    }  

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

public static , V> Comparator> comparingByKey() {
            return (Comparator> & Serializable)
                (c1, c2) -> c1.getKey().compareTo(c2.getKey());
        }
   public static > Comparator> comparingByValue() {
            return (Comparator> & Serializable)
                (c1, c2) -> c1.getValue().compareTo(c2.getValue());
        }

 

LinkedHashMap重写了Entry实现类，实现成双向链表的类型结构，会存取borfer和after的元素，插入的时候把当前元素插入到链表头部，

继承自HashMap，一个有序的Map接口实现，这里的有序指的是元素可以按插入顺序或访问顺序排列；

 

与HashMap的异同：同样是基于散列表实现，区别是，LinkedHashMap内部多了一个双向循环链表的维护，该链表是有序的，可以按元素插入顺序或元素最近访问顺序(LRU)排列，

简单地说：LinkedHashMap=散列表+循环双向链表

package java.util;
import java.io.*;


public class LinkedHashMap
    extends HashMap
    implements Map
{

    private static final long serialVersionUID = 3801124242820219131L;

    /**
     * 双向循环链表，  头结点(空节点)
     */
    private transient Entry 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 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 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 e = (Entry)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 extends HashMap.Entry {
        // 节点前后引用
        Entry before, after;

        //构造函数与HashMap一致
        Entry(int hash, K key, V value, HashMap.Entry next) {
            super(hash, key, value, next);
        }

        /**
         * 移除节点，并修改前后引用
         */
        private void remove() {
            before.after = after;
            after.before = before;
        }

        /**
         * 将当前节点插入到existingEntry的前面
         */
        private void addBefore(Entry existingEntry) {
            after  = existingEntry;
            before = existingEntry.before;
            before.after = this;
            after.before = this;
        }

        /**
         * 在HashMap的put和get方法中，会调用该方法，在HashMap中该方法为空
         * 在LinkedHashMap中，当按访问顺序排序时，该方法会将当前节点插入到链表尾部(头结点的前一个节点)，否则不做任何事
         */
        void recordAccess(HashMap m) {
            LinkedHashMap lm = (LinkedHashMap)m;
            //当LinkedHashMap按访问排序时
            if (lm.accessOrder) {
                lm.modCount++;
                //移除当前节点
                remove();
                //将当前节点插入到头结点前面
                addBefore(lm.header);
            }
        }

        void recordRemoval(HashMap m) {
            remove();
        }
    }
    
    //迭代器
    private abstract class LinkedHashIterator implements Iterator {
        //初始化下个节点引用
        Entry nextEntry    = header.after;
        Entry 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 nextEntry() {
            //快速失败机制
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            //链表为空情况
            if (nextEntry == header)
                throw new NoSuchElementException();
            
            //给lastReturned赋值，最近一个从迭代器返回的节点对象
            Entry e = lastReturned = nextEntry;
            nextEntry = e.after;
            return e;
        }
    }
    //key迭代器
    private class KeyIterator extends LinkedHashIterator {
        public K next() { return nextEntry().getKey(); }
    }
    //value迭代器
    private class ValueIterator extends LinkedHashIterator {
        public V next() { return nextEntry().value; }
    }
    //key-value迭代器
    private class EntryIterator extends LinkedHashIterator> {
        public Map.Entry next() { return nextEntry(); }
    }

    // 返回不同的迭代器对象
    Iterator newKeyIterator()   { return new KeyIterator();   }
    Iterator newValueIterator() { return new ValueIterator(); }
    Iterator> 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 eldest = header.after;
        if (removeEldestEntry(eldest)) {
            removeEntryForKey(eldest.key);
        }
    }

    /**
     * 创建节点，并将该节点插入到链表尾部
     */
    void createEntry(int hash, K key, V value, int bucketIndex) {
        HashMap.Entry old = table[bucketIndex];
        Entry e = new Entry<>(hash, key, value, old);
        table[bucketIndex] = e;
        //将该节点插入到链表尾部
        e.addBefore(header);
        size++;
    }

    /**
     * 该方法在创建新节点的时候调用，
     * 判断是否有必要删除链表头部的第一个节点(最不经常访问或最先插入的节点，由accessOrder决定)
     */
    protected boolean removeEldestEntry(Map.Entry eldest) {
        return false;
    }
}

 

 重写了Iterator的实现LinkedHashIterator，遍历的时候按照双向链表的顺序进行遍历，不是按照桶里数组的顺序进行遍历（HashMap）.

AbstractMap中的toString方法即调用的entrySet()方法，进行的遍历打印的值。

图解：

第一张图是LinkedHashMap的全部数据结构，包含散列表和循环双向链表，由于循环双向链表线条太多了，不好画，简单的画了一个节点(黄色圈出来的)示意一下，注意左边的红色箭头引用为Entry节点对象的next引用(散列表中的单链表)，绿色线条为Entry节点对象的before, after引用(循环双向链表的前后引用)；

 

• 
• 大小: 18.4 KB

• 
• 大小: 134.9 KB

• 查看图片附件