JAVA集合源码分析系列:TreeMap源码分析

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

TreeMap源码分析

treemap的数据结构基础是红黑树。
可以到如下复习一下红黑树:
http://blog.csdn.net/a910626/article/details/54378874

节点

    static final class Entry<K,V> implements Map.Entry<K,V> {
        // 键
        K key;
        // 值
        V value;
        // 左孩子
        Entry<K,V> left;
        // 右孩子
        Entry<K,V> right;
        // 父节点
        Entry<K,V> parent;
        // 红黑树的节点表示颜色的属性
        boolean color = BLACK;

        /**
         * Make a new cell with given key, value, and parent, and with
         * {@code null} child links, and BLACK color.
         */
         // 根据给定的键、值、父节点构造一个节点,颜色是默认的黑色
        Entry(K key, V value, Entry<K,V> parent) {
            this.key = key;
            this.value = value;
            this.parent = parent;
        }

        /**
         * Returns the key.
         *
         * @return the key
         */
         // 获取节点的key
        public K getKey() {
            return key;
        }

        /**
         * Returns the value associated with the key.
         *
         * @return the value associated with the key
         */
         // 获取节点的value
        public V getValue() {
            return value;
        }

        /**
         * Replaces the value currently associated with the key with the given
         * value.
         *
         * @return the value associated with the key before this method was
         *         called
         */
         // 修改并返回当前节点的value(返回的是旧的value)
        public V setValue(V value) {
            V oldValue = this.value;
            this.value = value;
            return oldValue;
        }
        // 判断节点相等的方法(两个节点为同一类型且key值和value值都相等时两个节点相等)
        public boolean equals(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry<?,?> e = (Map.Entry<?,?>)o;

            return valEquals(key,e.getKey()) && valEquals(value,e.getValue());
        }

        // 节点的哈希值计算方法
        public int hashCode() {
            int keyHash = (key==null ? 0 : key.hashCode());
            int valueHash = (value==null ? 0 : value.hashCode());
            return keyHash ^ valueHash;
        }

        public String toString() {
            return key + "=" + value;
        }
    }

Entry类比较简单,实现了树节点的必要内容,提供了hashCode方法等。

TreeMap的父类和实现的接口

public class TreeMap<K,V>
    extends AbstractMap<K,V>
    implements NavigableMap<K,V>, Cloneable, java.io.Serializable

TreeMap继承自AbstractMap,AbstractMap实现了Map接口。
TreeMap实现了NavigableMap接口?

TreeMap实现了Cloneable接口

TreeMap实现了Serializable接口

构造函数

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

就不说了

属性

    /**
     * The comparator used to maintain order in this tree map, or
     * null if it uses the natural ordering of its keys.
     *
     * @serial
     */
     // 用于保持顺序的比较器,如果为空的话使用自然顺序保持key的顺序
    private final Comparator<? super K> comparator;
    // 根节点
    private transient Entry<K,V> root;

    /**
     * The number of entries in the tree
     */
     // 树中节点数量
    private transient int size = 0;

    /**
     * The number of structural modifications to the tree.
     */
     // ???
    private transient int modCount = 0;

行为

下面从put/get方法开始,逐个分析TreeMap的方法。

put方法

    public V put(K key, V value) {
        Entry<K,V> t = root;
        if (t == null) {
            compare(key, key); // type (and possibly null) check
            // 如果根节点为null,将传入的键值对构造成根节点(根节点没有父节点,所以传入的父节点为null)
            root = new Entry<>(key, value, null);
            size = 1;
            modCount++;
            return null;
        }
        // 记录比较结果
        int cmp;
        Entry<K,V> parent;
        // split comparator and comparable paths
        // 分割比较器和可比较接口的处理
        Comparator<? super K> cpr = comparator;
        // 有比较器的处理
        if (cpr != null) {
            do {
                // 记录新节点的父节点
                parent = t;
                // 使用比较器比较父节点和插入键值对的key值的大小
                cmp = cpr.compare(key, t.key);
                // 插入的key较大
                if (cmp < 0)
                    t = t.left;
                // 插入的key较小
                else if (cmp > 0)
                    t = t.right;
                // key值相等,替换并返回t节点的value(put方法结束)
                else
                    return t.setValue(value);
            } while (t != null);
        }
        // 没有比较器
        else {
            // key为null,抛出空指针异常
            if (key == null)
                throw new NullPointerException();
            @SuppressWarnings("unchecked")
                Comparable<? super K> k = (Comparable<? super K>) key;
            // 与if里面的do while类似,只是比较的方式不同
            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);
        }
        // 没有找到key相同的节点才会有下面的操作
        // 根据传入的键值对和找到的父节点创建新节点
        Entry<K,V> e = new Entry<>(key, value, parent);
        // 根据最后一次的判断结果确认新节点是父节点的左孩子还是右孩子
        if (cmp < 0)
            parent.left = e;
        else
        // 对加入新节点的树进行调整
            parent.right = e;
        fixAfterInsertion(e);
        // 记录size和modcount
        size++;
        modCount++;
        // 因为是插入新节点,所以返回的是null
        return null;
    }

