java容器总结Map

Map接口

Map是 一个键值对的集合。也就是说,一个映射不能包含重复的键,每个键最多映射到一个值。该接口取代了Dictionary抽象类。
子接口:Bindings、ConcurrentMap、ConcurrentNavigableMap、MessageContext、LogicMessageContext、NavigableMap、SOAPMessageMap、SortedMap
实现类:AbstractMap, Attributes, AuthProvider, ConcurrentHashMap, EnumMap,ConcurrentSkipListMap,HashMap,Hashtable, IdentityHashMap, LinkedHashMap, PrinterStateReasons,Properties, Provider, RenderingHints, SimpleBindings, TabularDataSupport,TreeMap, UIDefaults,WeakHashMap

Paste_Image.png

HashMap介绍

a)HashMap的特点:

HashMap 继承于AbstractMap,实现了Map、Cloneable、java.io.Serializable接口。
HashMap基于Hash算法,通过put(key,value)存储,get(key)来获取。当传入key时,HashMap会根据key.hashCode()计算出hash值,根据hash值将value保存在bucket里。当计算出的hash值相同时怎么办呢,称之为Hash冲突,JDK1.6中HashMap采用的是位桶+链表的方式,即散列链表的方式,而JDK1.8中采用的是位桶+链表/红黑树的方式,也是非线程安全的。当某个位桶的链表的长度达到某个阀值的时候,这个链表就将转换成红黑树。
结构如图:

HashMap

从图中我们可以看到一个hashmap就是一个数组结构,当新建一个hashmap的时候,就会初始化一个数组。java1.6代码如下:
/** * The table, resized as necessary. Length MUST Always be a power of two. * FIXME 这里需要注意这句话,至于原因后面会讲到 */ transient Entry[] table;
java1.8代码则是这样的:
transient Node<K,V>[] table;
结点代码:
1.6代码:
链表节点
static class Entry<K,V> implements Map.Entry<K,V> { final K key; V value; final int hash; Entry<K,V> next; .......... }
1.8代码:
链表节点: static class Node<K,V> implements Map.Entry<K,V> { final int hash; final K key; V value; Node<K,V> next; //省略 } //红黑树节点 static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> { TreeNode<K,V> parent; // red-black tree links TreeNode<K,V> left; TreeNode<K,V> right; TreeNode<K,V> prev; // needed to unlink next upon deletion boolean red; TreeNode(int hash, K key, V val, Node<K,V> next) { super(hash, key, val, next); } //省略 }

hash算法

hash()函数在1.8时也进行改进。
java1.6
static int hash(int h) { h ^= (h >>> 20) ^ (h >>> 12); return h ^ (h >>> 7) ^ (h >>> 4); }
java1.8
static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); }

我们可以看到在hashmap中要找到某个元素,需要根据key的hash值来求得对应数组中的位置。如何计算这个位置就是hash算法。前面说过hashmap的数据结构是数组和链表的结合,所以我们当然希望这个hashmap里面的元素位置尽量的分布均匀些,尽量使得每个位置上的元素数量只有一个,那么当我们用hash算法求得这个位置的时候,马上就可以知道对应位置的元素就是我们要的,而不用再去遍历链表。
所以我们首先想到的就是把hashcode对数组长度取模运算,这样一来,元素的分布相对来说是比较均匀的。但是,“模”运算的消耗还是比较大的,能不能找一种更快速,消耗更小的方式那?java中时这样做的,
static int indexFor(int h, int length) { return h & (length-1); }
首先算得key得hashcode值,然后跟数组的长度-1做一次“与”运算(&)。看上去很简单,其实比较有玄机。比如数组的长度是2的4次方,那么hashcode就会和2的4次方-1做“与”运算。很多人都有这个疑问,为什么hashmap的数组初始化大小都是2的次方大小时,hashmap的效率最高,我以2的4次方举例,来解释一下为什么数组大小为2的幂时hashmap访问的性能最高。
看下图,左边两组是数组长度为16(2的4次方),右边两组是数组长度为15。两组的hashcode均为8和9,但是很明显,当它们和1110“与”的时候,产生了相同的结果,也就是说它们会定位到数组中的同一个位置上去,这就产生了碰撞,8和9会被放到同一个链表上,那么查询的时候就需要遍历这个链表,得到8或者9,这样就降低了查询的效率。同时,我们也可以发现,当数组长度为15的时候,hashcode的值会与14(1110)进行“与”,那么最后一位永远是0,而0001,0011,0101,1001,1011,0111,1101这几个位置永远都不能存放元素了,空间浪费相当大,更糟的是这种情况中,数组可以使用的位置比数组长度小了很多,这意味着进一步增加了碰撞的几率,减慢了查询的效率!

