【Java入门提高篇】Day30 Java容器类详解(十二)TreeMap详解

时间:2022-12-15 19:06:43

  今天来看看Map家族的另一名大将——TreeMap。前面已经介绍过Map家族的两名大将,分别是HashMap,LinkedHashMap。HashMap可以高效查找和存储元素,LinkedHashMap可以在高效查找的基础上对元素进行有序遍历,那么TreeMap又有什么特点呢?别急别急,看完这篇你就知道了。【Java入门提高篇】Day30 Java容器类详解(十二)TreeMap详解

  本篇主要从以下几个方面对TreeMap进行介绍:

  1、TreeMap的特性以及使用栗子

  2、TreeMap继承结构简介

  3、TreeMap源码分析

  本篇预计食用10分钟,请各位食客合理分配时间。【Java入门提高篇】Day30 Java容器类详解(十二)TreeMap详解

一、TreeMap的特性以及使用栗子

1. 键值不允许重复
2. 默认会对键进行排序,所以键必须实现Comparable接口或者使用外部比较器
3. 查找、移除、添加操作的时间复杂度为log(n)
4. 底层使用的数据结构是红黑树

  没错,又是让你欲仙欲死的红黑树,不过不要慌,跟之前介绍HashMap时的红黑树是一毛一样的,所以这一篇里,不打算再做介绍啦,如果对红黑树的内容有些遗忘了,可以动动小手,往前面翻一翻。【Java入门提高篇】Day30 Java容器类详解(十二)TreeMap详解

  先来看一个TreeMap的使用小栗子。

public class TreeMapTest {

    public static void main(String[] args){
        TreeMap<String, Integer> grades = new TreeMap<>();
        grades.put("Frank", 100);
        grades.put("Alice", 95);
        grades.put("Mary", 90);
        grades.put("Bob", 85);
        grades.put("Jack", 90);
        System.out.println(grades);
        System.out.println(grades.subMap("Bob", "Jack"));
        System.out.println(grades.subMap("Bob", true, "Jack", true));
        System.out.println(grades.ceilingEntry("Bob"));
        System.out.println(grades.ceilingKey("Bob"));
        System.out.println(grades.higherEntry("Bob"));
        System.out.println(grades.higherKey("Bob"));
        System.out.println(grades.headMap("Bob"));
        System.out.println(grades.headMap("Bob", true));
        System.out.println(grades.tailMap("Bob"));
        System.out.println(grades.tailMap("Bob", true));
        System.out.println(grades.containsKey("Bob"));
        System.out.println(grades.containsValue(90));
        System.out.println(grades.descendingMap());
        System.out.println(grades.descendingKeySet());
    }
}

  输出如下:

{Alice=95, Bob=85, Frank=100, Jack=90, Mary=90}
{Bob=85, Frank=100}
{Bob=85, Frank=100, Jack=90}
Bob=85
Bob
Frank=100
Frank
{Alice=95}
{Alice=95, Bob=85}
{Bob=85, Frank=100, Jack=90, Mary=90}
{Bob=85, Frank=100, Jack=90, Mary=90}
true
true
{Mary=90, Jack=90, Frank=100, Bob=85, Alice=95}
[Mary, Jack, Frank, Bob, Alice]

  可以看到,放入TreeMap中的元素默认按键值升序排列,这里的键值类型为String,使用String的CompareTo方法进行比较和排序。subMap返回当前Map的子Map,headMap和tailMap也是如此,

二、TreeMap继承结构简介    

   TreeMap继承自AbstractMap,实现了NavigableMap接口,继承关系图如下:

  【Java入门提高篇】Day30 Java容器类详解(十二)TreeMap详解

  对于AbstractMap相信大家已经不陌生了,HashMap也是继承自AbstractMap,里面有对Map接口的一些默认实现。这里我们可以看到两个新的接口——SortedMap和NavigableMap。SortedMap接口继承自Map接口,从名字就能看出。SortedMap相比Map接口,憎加了排序的功能,内部的方法也不多,简单了解一下就好了【Java入门提高篇】Day30 Java容器类详解(十二)TreeMap详解