首先一点通性是TreeMap的put方法和其他Map的put方法一样,向Map中加入键值对,若原先“键(key)”已经存在则替换“值(value)”,并返回原先的值。

在put(K key,V value)方法的末尾调用了fixAfterInsertion(Entry

get方法

public V get(Object key) {
        Entry<K,V> p = getEntry(key);
        return (p==null ? null : p.value);
    }

get(Object key)通过key获取对应的value,它通过调用getEntry(Object key)获取节点,若节点为null则返回null,否则返回节点的value值。下面是getEntry(Object key)的内容,来看它是怎么寻找节点的。

    final Entry<K,V> getEntry(Object key) {
        // Offload comparator-based version for sake of performance
        // 如果有比较器,返回getEntryUsingComparator的结果
        if (comparator != null)
            return getEntryUsingComparator(key);
        // 查找的key为null,抛出空指针
        if (key == null)
            throw new NullPointerException();
        @SuppressWarnings("unchecked")
            Comparable<? super K> k = (Comparable<? super K>) key;
        // 获取根节点
        Entry<K,V> p = root;
        // 对树进行遍历查找节点
        while (p != null) {
        // 把key和当前节点的key进行比较
            int cmp = k.compareTo(p.key);
            // key小于当前节点的key
            if (cmp < 0)
            // p移动到左节点上
                p = p.left;
                // key小于当前节点的key
            else if (cmp > 0)
            // p移动到右节点上
                p = p.right;
                // key值相等则当前节点就是要找的节点
            else
                return p;
        }
        return null;
    }

上面主要是处理实现了可比较接口的情况,而有比较器的情况在getEntryUsingComparator(Object key)中处理了,下面来看处理的代码。

final Entry<K,V> getEntryUsingComparator(Object key) {
    K k = (K) key;
    // 获取比较器
Comparator<? super K> cpr = comparator;
// 其实在调用此方法的get(Object key)中已经对比较器为null的情况进行判断,这里是防御性的判断
if (cpr != null) {
    // 获取根节点
        Entry<K,V> p = root;
        // 遍历树
        while (p != null) {
            // 获取key和当前节点的key的比较结果
            int cmp = cpr.compare(k, p.key);
            // 查找的key值较小
            if (cmp < 0)
                // p“移动”到左孩子
                p = p.left;
            // 查找的key值较大
            else if (cmp > 0)
                // p“移动”到右节点
                p = p.right;
            // key值相等
            else
                // 返回找到的节点
                return p;
        }
}
// 没找到key值对应的节点,返回null
    return null;
}

更多方法就不再深入啦

应用场景

我们知道treemap的底层数据结构是红黑树,红黑树的优点是什么:插入、查找、删除效率综合来说都比二叉排序树、平衡二叉树要好一些。

与HashMap相比,TreeMap的key是有序的。

参考资料

http://www.importnew.com/16679.html
http://www.cnblogs.com/hzmark/archive/2013/01/02/TreeMap-Base.html
http://blog.csdn.net/hustyangju/article/details/27214251
https://www.nowcoder.com/questionTerminal/16ff3fe9d0e748ffb37212fdc280bef9

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    写给自己
    ○ 种一棵树最好的时间是十年前,其次是现在

    ○ 坚持输出,坚持书写,才可以持续成长

    ○ 所有美好事物的成长都是缓慢的

    ○ 既往不恋,未来不迎,当下不杂

    ○ 业精于勤,荒于嬉,行成于思,毁于随

    ○将军赶路 不追小兔

    ○不要拘泥于语言,同样也不要拘泥于行业,眼光放远一点

    ○ 如果某件事你做的不够好,不必介怀,因为以后的每一次每一天你都会做得越来越好

    ○ 此心不于事上磨,更于何处磨此心

    ○ 保持热情,保持求知欲

    ○ 千里之行,始于足下

    ○ 最怕你一生碌碌无为,还安慰自己平凡可贵。

    ○ 对于任何事,要保持自觉积极主动探索尝试。但是如果自己不积极认真地生活,不管得到什么样的回答都没有用。——解忧杂货店
    个人资料
    • 访问:606876次
    • 积分:8403
    • 等级:
    • 排名:第2521名
    • 原创:354篇
    • 转载:61篇
    • 译文:0篇
    • 评论:140条
    个人简介