Paste_Image.png

所以说,当数组长度为2的n次幂的时候,不同的key算得得index相同的几率较小,那么数据在数组上分布就比较均匀,也就是说碰撞的几率小,相对的,查询的时候就不用遍历某个位置上的链表,这样查询效率也就较高了。

说到这里,我们再回头看一下hashmap中默认的数组大小是多少,查看源代码可以得知是16,为什么是16,而不是15,也不是20呢,看到上面annegu的解释之后我们就清楚了吧,显然是因为16是2的整数次幂的原因,在小数据量的情况下16比15和20更能减少key之间的碰撞,而加快查询的效率。 所以,在存储大容量数据的时候,最好预先指定hashmap的size为2的整数次幂次方。就算不指定的话,也会以大于且最接近指定值大小的2次幂来初始化的,代码如下(HashMap的构造方法中):

// 指定“容量大小”和“加载因子”的构造函数 public HashMap(int initialCapacity, float loadFactor) { if (initialCapacity < 0) throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity); // HashMap的最大容量只能是MAXIMUM_CAPACITY if (initialCapacity > MAXIMUM_CAPACITY) initialCapacity = MAXIMUM_CAPACITY; if (loadFactor <= 0 || Float.isNaN(loadFactor)) throw new IllegalArgumentException("Illegal load factor: " + loadFactor); // 找出“大于initialCapacity”的最小的2的幂 int capacity = 1; while (capacity < initialCapacity) capacity <<= 1; // 设置“加载因子” this.loadFactor = loadFactor; // 设置“HashMap阈值”,当HashMap中存储数据的数量达到threshold时,就需要将HashMap的容量加倍。 threshold = (int)(capacity * loadFactor); // 创建Entry数组,用来保存数据 table = new Entry[capacity]; init(); } // 指定“容量大小”的构造函数 public HashMap(int initialCapacity) { this(initialCapacity, DEFAULT_LOAD_FACTOR); } // 默认构造函数。 public HashMap() { // 设置“加载因子” this.loadFactor = DEFAULT_LOAD_FACTOR; // 设置“HashMap阈值”,当HashMap中存储数据的数量达到threshold时,就需要将HashMap的容量加倍。 threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR); // 创建Entry数组,用来保存数据 table = new Entry[DEFAULT_INITIAL_CAPACITY]; init(); } // 包含“子Map”的构造函数 public HashMap(Map<? extends K, ? extends V> m) { this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1, DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR); // 将m中的全部元素逐个添加到HashMap中 putAllForCreate(m); }

HashMap的存取实现

// 存储时:
int hash = key.hashCode(); // 这个hashCode方法这里不详述,只要理解每个key的hash是一个固定的int值
int index = hash % Entry[].length;
Entry[index] = value;

// 取值时:
int hash = key.hashCode();
int index = hash % Entry[].length;
return Entry[index];

1)put

疑问:如果两个key通过hash%Entry[].length得到的index相同,会不会有覆盖的危险?
  这里HashMap里面用到链式数据结构的一个概念。上面我们提到过Entry类里面有一个next属性,作用是指向下一个Entry。打个比方, 第一个键值对A进来,通过计算其key的hash得到的index=0,记做:Entry[0] = A。一会后又进来一个键值对B,通过计算其index也等于0,现在怎么办?HashMap会这样做:B.next = A,Entry[0] = B,如果又进来C,index也等于0,那么C.next = B,Entry[0] = C;这样我们发现index=0的地方其实存取了A,B,C三个键值对,他们通过next这个属性链接在一起。所以疑问不用担心。也就是说数组中存储的是最后插入的元素。到这里为止,HashMap的大致实现,我们应该已经清楚了。
1.6代码:

 public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value); //null总是放在数组的第一个链表中
        int hash = hash(key.hashCode());
        int i = indexFor(hash, table.length);
        //遍历链表
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            //如果key在链表中已存在,则替换为新value
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }

 

