JDK集合 TreeMap

阿新 • • 發佈：2018-07-21

wikipedia 個數檢查如何實現 pre cnblogs inpu tar ddl

TreeMap是JDK中一種排序的數據結構。在這一篇裏，我們將分析TreeMap的數據結構，深入理解它的排序能力是如何實現的。這一節要有一定的數據結構基礎，在閱讀下面的之前，推薦大家先看一下：《算法4》深入理解紅黑樹。（這裏介紹的紅黑樹實現：從2-3樹到紅黑樹的過渡很清晰，雖然源碼裏的實現不是這種方式 T^T），先了解一下紅黑樹的由來以及它的特性，這樣能更好的理解TreeMap的實現。

TreeMap的結構

TreeMap的內部實現就是一個紅黑樹。

技術分享圖片

對於紅黑樹的定義：

節點是紅色或黑色。
根是黑色。
所有葉子都是黑色（葉子是NIL節點）。
每個紅色節點必須有兩個黑色的子節點。（從每個葉子到根的所有路徑上不能有兩個連續的紅色節點。）

從任一節點到其每個葉子的所有簡單路徑都包含相同數目的黑色節點。

TreeMap的成員變量

public class TreeMap<K,V> extends AbstractMap<K,V>
    implements NavigableMap<K,V>, Cloneable, java.io.Serializable {
    // Key的比較器，用作排序
    private final Comparator<? super K> comparator;
    // 樹的根節點
    private transient Entry<K,V> root;
     
// 樹的大小
    private transient int size = 0;
    // 修改計數器
    private transient int modCount = 0;
    // 返回map的Entry視圖
    private transient EntrySet entrySet;
    private transient KeySet<K> navigableKeySet;
    private transient NavigableMap<K,V> descendingMap;
    // 定義紅黑樹的顏色
    private static final 
 boolean RED   = false;
    private static final boolean BLACK = true;
   
}

TreeMap的構造方法

public TreeMap(Comparator<? super K> comparator) {
   this.comparator = comparator;
}

允許用戶自定義比較器進行key的排序。

public TreeMap(Map<? extends K, ? extends V> m) {
  comparator = null;
  putAll(m);
}
 
public void putAll(Map<? extends K, ? extends V> map) {
  int mapSize = map.size();
  //判斷map是否SortedMap，不是則采用AbstractMap的putAll
  if (size==0 && mapSize!=0 && map instanceof SortedMap) {
    Comparator<?> c = ((SortedMap<?,?>)map).comparator();
    //同為null或者不為null，類型相同，則進入有序map的構造
    if (c == comparator || (c != null && c.equals(comparator))) {
      ++modCount;
      try {
        buildFromSorted(mapSize, map.entrySet().iterator(),
                        null, null);
      } catch (java.io.IOException cannotHappen) {
      } catch (ClassNotFoundException cannotHappen) {
      }
      return;
    }
  }
  super.putAll(map);
}

buildFromSorted將在後面解析，因為後面的構造函數也調用了這個方法。

public TreeMap(SortedMap<K, ? extends V> m) {
  comparator = m.comparator();
  try {
    buildFromSorted(m.size(), m.entrySet().iterator(), null, null);
  } catch (java.io.IOException cannotHappen) {
  } catch (ClassNotFoundException cannotHappen) {
  }
}

下面讓我們來看一下這個buildFromSorted方法：

/**
* size: map裏鍵值對的數量
* it: 傳入的map的entries叠代器
* str: 如果不為空，則從流裏讀取key-value
* defaultVal：見名知意，不為空，則value都用這個值
*/
private void buildFromSorted(int size, Iterator<?> it,
                                 java.io.ObjectInputStream str,
                                 V defaultVal)
  throws  java.io.IOException, ClassNotFoundException {
  this.size = size;
  root = buildFromSorted(0, 0, size-1, computeRedLevel(size),
                         it, str, defaultVal);
}

我們先來分析一下computeRedLevel方法：

private static int computeRedLevel(int sz) {
  int level = 0;
  for (int m = sz - 1; m >= 0; m = m / 2 - 1)
    level++;
  return level;
}

它的作用是用來計算完全二叉樹的層數。什麽意思呢，先來看一下下面的圖：

技術分享圖片

