TreeMap源码分析总结

25人阅读 评论(0) 收藏 举报
分类:

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;  
        }  
    }  

查看评论

zookeeper源码分析

-
  • 1970年01月01日 08:00

【Java集合源码剖析】TreeMap源码剖析

前言 本文不打算延续前几篇的风格(对所有的源码加入注释),因为要理解透TreeMap的所有源码,对博主来说,确实需要耗费大量的时间和经历,目前看来不大可能有这么多时间的投入,故这里意在通过于...
  • mmc_maodun
  • mmc_maodun
  • 2014-07-07 07:47:49
  • 10776

Java集合之TreeMap源码解析

TreeMap 不可重复元素的可排序键值对 采用红黑树的数据结构,该数据结构是一颗自平衡二叉查找树,每个节点标注了红或黑的颜色。 红黑树的5个性质如下: 1、节点是红色或黑色 2、根节点是...
  • baidu_36506044
  • baidu_36506044
  • 2016-11-10 09:26:35
  • 373

史上最详细的TreeMap详解--源码分析

ps.本文所有源码都是基于jdk1.6
  • yan_wenliang
  • yan_wenliang
  • 2016-04-08 00:21:35
  • 413

TreeMap源码分析(jdk1.8)

TreeMap的基本概念: TreeMap集合是基于红黑树(Red-Black tree)的 NavigableMap实现。该集合最重要的特点就是可排序,该映射根据其键的自然顺序进行排序,或者根据创建...
  • qq_23211905
  • qq_23211905
  • 2017-08-04 19:33:42
  • 236

【Java8源码分析】集合框架-TreeMap

一、红黑树原理TreeMap是基于红黑树实现的。一棵高度为h的二叉搜索树,它可以支持任何一种基本动态集合操作,其时间复杂度均为O(h)。当h较小时,执行会比较快。红黑树是许多“平衡”搜索树中的一种。 ...
  • linxdcn
  • linxdcn
  • 2017-05-21 21:12:02
  • 1020

java源码分析之TreeMap深入篇

TreeMap有Values、EntrySet、KeySet、PrivateEntryIterator、EntryIterator、ValueIterator、KeyIterator、Descendi...
  • jzhf2012
  • jzhf2012
  • 2013-01-25 09:59:16
  • 5581

java集合(6):TreeMap源码分析(jdk1.8)

前言TreeMap的基本概念: TreeMap集合是基于红黑树(Red-Black tree)的 NavigableMap实现。该映射根据其键的自然顺序进行排序,或者根据创建映射时提供的 Compar...
  • qq_32166627
  • qq_32166627
  • 2017-05-26 20:24:14
  • 1419

【JDK1.8】JDK1.8集合源码阅读——TreeMap(一)

目录 一、前言 二、TreeMap的继承关系 三、SortedMap接口源码解析 3.1 SortedMap接口 3.2 Comparable接口 3.3 Comparator接口 四、...
  • qq3401247010
  • qq3401247010
  • 2017-11-22 19:47:58
  • 296

【源码】TreeMap源码剖析

注:以下源码基于jdk1.7.0_11 之前介绍了一系列Map集合中的具体实现类,包括HashMap,HashTable,LinkedHashMap。这三个类都是基于哈希表实现的,今天我们介...
  • RowandJJ
  • RowandJJ
  • 2014-08-23 22:08:00
  • 1937
    个人资料
    持之以恒
    等级:
    访问量: 1553
    积分: 477
    排名: 10万+
    文章分类
    文章存档
    最新评论