void addEntry(int hash, K key, V value, int bucketIndex) {
    Entry<K,V> e = table[bucketIndex];
    table[bucketIndex] = new Entry<K,V>(hash, key, value, e); //参数e, 是Entry.next
    //如果size超过threshold,则扩充table大小。再散列
    if (size++ >= threshold)
            resize(2 * table.length);
}

当然HashMap里面也包含一些优化方面的实现,这里也说一下。比如:Entry[]的长度一定后,随着map里面数据的越来越长,这样同一个index的链就会很长,会不会影响性能?HashMap里面设置一个因子,随着map的size越来越大,Entry[]会以一定的规则加长长度。

1.8

//put(K key,V value)函数 
    public V put(K key, V value) {
            return putVal(hash(key), key, value, false, true);
        }
    
  * @param onlyIfAbsent if true, don't change existing value //   
* @param evict if false, the table is in creation mode.  
* @return previous value, or null if none  
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {  
        Node<K,V>[] tab; Node<K,V> p; int n, i;  
        if ((tab = table) == null || (n = tab.length) == 0)//table空||length为0  
            n = (tab = resize()).length; // 分配空间,初始化  
        if ((p = tab[i = (n - 1) & hash]) == null)//hash所在位置(第i个桶)为null,直接put  
            tab[i] = newNode(hash, key, value, null);  
        else {//tab[i]有元素,则需要遍历结点后再添加   
            Node<K,V> e; K k;  
            // hash、key均等,说明待插入元素和第一个元素相等,直接更新  
            if (p.hash == hash &&  
                ((k = p.key) == key || (key != null && key.equals(k))))  
                e = p;  
            else if (p instanceof TreeNode) //红黑树冲突插入  
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);  
            else{ // 链表  
                for (int binCount = 0; ; ++binCount){ //死循环,直到break  
                    if ((e = p.next) == null) { //表尾仍没有key相同节点,新建节点  
                        p.next = newNode(hash, key, value, null);  
//若链表数量大于阀值8【9个】,则调用treeifyBin方法,仅当tab.length大于64才将链表改为红黑树  
                  // 如果tab.length<64或table=null,则重构一下链表  
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st  
                            treeifyBin(tab, hash); //binCount>=9则链表转树  
                        break; // 退出循环  
                    }  
                    if (e.hash == hash &&  
                        ((k = e.key) == key || (key != null && key.equals(k))))  
                        break;  // hash、key均相等,说明此时的节点==待插入节点,更新  
                    p = e; //更新p指向下一个节点  
               }  
            }  
            //当前节点e = p.next不为null,即链表中原本存在了相同key,则返回oldValue  
            if (e != null) {// existing mapping for key  
                V oldValue = e.value;  
               //onlyIfAbsent值为false,参数主要决定当该键已经存在时,是否执行替换  
                if (!onlyIfAbsent || oldValue == null)   
                    e.value = value;  
                afterNodeAccess(e); //调用linkedHashMap,move node to last  
                return oldValue;  
            }  
        }  
        ++modCount;  
        if (++size > threshold) //++size后再检测是否到了阀值  
            resize();  
        afterNodeInsertion(evict);//调用linkedHashMap,true则possibly remove eldest  
        return null; // 原hashMap中不存在相同key的键值对,则在插入键值对后,返回null。  
    }  
/** 
 * Replaces all linked nodes in bin at index for given hash unless 
 * table is too small, in which case resizes instead. 
 // MIN_TREEIFY_CAPACITY=64. 
// tab.length 为2的幂,表示容量,不是size。 
 */ //当桶中链表的数量>=9的时候,底层则改为红黑树实现   
    final void treeifyBin(Node<K,V>[] tab, inthash) {  
        intn, index; Node<K,V> e;  
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)  
            resize();  
        else if ((e = tab[index = (n - 1) & hash]) != null) {  
            TreeNode<K,V> hd = null, tl = null;  
            do {  
                TreeNode<K,V> p = replacementTreeNode(e, null);  
                if (tl == null)  
                    hd = p;  
                else {  
                    p.prev = tl;  
                    tl.next = p;  
                }  
                tl = p;  
            } while ((e = e.next) != null);  
            if ((tab[index] = hd) != null)  
                hd.treeify(tab);  
        }  
    }  
// For treeifyBin  
   TreeNode<K,V> replacementTreeNode(Node<K,V> p, Node<K,V> next) {  
        return new TreeNode<>(p.hash, p.key, p.value, next);  
    }  