把根結點索引看為0，那麽高度為2的樹的最後一個節點的索引為2，類推高度為3的最後一個節點為6，滿足 m = (m + 1) * 2 。那麽計算這個高度有什麽好處呢，如上圖，如果一個樹有9個節點，那麽我們構造紅黑樹的時候，只要把前面3層的結點都設置為黑色，第四層的節點設置為紅色，則構造完的樹，就是紅黑樹，滿足前面提到的紅黑樹的5個條件。而實現的關鍵就是找到要構造樹的完全二叉樹的層數。

了解了上面的原理，後面就簡單了，接著來看buildFromSorted方法：

/**
* level: 當前樹的層數，註意：是從0層開始
* lo: 子樹第一個元素的索引
* hi: 子樹最後一個元素的索引
* redLevel: 上述紅節點所在層數
* 剩下的3個就不解釋了，跟上面的一樣
*/
@SuppressWarnings("unchecked")
private final Entry<K,V> buildFromSorted(int level, int lo, int hi,
                                         int redLevel,
                                         Iterator<?> it,
                                         java.io.ObjectInputStream str,
                                         V defaultVal)
  throws  java.io.IOException, ClassNotFoundException {
  // hi >= lo 說明子樹已經構造完成
  if (hi < lo) return null;
  // 取中間位置，無符號右移，相當於除2
  int mid = (lo + hi) >>> 1;
  Entry<K,V> left  = null;
  //遞歸構造左結點
  if (lo < mid)
    left = buildFromSorted(level+1, lo, mid - 1, redLevel,
                           it, str, defaultVal);
  K key;
  V value;
  // 通過叠代器獲取key， value
  if (it != null) {
    if (defaultVal==null) {
      Map.Entry<?,?> entry = (Map.Entry<?,?>)it.next();
      key = (K)entry.getKey();
      value = (V)entry.getValue();
    } else {
      key = (K)it.next();
      value = defaultVal;
    }
  // 通過流來讀取key, value
  } else {
    key = (K) str.readObject();
    value = (defaultVal != null ? defaultVal : (V) str.readObject());
  }
  //構建結點
  Entry<K,V> middle =  new Entry<>(key, value, null);
  // level從0開始的，所以上述9個節點，計算出來的是3，實際上就是代表的第4層
  if (level == redLevel)
    middle.color = RED;
  //如果存在的話，設置左結點，
  if (left != null) {
    middle.left = left;
    left.parent = middle;
  }
  // 遞歸構造右結點
  if (mid < hi) {
    Entry<K,V> right = buildFromSorted(level+1, mid+1, hi, redLevel,
                                       it, str, defaultVal);
    middle.right = right;
    right.parent = middle;
  }
  return middle;
}

另外提一句，buildFromSorted能這麽構造是因為這是一個已經排序的map。
具體的構造順序如下圖（偷懶畫了個簡單的）:

技術分享圖片

若感興趣可以自己分析一下上面9個節點的是如何構造的。

TreeMap的重要方法

get(Object key)

對於map來說，根據key來獲取value幾乎是最常見的操作，下面我們來看一下：

public V get(Object key) {
  //內部調用了getEntry方法。
  Entry<K,V> p = getEntry(key);
  return (p==null ? null : p.value);
}
 
final Entry<K,V> getEntry(Object key) {
  // 如果有比較器，則調用通過比較器的來比較key的方法
  if (comparator != null)
    return getEntryUsingComparator(key);
  if (key == null)
    throw new NullPointerException();
  @SuppressWarnings("unchecked")
  // 獲取key的Comparable接口
  Comparable<? super K> k = (Comparable<? super K>) key;
  //從根結點開始比較，根據二叉樹的形式，小的往左樹找，大的往右樹找，直到找到返回
  Entry<K,V> p = root;
  while (p != null) {
    int cmp = k.compareTo(p.key);
    if (cmp < 0)
      p = p.left;
    else if (cmp > 0)
      p = p.right;
    else
      return p;
  }
  return null;
}

對於 Comparable<? super K> k = (Comparable<? super K>) key; ，筆者一開始的時候在想為什麽用<? super K>，用<? extends K>不行嗎，不是根據PECS（Producer Extends, Consumer Super）原則，取出來的時候用extends嗎。後來發現太傻了 T^T，這一原則是用來針對list的。這裏肯定是用super，用K或者K的父類的compareTo方法。如果用extends的話，K的子類加了其他屬性進行比較，那就根本沒法進行比較了。

