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

最新推荐文章于 2022-11-22 00:21:11 发布

有心好书

最新推荐文章于 2022-11-22 00:21:11 发布

阅读量884

点赞数

分类专栏： java提高

java提高专栏收录该内容

54 篇文章 1 订阅

订阅专栏

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