// 链节点替换为树  

2)get
1.6

 public V get(Object key) {
        if (key == null)
            return getForNullKey();
        int hash = hash(key.hashCode());
        //先定位到数组元素,再遍历该元素处的链表
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
                return e.value;
        }
        return null;
}

1.8参考http://blog.csdn.net/u010887744/article/details/50346257

3)null key的存取
null key总是存放在Entry[]数组的第一个元素。

   private V putForNullKey(V value) {
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++;
        addEntry(0, null, value, 0);
        return null;
    }
 
    private V getForNullKey() {
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;
        }
        return null;
    }

解决hash冲突的办法

开放定址法(线性探测再散列,二次探测再散列,伪随机探测再散列)
再哈希法
链地址法
建立一个公共溢出区
http://www.nowamagic.net/academy/detail/3008021
Java中hashmap的解决办法就是采用的链地址法。

再散列rehash过程

当哈希表的容量超过默认容量时,必须调整table的大小。当容量已经达到最大可能值时,那么该方法就将容量调整到Integer.MAX_VALUE返回,这时,需要创建一张新表,将原表的映射到新表中。

   /**
     * Rehashes the contents of this map into a new array with a
     * larger capacity.  This method is called automatically when the
     * number of keys in this map reaches its threshold.
     *
     * If current capacity is MAXIMUM_CAPACITY, this method does not
     * resize the map, but sets threshold to Integer.MAX_VALUE.
     * This has the effect of preventing future calls.
     *
     * @param newCapacity the new capacity, MUST be a power of two;
     *        must be greater than current capacity unless current
     *        capacity is MAXIMUM_CAPACITY (in which case value
     *        is irrelevant).
     */
    void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }
        Entry[] newTable = new Entry[newCapacity];
        transfer(newTable);
        table = newTable;
        threshold = (int)(newCapacity * loadFactor);
    }

 

    /**
     * Transfers all entries from current table to newTable.
     */
    void transfer(Entry[] newTable) {
        Entry[] src = table;
        int newCapacity = newTable.length;
        for (int j = 0; j < src.length; j++) {
            Entry<K,V> e = src[j];
            if (e != null) {
                src[j] = null;
                do {
                    Entry<K,V> next = e.next;
                    //重新计算index
                    int i = indexFor(e.hash, newCapacity);
                    e.next = newTable[i];
                    newTable[i] = e;
                    e = next;
                } while (e != null);
            }
        }
    }

正常的ReHash过程

画了个图做了个演示。
我假设了我们的hash算法就是简单的用key mod 一下表的大小(也就是数组的长度)。
最上面的是old hash 表,其中的Hash表的size=2, 所以key = 3, 7, 5,在mod 2以后都冲突在table1这里了。
接下来的三个步骤是Hash表 resize成4,然后所有的<key,value> 重新rehash的过程。


(1)假设我们有两个线程。我用红色和浅蓝色标注了一下。我们再回头看一下我们的 transfer代码中的这个细节:

do 
{ Entry<K,V> next = e.next; // <--假设线程一执行到这里就被调度挂起了 
int i = indexFor(e.hash, newCapacity); 
e.next = newTable[i]; 
newTable[i] = e; 
e = next;
}
 while (e != null);

而我们的线程二执行完成了。于是我们有下面的这个样子。

在此输入图片描述

注意:因为Thread1的 e 指向了key(3),而next指向了key(7),其在线程二rehash后,指向了线程二重组后的链表。我们可以看到链表的顺序被反转后。 (2)线程一被调度回来执行。
先是执行 newTalbe[i] = e。
然后是e = next,导致了e指向了key(7)。
而下一次循环的next = e.next导致了next指向了key(3)。

在此输入图片描述
(3)一切安好。 线程一接着工作。把key(7)摘下来,放到newTable[i]的第一个,然后把e和next往下移。
在此输入图片描述
(4)环形链接出现。 e.next = newTable[i] 导致 key(3).next 指向了 key(7)。注意:此时的key(7).next 已经指向了key(3), 环形链表就这样出现了。
在此输入图片描述
于是,当我们的线程一调用到,HashTable.get(11)时,悲剧就出现了——Infinite Loop。

TreeMap

TreeMap底层是使用红黑树算法实现的。所以先介绍红黑树。