至於getEntryUsingComparator方法就不分析了，就是把compareTo變成了用Comparator進行比較，感興趣可以自己看看。

put(K key, V value)

public V put(K key, V value) {
  Entry<K,V> t = root;
  //根結點為空，則進行添加根結點並初始化參數
  if (t == null) {
    //用來進行類型檢查
    compare(key, key);
    root = new Entry<>(key, value, null);
    size = 1;
    modCount++;
    return null;
  }
  int cmp;
  Entry<K,V> parent;
  // 與get類型，分離comparator與comparable的比較
  Comparator<? super K> cpr = comparator;
  if (cpr != null) {
    //循環查找key，如果找到則替換value，沒有則記錄其parent，後面進行插入
    do {
      parent = t;
      cmp = cpr.compare(key, t.key);
      if (cmp < 0)
        t = t.left;
      else if (cmp > 0)
        t = t.right;
      else
        return t.setValue(value);
    } while (t != null);
  }
  else {
    if (key == null)
      throw new NullPointerException();
    @SuppressWarnings("unchecked")
    Comparable<? super K> k = (Comparable<? super K>) key;
    //循環查找key，如果找到則替換value，沒有則記錄其parent，後面進行插入
    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);
  if (cmp < 0)
    parent.left = e;
  else
    parent.right = e;
  //對紅黑樹進行修復
  fixAfterInsertion(e);
  size++;
  modCount++;
  return null;
}

put的邏輯還是比較清晰的，關鍵在於fixAfterInsertion對插入結點後的紅黑樹進行修復，維護其平衡，我們接著來看看它是如何實現的（在繼續看之前，建議先去了解一下左旋轉和右旋轉的操作）。

private void fixAfterInsertion(Entry<K,V> x) {
  //約定插入的結點都是紅節點
  x.color = RED;
  //x本身紅色，如果其父節點也是紅色，違反規則4，進行循環處理
  while (x != null && x != root && x.parent.color == RED) {
    //父節點是左結點
    if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {
      //獲取父節點的右兄弟y
      Entry<K,V> y = rightOf(parentOf(parentOf(x)));
      //p為左結點，y為紅色 ①
      if (colorOf(y) == RED) {
        setColor(parentOf(x), BLACK);
        setColor(y, BLACK);
        setColor(parentOf(parentOf(x)), RED);
        x = parentOf(parentOf(x));
      } else {
        // p為左結點，y為黑，x為右節點 ②
        if (x == rightOf(parentOf(x))) {
          x = parentOf(x);
          rotateLeft(x);
        }
        // p為左結點，y為紅，x為左結點 ③
        setColor(parentOf(x), BLACK);
        setColor(parentOf(parentOf(x)), RED);
        rotateRight(parentOf(parentOf(x)));
      }
    //父節點是右結點  
    } else {
      Entry<K,V> y = leftOf(parentOf(parentOf(x)));
      //p為右結點，y為紅色 ④
      if (colorOf(y) == RED) {
        setColor(parentOf(x), BLACK);
        setColor(y, BLACK);
        setColor(parentOf(parentOf(x)), RED);
        x = parentOf(parentOf(x));
      } else {
        //p為右結點，y為黑色，x為左結點 ⑤
        if (x == leftOf(parentOf(x))) {
          x = parentOf(x);
          rotateRight(x);
        }
        //p為右結點，y為黑色，x為右結點 ⑥
        setColor(parentOf(x), BLACK);
        setColor(parentOf(parentOf(x)), RED);
        rotateLeft(parentOf(parentOf(x)));
      }
    }
  }
  //約定根結點都是黑節點
  root.color = BLACK;
}

總結一下有這麽幾種情況：

由於p為紅，則x沒有兄弟結點（原則4），要想插入後維持紅黑樹平衡，必須從p，pp以及p的兄弟結點y中找到對應的處理情況來平衡；
首先，插入的結點x，顏色肯定是紅色，插入位置兩種情況——左結點或者右結點；
其次，父結點p肯定為紅色，因為父節點p為黑色的話，那就不用調整了（插入紅節點對原則五並沒有印象），所以只有父結點p是左結點和右結點的兩種情況；
既然父結點p為紅色，那麽父父結點pp肯定為黑色（根據原則四），那麽p的兄弟節點y，存在兩種情況，顏色為紅或者黑。

