TreeMap源码分析总结

1，概述

     我们大学里学习的数据结构中的二叉树知识应用到了TreeMap中，回忆下TreeMap包含几个重要的成员变量： root,    size, comparator。root 是红黑数的根节点。它是Entry类型，Entry是红黑数的节点，它包含了红    黑数的6个基本组成成分：key(键)、value(值)、left(左孩子)、right(右孩子)、parent(父节点)、color(颜     色)。Entry节点根据key进行排序，Entry节点包含的内容为value。 
   reeMap 是一个有序的key-value集合，它是通过红黑树(二叉树)实现的。
   TreeMap 继承于AbstractMap，所以它是一个Map，即一个key-value集合。
   TreeMap 实现了NavigableMap接口，意味着它支持一系列的导航方法。比如返回有序的key集合。
   TreeMap 实现了Cloneable接口，意味着它能被克隆。
   TreeMap 实现了java.io.Serializable接口，意味着它支持序列化。
 案例：
     public static void main(String[] args) {
Map<String,String> treeMap = new TreeMap<String,String>();
treeMap.put("93", "化学");
treeMap.put("98", "数学");
treeMap.put("92", "生物");
for(Map.Entry<String, String> en :treeMap.entrySet()) {
System.out.println(en.getKey()+":"+en.getValue());
}
}

     排序了，因为分数是String类型，String实现了 Comparable<String>接口

 我们也可以自定义对象实现Comparable<String>接口，可以按照我们自定义对象的属性值大小进行排序
     我们还可以给treeMap传递也给比较器对象(自定义一个类实现Comparator接口)， Comparator实现的比较器提供      可插拔的功能效果。
     案例：public static void main(String[] args) {
Comparator<Object> comparator = new Comparator<Object>() {

@Override
public int compare(Object o1, Object o2) {
if(o1 instanceof TUser && o2 instanceof TUser) {
TUser user1 = (TUser) o1;
TUser user2 = (TUser) o2;
return user1.getAge()-user2.getAge();
}
return 0;
}

};
Map<Object,Object> treeMap = new TreeMap<Object,Object>(comparator);
TUser user1 = new TUser();
user1.setAge(3);
user1.setLoginName("tom");
TUser user2 = new TUser();
user2.setAge(1);
user2.setLoginName("peter");
TUser user3 = new TUser();
user3.setAge(2);
user3.setLoginName("marry");
treeMap.put(user1, user1.getAge());
treeMap.put(user2, user2.getAge());
treeMap.put(user3, user3.getAge());
for(Map.Entry<Object, Object> en :treeMap.entrySet()) {
System.out.println(en.getKey().toString()+":"+en.getValue().toString());
}

}

2，设计原理

 从图中可以看出：
  (1)TreeMap实现继承于AbstractMap，并且实现了NavigableMap接口。
  (2)TreeMap的本质是R-B Tree(红黑树)，它包含几个重要的成员变量： root, size, comparator。
　　 root 是红黑数的根节点。它是Entry类型，Entry是红黑数的节点，它包含了红黑数的6个基本组成成分：key      (键)、value(值)、left(左孩子)、right(右孩子)、parent(父节点)、color(颜色)。Entry节点根据key进行      排序，Entry节点包含的内容为value。 
　　 红黑数排序时，根据Entry中的key进行排序；Entry中的key比较大小是根据比较器comparator来进行判断        的。
　　 size是红黑数中节点的个数。