红黑树

红黑树又称红-黑二叉树,它首先是一颗二叉树,它具体二叉树所有的特性。同时红黑树更是一颗自平衡的排序二叉树。
红黑树有5个重要规则:
** 1、每个节点都只能是红色或者黑色**
2、根节点是黑色
3、每个叶节点(NIL节点,空节点)是黑色的。
4、如果一个结点是红的,则它两个子节点都是黑的。也就是说在一条路径上不能出现相邻的两个红色结点。
5、从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。

这些约束强制了红黑树的关键性质: 从根到叶子的最长的可能路径不多于最短的可能路径的两倍长。结果是这棵树大致上是平衡的。因为操作比如插入、删除和查找某个值的最坏情况时间都要求与树的高度成比例,这个在高度上的理论上限允许红黑树在最坏情况下都是高效的,而不同于普通的二叉查找树。所以红黑树它是复杂而高效的,其检索效率O(log n)。下图为一颗典型的红黑二叉树。


对于红黑二叉树而言它主要包括三大基本操作:左旋、右旋、着色。

图片来自:http://www.cnblogs.com/yangecnu/p/Introduce-Red-Black-Tree.html

TreeMap数据结构

** **TreeMap继承AbstractMap,实现NavigableMap、Cloneable、Serializable三个接口。其中AbstractMap表明TreeMap为一个Map即支持key-value的集合, NavigableMap(更多)则意味着它支持一系列的导航方法,具备针对给定搜索目标返回最接近匹配项的导航方法 。
TreeMap中同时也包含了如下几个重要的属性:
//比较器,因为TreeMap是有序的,通过comparator接口我们可以对TreeMap的内部排序进行精密的控制 private final Comparator<? super K> comparator; //TreeMap红-黑节点,为TreeMap的内部类 private transient Entry<K,V> root = null; //容器大小 private transient int size = 0; //TreeMap修改次数 private transient int modCount = 0; //红黑树的节点颜色--红色 private static final boolean RED = false; //红黑树的节点颜色--黑色 private static final boolean BLACK = true;

** ** 对于叶子节点Entry是TreeMap的内部类,它有几个重要的属性:
//键 K key; //值 V value; //左孩子 Entry<K,V> left = null; //右孩子 Entry<K,V> right = null; //父亲 Entry<K,V> parent; //颜色 boolean color = BLACK;

reeMap put()方法实现分析
** **在TreeMap的put()的实现方法中主要分为两个步骤,第一:构建排序二叉树,第二:平衡二叉树。

** **对于排序二叉树的创建,其添加节点的过程如下:
** **1、以根节点为初始节点进行检索。

** **2、与当前节点进行比对,若新增节点值较大,则以当前节点的右子节点作为新的当前节点。否则以当前节点的左子节点作为新的当前节点。

** **3、循环递归2步骤知道检索出合适的叶子节点为止。

** **4、将新增节点与3步骤中找到的节点进行比对,如果新增节点较大,则添加为右子节点;否则添加为左子节点。

** **按照这个步骤我们就可以将一个新增节点添加到排序二叉树中合适的位置。如下:

public V put(K key, V value) {  
           //用t表示二叉树的当前节点  
            Entry<K,V> t = root;  
            //t为null表示一个空树,即TreeMap中没有任何元素,直接插入  
            if (t == null) {  
                //比较key值,个人觉得这句代码没有任何意义,空树还需要比较、排序?  
                compare(key, key); // type (and possibly null) check  
                //将新的key-value键值对创建为一个Entry节点,并将该节点赋予给root  
                root = new Entry<>(key, value, null);  
                //容器的size = 1,表示TreeMap集合中存在一个元素  
                size = 1;  
                //修改次数 + 1  
                modCount++;  
                return null;  
            }  
            int cmp;     //cmp表示key排序的返回结果  
            Entry<K,V> parent;   //父节点  
            // split comparator and comparable paths  
            Comparator<? super K> cpr = comparator;    //指定的排序算法  
            //如果cpr不为空,则采用既定的排序算法进行创建TreeMap集合  
            if (cpr != null) {  
                do {  
                    parent = t;      //parent指向上次循环后的t  
                    //比较新增节点的key和当前节点key的大小  
                    cmp = cpr.compare(key, t.key);  
                    //cmp返回值小于0,表示新增节点的key小于当前节点的key,则以当前节点的左子节点作为新的当前节点  
                    if (cmp < 0)  
                        t = t.left;  
                    //cmp返回值大于0,表示新增节点的key大于当前节点的key,则以当前节点的右子节点作为新的当前节点  
                    else if (cmp > 0)  
                        t = t.right;  
                    //cmp返回值等于0,表示两个key值相等,则新值覆盖旧值,并返回新值  
                    else  
                        return t.setValue(value);  
                } while (t != null);  
            }  
            //如果cpr为空,则采用默认的排序算法进行创建TreeMap集合  
            else {  
                if (key == null)     //key值为空抛出异常  
                    throw new NullPointerException();  
                /* 下面处理过程和上面一样 */  
                Comparable<? super K> k = (Comparable<? super K>) key;  
                do {  
                    parent = t;  
                    cmp = k.compareTo(t.key);  
                    if (cmp < 0)  
                        t = t.left;  
                    else if (cmp > 0)  
                        t = t.right;  
                    else  
                        return t.setValue(value);  
                } while (t != null);  
            }  
            //将新增节点当做parent的子节点  
            Entry<K,V> e = new Entry<>(key, value, parent);  
            //如果新增节点的key小于parent的key,则当做左子节点  
            if (cmp < 0)  
                parent.left = e;  
          //如果新增节点的key大于parent的key,则当做右子节点  
            else  
                parent.right = e;  
            /*  
             *  上面已经完成了排序二叉树的的构建,将新增节点插入该树中的合适位置  
             *  下面fixAfterInsertion()方法就是对这棵树进行调整、平衡,具体过程参考上面的五种情况  
             */  
            fixAfterInsertion(e);  
            //TreeMap元素数量 + 1  
            size++;  
            //TreeMap容器修改次数 + 1  
            modCount++;  
            return null;  
        } 

TreeMap的deleteEntry()实现方法

private void deleteEntry(Entry<K,V> p) {  
        modCount++;      //修改次数 +1  
        size--;          //元素个数 -1  
  
        /* 
         * 被删除节点的左子树和右子树都不为空,那么就用 p节点的中序后继节点代替 p 节点 
         * successor(P)方法为寻找P的替代节点。规则是右分支最左边,或者 左分支最右边的节点 
         * ---------------------(1) 
         */  
        if (p.left != null && p.right != null) {    
            Entry<K,V> s = successor(p);  
            p.key = s.key;  
            p.value = s.value;  
            p = s;  
        }  
  
        //replacement为替代节点,如果P的左子树存在那么就用左子树替代,否则用右子树替代  
        Entry<K,V> replacement = (p.left != null ? p.left : p.right);  
  
        /* 
         * 删除节点,分为上面提到的三种情况 
         * -----------------------(2) 
         */  
        //如果替代节点不为空  
        if (replacement != null) {  
            replacement.parent = p.parent;  
            /* 
             *replacement来替代P节点 
             */  
            //若P没有父节点,则跟节点直接变成replacement  
            if (p.parent == null)  
                root = replacement;  
            //如果P为左节点,则用replacement来替代为左节点  
            else if (p == p.parent.left)  
                p.parent.left  = replacement;  
          //如果P为右节点,则用replacement来替代为右节点  
            else  
                p.parent.right = replacement;  
  
            //同时将P节点从这棵树中剔除掉  
            p.left = p.right = p.parent = null;  
  
            /* 
             * 若P为红色直接删除,红黑树保持平衡 
             * 但是若P为黑色,则需要调整红黑树使其保持平衡 
             */  
            if (p.color == BLACK)  
                fixAfterDeletion(replacement);  
        } else if (p.parent == null) {     //p没有父节点,表示为P根节点,直接删除即可  
            root = null;  
        } else {      //P节点不存在子节点,直接删除即可  
            if (p.color == BLACK)         //如果P节点的颜色为黑色,对红黑树进行调整  
                fixAfterDeletion(p);  
  
            //删除P节点  
            if (p.parent != null) {  
                if (p == p.parent.left)  
                    p.parent.left = null;  
                else if (p == p.parent.right)  
                    p.parent.right = null;  
                p.parent = null;  
            }  
        }  
    }  

TreeMap总结

TreeMap基于红黑树实现,无容量限制
TreeMap是非线程安全的
(参考)

推荐阅读更多精彩内容