所以綜上，x插入要調整的所有情況有：2 * 2 * 2 = 8種，但是當y為紅色的時候不用調整，不需要考慮x的插入位置，所以8 - 2 = 6種，且只要懂三種就夠了，剩余的是左右對稱的。至於為什麽要這麽處理這裏就不展開了。感興趣的園友們可以推薦這篇看一下：紅黑樹的插入操作

至於左旋轉和右旋轉就不拿出來分析了。

remove(Object key)

最後我們再來看一下remove方法：

public V remove(Object key) {
  //獲取Entry
  Entry<K,V> p = getEntry(key);
  if (p == null)
    return null;
  V oldValue = p.value;
  //刪除的關鍵方法
  deleteEntry(p);
  return oldValue;
}

在看deleteEntry之前，我們先來看一下successor方法，為其做準備：

//查找t的後繼結點
static <K,V> TreeMap.Entry<K,V> successor(Entry<K,V> t) {
  if (t == null)
    return null;
  //從t的右子樹中找到最小的
  else if (t.right != null) {
    Entry<K,V> p = t.right;
    while (p.left != null)
      p = p.left;
    return p;
  //當右子樹為空時，向上找到第一個左父節點
  } else {
    Entry<K,V> p = t.parent;
    Entry<K,V> ch = t;
    while (p != null && ch == p.right) {
      ch = p;
      p = p.parent;
    }
    return p;
  }
}

上述的目的是找到最接近且大於t的結點，這樣的話，直接用來替換掉t，對原有的樹結構變動最小。

private void deleteEntry(Entry<K,V> p) {
  modCount++;
  size--;
  //① p的左右子樹都不為空，找到右子樹中最小的結點，將key、value賦給p，然後p指向後繼結點
  if (p.left != null && p.right != null) {
    Entry<K,V> s = successor(p);
    p.key = s.key;
    p.value = s.value;
    p = s;
  } 
  //獲取p中不為空的結點，也可能兩個都是空的
  Entry<K,V> replacement = (p.left != null ? p.left : p.right);
  //① 替換的結點有一個子節點
  if (replacement != null) {
    replacement.parent = p.parent;
    if (p.parent == null)
      root = replacement;
    else if (p == p.parent.left)
      p.parent.left  = replacement;
    else
      p.parent.right = replacement;
    //清空鏈接，以便可以使用fixAfterDeletion和內存回收
    p.left = p.right = p.parent = null;
    if (p.color == BLACK)
      fixAfterDeletion(replacement);
  // ② 刪除的結點是根結點
  } else if (p.parent == null) { 
    root = null;
  // ③ 替換的結點是空節點
  } else {
    if (p.color == BLACK)
      fixAfterDeletion(p);
    if (p.parent != null) {
      if (p == p.parent.left)
        //清空鏈接，方便GC
        p.parent.left = null;
      else if (p == p.parent.right)
        p.parent.right = null;
      //清空鏈接，方便GC
      p.parent = null;
    }
  }
}

整體思路是：

當刪除結點p的左右結點都不為空的時候，選擇大於且最接近p的後繼結點s，直接將s的key、value替換掉p的原有值，然後對後繼結點s做刪除處理。此時的s必有一個左必為空，做操作2；
對於有左右結點有一個為空的p時，在不為空的結點replacement，與p的parent之間修改父子節點間引用關系；
兩個結點都是空的就更簡單了，直接刪掉；
對於刪除的黑色的結點進行fix。

在獲取replacement的時候，p的左右結點為空的個數>=1，

沒有進前面if條件，則說明p至少有一個為空；
進入if條件，則在p的右樹中找最小節點s，s左結點必為空，右結點可能存在。

下面讓我們來看一下fixAfterDeletion的源碼的源碼：