3，源码分析

    TreeMap提供了操作“key”、“key-value”、“value”等方法，也提供了对TreeMap这颗树进行整体操作的方法，如       获取子树、反向树。


    3.1 构造方法：
      public TreeMap() {  //使用节点自身的比较器(实现comparable接口)
        comparator = null;
      }
      public TreeMap(Comparator<? super K> comparator) {  //使用自定义的比较器(实现comparator接口)
        this.comparator = comparator;
      }
      //将map中的键值放到红黑树中存储，由于map中的键是乱序的，故放入到红黑树后需要重新调整树使其平衡
      public TreeMap(Map<? extends K, ? extends V> m) {
        comparator = null;
        putAll(m);
      }
      //直接将SortedMap中的键值放到红黑树中存储，不用调整树，因为SortedMap已经对键进行了排序
      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) {
        }
      }


    //如果把comparator比较器传到TreeMap中，那么就用这个比较器比较元素，如果没有传进来，则用元素自己       实现的          comparable接口中的方法compareTo来比较。
    final int compare(Object k1, Object k2) {
        return comparator==null ? ((Comparable<? super K>)k1).compareTo((K)k2)
            : comparator.compare((K)k1, (K)k2);
    }


    3.2 TreeMap添加节点方法


        public V put(K key, V value) {
        Entry<K,V> t = root; //root节点用于存放当前节点
        if (t == null) {
            compare(key, key); //这步没啥意义，感觉
            root = new Entry<>(key, value, null);//将待添加的节点作为当前节点
            size = 1;//此时的节点个数为1
            modCount++;//记录修改次数
            return null;
        }
        int cmp;//存放当前节点的key和待添加节点的key调用比较器的比较方法返回的结果的变量
        Entry<K,V> parent;
        // split comparator and comparable paths
        Comparator<? super K> cpr = comparator;
        if (cpr != null) {  //如果传进来自定义的比较器
            do {
                parent = t;
                cmp = cpr.compare(key, t.key);
                if (cmp < 0) //左子树遍历
                    t = t.left; //获取当前节点的左孩子节点
                else if (cmp > 0)//右子树遍历
                    t = t.right;//获取当前节点的右孩子节点
                else  //如果key值相同，就用当前的value替换原来的value
                    return t.setValue(value); 
            } while (t != null);
        }
        else { //使用节点自身的比较器
            if (key == null) //TreeMap中的key不能为null
                throw new NullPointerException();
            @SuppressWarnings("unchecked")
            //如果节点的key实现了comparable接口，那么该节点本身就是一个比较器
            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);
        }
        //实例化新的节点对象
        Entry<K,V> e = new Entry<>(key, value, parent);
        if (cmp < 0) //新节点是当前节点的左孩子
            parent.left = e;
        else /新节点是当前节点的右孩子
            parent.right = e;
        fixAfterInsertion(e); //调整红黑树结构使其成为平衡树
        size++; //节点个数加1
        modCount++;修改次数加1
        return null;
       }


     3.3 这样做了其实还没有完成，因为我知道TreeMap的底层实现是红黑树，红黑树是一棵平衡排序二叉树，普通的          排序二叉树可能会出现失衡的情况，所以下一步就是要进行调整。fixAfterInsertion(e); 调整的过程务必          会涉及到红黑树的左旋、右旋、着色三个基本操作。代码如下：调整红黑树结构使其成为平衡树方法：通过          左旋、右旋、着色的方式把当前红黑树调整成一颗平衡排序二叉树。


      /** 
        * 新增节点后的修复操作 
        * x 表示新增节点 
        */  
        private void fixAfterInsertion(Entry<K,V> x) {   
        x.color = RED;    //新增节点的颜色为红色  
        //循环 直到 x不是根节点，且x的父节点不为红色  
        while (x != null && x != root && x.parent.color == RED) {  
             //如果X的父节点（P）是其父节点的父节点（G）的左节点  
             if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {  
             //获取X的叔节点(U)  
             Entry<K,V> y = rightOf(parentOf(parentOf(x)));  
             //如果X的叔节点（U） 为红色（情况三）  
             if (colorOf(y) == RED) {       
                   //将X的父节点（P）设置为黑色  
                   setColor(parentOf(x), BLACK);  
                   //将X的叔节点（U）设置为黑色  
                   setColor(y, BLACK);  
                   //将X的父节点的父节点（G）设置红色  
                   setColor(parentOf(parentOf(x)), RED);  
                   x = parentOf(parentOf(x));  
              }  
              //如果X的叔节点（U为黑色）；这里会存在两种情况（情况四、情况五）  
              else {     
                   //如果X节点为其父节点（P）的右子树，则进行左旋转（情况四）  
                   if (x == rightOf(parentOf(x))) {  
                        //将X的父节点作为X  
                        x = parentOf(x);  
                        //右旋转  
                        rotateLeft(x);  
                    }  
                    //（情况五）  
                    //将X的父节点（P）设置为黑色  
                    setColor(parentOf(x), BLACK);  
                    //将X的父节点的父节点（G）设置红色  
                    setColor(parentOf(parentOf(x)), RED);  
                    //以X的父节点的父节点（G）为中心右旋转  
                    rotateRight(parentOf(parentOf(x)));  
               }  
            }  
            //如果X的父节点（P）是其父节点的父节点（G）的右节点  
            else {  
                 //获取X的叔节点（U）  
                 Entry<K,V> y = leftOf(parentOf(parentOf(x)));  
                 //如果X的叔节点（U） 为红色（情况三）  
                 if (colorOf(y) == RED) {  
                      //将X的父节点（P）设置为黑色  
                      setColor(parentOf(x), BLACK);  
                      //将X的叔节点（U）设置为黑色  
                      setColor(y, BLACK);  
                      //将X的父节点的父节点（G）设置红色  
                      setColor(parentOf(parentOf(x)), RED);  
                      x = parentOf(parentOf(x));  
                  }  
                  //如果X的叔节点（U为黑色）；这里会存在两种情况（情况四、情况五）  
                  else {  
                        //如果X节点为其父节点（P）的右子树，则进行左旋转（情况四）  
                        if (x == leftOf(parentOf(x))) {  
                            //将X的父节点作为X  
                            x = parentOf(x);  
                           //右旋转  
                            rotateRight(x);  
                        }  
                        //（情况五）  
                        //将X的父节点（P）设置为黑色  
                        setColor(parentOf(x), BLACK);  
                        //将X的父节点的父节点（G）设置红色  
                        setColor(parentOf(parentOf(x)), RED);  
                        //以X的父节点的父节点（G）为中心右旋转  
                        rotateLeft(parentOf(parentOf(x)));  
                    }  
                }  
            }  
            //将根节点G强制设置为黑色  
            root.color = BLACK;  
        }  




       左旋：rotateLeft()所谓左旋转，就是将新增节点（N）当做其父节点（P），将其父节点P当做新增节点（N）的左    子节点。即：G.left ---> N,N.left ---> P。
        private void rotateLeft(Entry<K,V> p) {  
        if (p != null) {  
            //获取P的右子节点，其实这里就相当于新增节点N（情况四而言）  
            Entry<K,V> r = p.right;  
            //将R的左子树设置为P的右子树  
            p.right = r.left;  
            //若R的左子树不为空，则将P设置为R左子树的父亲  
            if (r.left != null)  
                r.left.parent = p;  
            //将P的父亲设置R的父亲  
            r.parent = p.parent;  
            //如果P的父亲为空，则将R设置为跟节点  
            if (p.parent == null)  
                root = r;  
            //如果P为其父节点（G）的左子树，则将R设置为P父节点(G)左子树  
            else if (p.parent.left == p)  
                p.parent.left = r;  
            //否则R设置为P的父节点（G）的右子树  
            else  
                p.parent.right = r;  
            //将P设置为R的左子树  
            r.left = p;  
            //将R设置为P的父节点  
            p.parent = r;  
        }  
    }  


   所谓右旋转即，P.right ---> G、G.parent ---> P。


   private void rotateRight(Entry<K,V> p) {  
        if (p != null) {  
            //将L设置为P的左子树  
            Entry<K,V> l = p.left;  
            //将L的右子树设置为P的左子树  
            p.left = l.right;  
            //若L的右子树不为空，则将P设置L的右子树的父节点  
            if (l.right != null)   
                l.right.parent = p;  
            //将P的父节点设置为L的父节点  
            l.parent = p.parent;  
            //如果P的父节点为空，则将L设置根节点  
            if (p.parent == null)  
                root = l;  
            //若P为其父节点的右子树，则将L设置为P的父节点的右子树  
            else if (p.parent.right == p)  
                p.parent.right = l;  
            //否则将L设置为P的父节点的左子树  
            else   
                p.parent.left = l;  
            //将P设置为L的右子树  
            l.right = p;  
            //将L设置为P的父节点  
            p.parent = l;  
        }  
    }