【Java入门提高篇】Day30 Java容器类详解(十二)TreeMap详解

  NavigableMap接口继承自SortedMap接口,主要提供一下导航方法:

【Java入门提高篇】Day30 Java容器类详解(十二)TreeMap详解

  说了这么多没啥营养的,接下来还是讲讲真正的干货吧。

三、TreeMap源码分析

  JDK 1.8中的TreeMap源码有两千多行,还是比较多的。所以本文并不打算逐句分析所有的源码,而是挑选几个常用的内部类和方法进行分析。这些方法实现的功能分别是查找、遍历、插入、删除等,其他的方法小伙伴们有兴趣可以自己分析。TreeMap实现的核心部分是关于红黑树的实现,其绝大部分的方法基本都是对底层红黑树增、删、查操作的一个封装。就像前面所说,只要弄懂了红黑树原理,TreeMap 就没什么秘密了。关于红黑树的原理,可以参考前面关于HashMap红黑树的文章,本篇文章不会对此展开讨论。

  TreeMap的主要数据结构是红黑树,而这红黑树结构的承载者便是内部类Entry,先来看看这个Entry类:

    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;

        /**
         * 构造函数*/
        Entry(K key, V value, Entry<K,V> parent) {
            this.key = key;
            this.value = value;
            this.parent = parent;
        }

        public K getKey() {
            return key;
        }

        public V getValue() {
            return value;
        }

        public V setValue(V value) {
            V oldValue = this.value;
            this.value = value;
            return oldValue;
        }

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

  其实内部的结构也很简单,主要有key,value和三个分别指向左孩子,右孩子,父节点的引用,以及用来标识颜色的color成员变量。再来看看TreeMap中的几个重要的成员变量:

    /**
     * 外部比较器
     */
    private final Comparator<? super K> comparator;

    private transient Entry<K,V> root;

    /**
     * 键值对数量
     */
    private transient int size = 0;

    private transient int modCount = 0;

    private static final boolean RED   = false;
    private static final boolean BLACK = true;

    /**
     * 键值对集合
     */
    private transient EntrySet entrySet;
    /**
     * 键的集合
     */
    private transient KeySet<K> navigableKeySet;
    /**
     * 倒序Map
     */
    private transient NavigableMap<K,V> descendingMap;

  comparator用于对map中的键进行排序,root指向红黑树的根节点,size表示键值对的数量,modCount相信已经不陌生了,表示内部结构被修改的次数,RED和BLACK是两个内部常量,即红黑两种颜色,false表示红,true表示黑。entrySet是键值对的集合,navigableKeySet是键的集合,最后一个descendingMap是当前map的一个倒序map。

  在TreeMap中有很多内部类,可以先看图了解一下:

【Java入门提高篇】Day30 Java容器类详解(十二)TreeMap详解

  前前后后一共18个内部类,不过不要慌,其实里面跟迭代器相关的类就占了一半多(10个),跟子Map相关的类占4个,剩下4个就是跟内部集合相关的了。接下来还是一起来看看那些最常用的方法吧:

    // 插入元素
    public V put(K key, V value) {
        TreeMap.Entry<K,V> t = root;
        if (t == null) {
            // 检查类型以及key是否为null
            // 如果外部比较器为null,且key也为null则会抛出空指针异常
            // 如果TreeMap未设置外部比较器,且传入的对象未实现Comparable接口
            // 则会抛出ClassCastException异常
            compare(key, key); // type (and possibly null) check

            // 如果根节点不存在,则用传入的键值对信息生成一个根节点
            root = new TreeMap.Entry<>(key, value, null);
            size = 1;
            modCount++;
            return null;
        }
        int cmp;
        TreeMap.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
                    return t.setValue(value);
                // 一直循环,直到待比较的节点为null
            } while (t != null);
        }
        else {
            // 如果外部比较器为null
            // 如果key为null则抛出空指针
            if (key == null)
                throw new NullPointerException();
            // 如果key未实现comparable接口则会抛出异常
            @SuppressWarnings("unchecked")
            Comparable<? super K> k = (Comparable<? super K>) key;
            do {
                // 跟上面逻辑类似,只是用key的compareTo方法进行比较,而不是用外部比较器的compare方法
                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);
        }
        // 生成键值对
        TreeMap.Entry<K,V> e = new TreeMap.Entry<>(key, value, parent);
        // 连接到当前map的左孩子位置或者右孩子位置
        if (cmp < 0)
            parent.left = e;
        else
            parent.right = e;
        // 插入后的调整
        fixAfterInsertion(e);
        size++;
        modCount++;
        return null;
    }

  其实这里的逻辑跟HashMap中TreeNode的插入逻辑十分类似,也是先找到要插入的位置,然后再进行结构调整。这里的结构调整即红黑树的结构调整,在前面HashMap中已经详细介绍过了,这里就不重复介绍了,调整过程是完全一样的。

    /**
     * 插入后的调整
     */
    private void fixAfterInsertion(TreeMap.Entry<K,V> x) {
        // 将插入的节点初始化为红色节点
        x.color = RED;

        // 如果x不为null且x不是根节点,且x的父节点是红色,此时祖父节点一定为黑色
        while (x != null && x != root && x.parent.color == RED) {
            // 如果x的父节点为祖父节点的左孩子
            if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {
                // y指向x的叔叔节点
                TreeMap.Entry<K,V> y = rightOf(parentOf(parentOf(x)));
                // 如果叔叔节点也是红色,则进行变色处理
                if (colorOf(y) == RED) {
                    // 父节点变成黑色
                    setColor(parentOf(x), BLACK);
                    // 叔叔节点变成黑色
                    setColor(y, BLACK);
                    // 祖父节点变成黑色
                    setColor(parentOf(parentOf(x)), RED);
                    // 将x指向祖父节点,继续往上调整
                    x = parentOf(parentOf(x));
                } else {
                    // 如果叔叔节点是黑色节点
                    // 如果x是父节点的右孩子
                    if (x == rightOf(parentOf(x))) {
                        // 将x指向其父节点
                        x = parentOf(x);
                        // 左旋
                        rotateLeft(x);
                    }
                    // 将x的父节点置为黑色
                    setColor(parentOf(x), BLACK);
                    // 将x的祖父节点置为红色
                    setColor(parentOf(parentOf(x)), RED);
                    // 将祖父节点右旋
                    rotateRight(parentOf(parentOf(x)));
                }
            } else {
                // 这里类似操作
                TreeMap.Entry<K,V> y = leftOf(parentOf(parentOf(x)));
                if (colorOf(y) == RED) {
                    setColor(parentOf(x), BLACK);
                    setColor(y, BLACK);
                    setColor(parentOf(parentOf(x)), RED);
                    x = parentOf(parentOf(x));
                } else {
                    if (x == leftOf(parentOf(x))) {
                        x = parentOf(x);
                        rotateRight(x);
                    }
                    setColor(parentOf(x), BLACK);
                    setColor(parentOf(parentOf(x)), RED);
                    rotateLeft(parentOf(parentOf(x)));
                }
            }
        }
        root.color = BLACK;
    }

  说完了插入,再来看看删除操作。

    // 删除节点
    public V remove(Object key) {
        // 先找到该key对应的键值对
        TreeMap.Entry<K,V> p = getEntry(key);
        if (p == null)
            // 如果未找到则返回null
            return null;

        V oldValue = p.value;
        // 找到后删除该键值对
        deleteEntry(p);
        return oldValue;
    }
    final TreeMap.Entry<K,V> getEntry(Object key) {
        // 为了性能,卸载了比较器的版本
        if (comparator != null)
            return getEntryUsingComparator(key);
        if (key == null)
            throw new NullPointerException();
        @SuppressWarnings("unchecked")
        Comparable<? super K> k = (Comparable<? super K>) key;
        TreeMap.Entry<K,V> p = root;
        // 使用compareTo方法进行查找
        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;
    }

    // 使用比较器的getEntry版本。 从getEntry分离以获得性能。
    // (对于大多数方法而言,这不值得做,这些方法较少依赖于比较器性能,但在这里是值得的。)
    final TreeMap.Entry<K,V> getEntryUsingComparator(Object key) {
        @SuppressWarnings("unchecked")
        K k = (K) key;
        Comparator<? super K> cpr = comparator;
        // 使用比较器进行二分查找
        if (cpr != null) {
            TreeMap.Entry<K,V> p = root;
            while (p != null) {
                int cmp = cpr.compare(k, p.key);
                if (cmp < 0)
                    p = p.left;
                else if (cmp > 0)
                    p = p.right;
                else
                    return p;
            }
        }
        return null;
    }

    /**
     * 删除节点,并调整红黑树以保持它的平衡
     */
    private void deleteEntry(TreeMap.Entry<K,V> p) {
        modCount++;
        size--;

        // 如果p的左右孩子均不为空,则找到p的后继节点,并且将p指向该后继节点
        if (p.left != null && p.right != null) {
            TreeMap.Entry<K,V> s = successor(p);
            p.key = s.key;
            p.value = s.value;
            p = s;
        } // p has 2 children

        // 修复替补节点
        // 用替补节点替换待删除的节点后,需要对其原来所在位置结构进行修复
        TreeMap.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;

            p.left = p.right = p.parent = null;

            // 如果p的颜色是黑色,则进行删除后的修复
            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)
                    p.parent.left = null;
                else if (p == p.parent.right)
                    p.parent.right = null;
                p.parent = null;
            }
        }
    }

    /**
     * 返回指定节点的后继节点
     */
    static <K,V> TreeMap.Entry<K,V> successor(TreeMap.Entry<K,V> t) {
        if (t == null)
            return null;
        else if (t.right != null) {
            TreeMap.Entry<K,V> p = t.right;
            // 如果右子树不为空,则找到右子树的最左节点作为后继节点
            while (p.left != null)
                p = p.left;
            return p;
        } else {
            TreeMap.Entry<K,V> p = t.parent;
            TreeMap.Entry<K,V> ch = t;
            // 如果右子树为空且当前节点为其父节点的左孩子,则直接返回
            // 如果为其父节点的右孩子,则一直往上找,直到找到根节点或者当前节点为其父节点的左孩子时,用其做为后继节点
            while (p != null && ch == p.right) {
                ch = p;
                p = p.parent;
            }
            return p;
        }
    }

    /**
     * 进行删除后的结构修复
     * @param x
     */
    private void fixAfterDeletion(TreeMap.Entry<K,V> x) {
        while (x != root && colorOf(x) == BLACK) {
            // 如果x是父节点的左孩子
            if (x == leftOf(parentOf(x))) {
                // sib指向x的兄弟节点
                TreeMap.Entry<K,V> sib = rightOf(parentOf(x));

                // 如果sib是红色,则进行变色处理
                if (colorOf(sib) == RED) {
                    // 兄弟节点改为黑色
                    setColor(sib, BLACK);
                    // 父节点改为红色
                    setColor(parentOf(x), RED);
                    // 父节点左旋
                    rotateLeft(parentOf(x));
                    // sib指向x的父节点的右孩子
                    sib = rightOf(parentOf(x));
                }

                // 如果sib的左孩子和右孩子都是黑色,则进行变色处理
                if (colorOf(leftOf(sib))  == BLACK &&
                        colorOf(rightOf(sib)) == BLACK) {
                    // 将sib置为红色
                    setColor(sib, RED);
                    // x指向其父节点
                    x = parentOf(x);
                } 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 { // symmetric
                // 跟上面操作类似
                TreeMap.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);
    }

  嗯,对比一下HashMap的删除操作,核心步骤是完全一样的,所以可以对照前面的HashMap红黑树详解进行食用。

  到此,这一篇就很水的讲完啦= =【Java入门提高篇】Day30 Java容器类详解(十二)TreeMap详解

  最近这段时间烦心事比较多,对发展方向也考虑了很多,想做的事情很多,反而让我止步不前,不过很多事情是急不来的,还是好好写写博客,多做总结分享吧。

  机会只留给有准备的人。