private void fixAfterDeletion(Entry<K,V> x) {
  while (x != root && colorOf(x) == BLACK) {
    //x是左結點且為黑色
    if (x == leftOf(parentOf(x))) {
      //獲取兄弟右節點
      Entry<K,V> sib = rightOf(parentOf(x));
      //① 兄弟右節點sib顏色是紅色
      if (colorOf(sib) == RED) {
        setColor(sib, BLACK);
        setColor(parentOf(x), RED);
        rotateLeft(parentOf(x));
        sib = rightOf(parentOf(x));
      }
      //② sib的子節點都是黑色
      if (colorOf(leftOf(sib))  == BLACK &&
          colorOf(rightOf(sib)) == BLACK) {
        setColor(sib, RED);
        x = parentOf(x);
      //sib子節點不全為黑
      } else {
        //③ sib右子節點為黑色
        if (colorOf(rightOf(sib)) == BLACK) {
          setColor(leftOf(sib), BLACK);
          setColor(sib, RED);
          rotateRight(sib);
          sib = rightOf(parentOf(x));
        }
        // ④
        setColor(sib, colorOf(parentOf(x)));
        setColor(parentOf(x), BLACK);
        setColor(rightOf(sib), BLACK);
        rotateLeft(parentOf(x));
        x = root;
      }
    // 對稱
    } else {
      Entry<K,V> sib = leftOf(parentOf(x));
 
      if (colorOf(sib) == RED) {
        setColor(sib, BLACK);
        setColor(parentOf(x), RED);
        rotateRight(parentOf(x));
        sib = leftOf(parentOf(x));
      }
 
      if (colorOf(rightOf(sib)) == BLACK &&
          colorOf(leftOf(sib)) == BLACK) {
        setColor(sib, RED);
        x = parentOf(x);
      } else {
        if (colorOf(leftOf(sib)) == BLACK) {
          setColor(rightOf(sib), BLACK);
          setColor(sib, RED);
          rotateLeft(sib);
          sib = leftOf(parentOf(x));
        }
        setColor(sib, colorOf(parentOf(x)));
        setColor(parentOf(x), BLACK);
        setColor(leftOf(sib), BLACK);
        rotateRight(parentOf(x));
        x = root;
      }
    }
  }
  setColor(x, BLACK);
}

fixAfterDeletion總體思路是：由於刪除的結點x是黑色，所以在該結點的樹上做調整沒法使紅黑樹恢復平衡，所以要依靠x的兄弟結點sib做文章，依靠p結點以及sib和其子結點，將x的黑色結點+1，這裏具體就不展開了。感興趣可以推薦這篇看一下：紅黑樹的刪除操作

參考：紅黑樹

轉載：【JDK1.8】JDK1.8集合源碼閱讀——TreeMap（二）

JDK集合 TreeMap

wikipedia 個數檢查如何實現 pre cnblogs inpu tar ddl TreeMap是JDK中一種排序的數據結構。在這一篇裏，我們將分析TreeMap的數據結構，深入理解它的排序能力是如何實現的。這一節要有一定的數據結構基礎，在閱讀下面的之前，推薦大家

JDK集合 TreeMap

TreeMap的結構

TreeMap的成員變量

TreeMap的構造方法

TreeMap的重要方法

get(Object key)

put(K key, V value)

remove(Object key)

JDK集合 TreeMap

JDK集合框架

JDK集合原始碼分析（一）ArrayList

【小家java】Java中Apache Commons-Collections4使用精講（對JDK集合功能的強有力擴充套件）

[jjzhu學java]之JDK集合框架原始碼分析

JDK集合類原始碼分析

Java集合-TreeMap原始碼

java集合 TreeMap 使用自然排序和定製排序

JDK集合面試20問

jdk源碼閱讀筆記之java集合框架（四）（LinkedList）

java：容器/集合（Map（HashMap，TreeMap））

Java集合Set、Map、HashSet、HashMap、TreeSet、TreeMap等

JAVA基礎學習-集合三-Map、HashMap,TreeMap與常用API

Java集合框架（五）—— Map、HashMap、Hashtable、Properties、SortedMap、TreeMap、WeakHashMap、IdentityHashMap、EnumMap

扒一扒系列之開發中常用的Java集合類(ArrayList篇 jdk 1.7)

jdk TreeMap工作原理分析

Java中的集合Map、HashMap、Hashtable、Properties、SortedMap、TreeMap、WeakHashMap、IdentityHashMap、EnumMap(五)

Java基礎 - Map接口的實現類 : HashedMap / LinkedHashMap /TreeMap 的構造/修改/遍歷/ 集合視圖方法/雙向叠代輸出

TreeMap集合遍歷學習

30-集合--Map+keySet()/entrySet()獲取元素+Map.Entry+Map子類的特點+Hashtable+Properties+HashMap/TreeMap儲存自定義物件

JDK集合 TreeMap

TreeMap的結構

TreeMap的成員變量

TreeMap的構造方法

TreeMap的重要方法

get(Object key)

put(K key, V value)

remove(Object key)

相關推薦