TreeMap源码解析和设计思路

于 2024-03-20 16:18:44 发布
阅读量920 收藏 9
点赞数 7
分类专栏： # 集合 文章标签： 开发语言 java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44716935/article/details/136878195
版权

一、TreeMap有两种排序方式

  1. 自然排序(Natural Order)

自然排序是TreeMap默认的排序方式,它根据键对象的自然顺序对键进行排序。如果键对象实现了Comparable接口,TreeMap将使用对象的compareTo方法来比较键的大小。如果键对象没有实现Comparable接口,则会在构造时抛出NullPointerException异常。

// 自然排序，对键排序
TreeMap<String, Integer> naturalOrderMap = new TreeMap<>();
naturalOrderMap.put("apple", 1);
naturalOrderMap.put("orange", 3);
naturalOrderMap.put("banana", 2);


System.out.println(naturalOrderMap); // 输出: {apple=1, banana=2, orange=3}
  1. 定制排序(Custom Order)

如果自然排序无法满足需求,可以在构造TreeMap时传入一个Comparator对象,用于定制排序规则。Comparator接口定义了compare方法

// 定制排序 - Key按字符串长度排序
Comparator<String> lengthComparator = (s1, s2) -> Integer.compare(s1.length(), s2.length());
TreeMap<String, Integer> customOrderMap = new TreeMap<>(lengthComparator);
customOrderMap.put("pear", 4);
customOrderMap.put("apple", 1);
customOrderMap.put("banana", 2);
customOrderMap.put("orange", 3);

System.out.println(customOrderMap); // 输出: {pear=4, apple=1, orange=3, banana=2}

二、类结构源码和初始化对象

public class TreeMap<K,V>
    extends AbstractMap<K,V>
    implements NavigableMap<K,V>, Cloneable, java.io.Serializable
{
    /**
     * 用于维护树的排序规则的比较器。
     * 如果为null,则使用键对象的自然排序。
     */
    private final Comparator<? super K> comparator;

    // 红黑树的根节点
    private transient Entry<K,V> root;

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

    /**
     * 记录对树的结构修改次数,用于支持fail-fast机制
     */
    private transient int modCount = 0;

    /**
     * 构造一个空的TreeMap,使用键对象的自然排序。
     * 要求所有键都实现Comparable接口,并且互相可比较。
     */
    public TreeMap() {
        comparator = null;
    }

    /**
     * 构造一个空的TreeMap,使用指定的比较器排序。
     * 要求所有键都通过比较器可比较。
     *
     * @param comparator 用于排序的比较器,如果为null则使用键对象自然排序
     */
    public TreeMap(Comparator<? super K> comparator) {
        this.comparator = comparator;
    }

    /**
     * 根据给定的Map构造TreeMap,使用键对象自然排序。
     * 要求所有键都实现Comparable接口,并且互相可比较。
     * 时间复杂度为O(n*log(n))。
     *
     * @param m 提供初始映射关系的Map
     * @throws ClassCastException 如果键不可比较
     * @throws NullPointerException 如果给定Map为null
     */
    public TreeMap(Map<? extends K, ? extends V> m) {
        comparator = null;
        putAll(m);
    }

    /**
     * 根据给定的有序Map构造TreeMap,使用与之相同的排序规则。
     * 时间复杂度为O(n)。
     *
     * @param m 提供初始映射关系的有序Map
     * @throws NullPointerException 如果给定Map为null
     */
    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) {
        }
    }
	
	//红黑树的节点
	static final class Entry<K,V> implements Map.Entry<K,V> {
	}
}

TreeMap继承自AbstractMap,实现了NavigableMap、Cloneable和Serializable接口。其中NavigableMap继承自SortedMap,允许键值对按升序或降序遍历。Cloneable支持克隆操作,Serializable支持序列化操作。

  • 无参构造器创建空树使用自然排序
  • 带比较器的构造器使用指定的排序规则
  • Map构造则使用键对象自然排序构建树
  • SortedMap构造可以利用其有序性

三、put添加源码

好的,让我们来分析一下这段put方法的源码:

public V put(K key, V value) {
    // 获取红黑树根节点
    Entry<K,V> t = root;

    // 1.判断红黑树的节点是否为空，为空的话，新增的节点直接作为根节点
    if (t == null) {
        // 检查键对象是否可比较
        compare(key, key);

        // 创建一个新的根节点Entry
        root = new Entry<>(key, value, null);
        size = 1;
        modCount++;
        return null;
    }

    // 声明一些变量
    int cmp;
    Entry<K,V> parent;
    // 获取比较器
    Comparator<? super K> cpr = comparator;

    // 2.如果使用自定义比较器
    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
                return t.setValue(value);
        } while (t != null);
    }
    // 3.如果使用自然排序
    else {
        // 如果键为null,抛出NullPointerException
        if (key == null)
            throw new NullPointerException();
        // 获取键的Comparable视图
        @SuppressWarnings("unchecked")
        Comparable<? super K> k = (Comparable<? super K>) key;
        do {
            parent = t;
            // 使用键对象的compareTo方法比较
            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++;
    modCount++;
    return null;
}
  1. 如果树为空,直接创建一个根节点并返回。
  2. 如果使用自定义比较器,则使用comparator.compare方法比较键;否则使用键对象自身的compareTo方法比较。
  3. 沿着树从根节点开始遍历,根据比较结果选择左子树还是右子树,直到找到插入位置或遇到重复键。
  4. 如果找到重复键,直接更新其值并返回旧值。
  5. 如果未找到重复键,创建新节点,并将其链接到父节点中合适的位置。
  6. 调用fixAfterInsertion方法调整树结构,维护平衡。
  7. 更新size大小和modCount计数器。

需要注意的几点:

  1. 如果使用自然排序,键对象必须实现Comparable接口,否则会抛出ClassCastException。
  2. 如果键为null且使用自然排序,会抛出NullPointerException。
  3. 在比较时使用了null-safe的compare方法,避免传入null导致NullPointerException。

四、复现为啥必须实现Comparable接口？

import java.util.TreeMap;

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 没有实现Comparable接口
}

public class TreeMapDemo {
    public static void main(String[] args) {
        // 创建一个TreeMap,使用自然排序
        TreeMap<Person, String> treeMap = new TreeMap<>();

        // 添加一些键值对
        treeMap.put(new Person("Alice", 25), "Alice's value");
        treeMap.put(new Person("Bob", 30), "Bob's value");
        treeMap.put(new Person("Charlie", 35), "Charlie's value");

        // 这里会抛出ClassCastException
        // 因为Person类没有实现Comparable接口
        treeMap.put(new Person("David", 40), "David's value");
    }
}

定义了一个Person类,但是没有实现Comparable接口。然后,我们创建了一个TreeMap对象,并尝试使用Person对象作为键。

当我们执行treeMap.put(new Person("David", 40), "David's value");语句时,会抛出ClassCastException异常,因为TreeMap在使用自然排序时,要求键对象必须实现Comparable接口。

解决方案:

  1. 让Person类实现Comparable接口
class Person implements Comparable<Person> {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public int compareTo(Person other) {
        // 按照age进行排序
        return Integer.compare(this.age, other.age);
    }
}

Person类实现了Comparable接口,并在compareTo方法中实现了按照age进行排序的逻辑。这样,当我们使用Person对象作为TreeMap的键时,就不会再抛出ClassCastException异常了。

五、get查询源码

根据给定的键对象获取对应的树Entry节点

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

    final Entry<K, V> getEntry(Object key) {
        // 使用自定义比较器,则调用getEntryUsingComparator方法
        if (comparator != null)
            return getEntryUsingComparator(key);

        // 如果键为null且使用自然排序,抛出NullPointerException
        if (key == null)
            throw new NullPointerException();

        // 获取键对象的Comparable视图
        @SuppressWarnings("unchecked")
        Comparable<? super K> k = (Comparable<? super K>) key;

        // 从根节点开始遍历
        Entry<K, V> p = root;
        while (p != null) {
            // 使用键对象的compareTo方法比较
            int cmp = k.compareTo(p.key);
            // 根据比较结果选择左子树或右子树
            if (cmp < 0)
                p = p.left;
            else if (cmp > 0)
                p = p.right;
                // 如果找到对应的节点,返回该节点
            else
                return p;
        }
        // 未找到对应节点,返回null
        return null;
    }

  1. 首先检查是否使用了自定义比较器。如果使用了,则调用getEntryUsingComparator方法,该方法的实现类似,只是使用comparator.compare方法进行比较。

  2. 如果使用自然排序,并且传入的键为null,则抛出NullPointerException。

  3. 获取键对象的Comparable视图,用于后续比较。

  4. 从根节点开始遍历树。使用键对象的compareTo方法与当前节点的键进行比较,根据比较结果选择左子树还是右子树继续遍历。

  5. 如果找到与键对象相等的节点,直接返回该节点。

  6. 如果遍历完整棵树还未找到对应节点,返回null。

六、总结

  1. 数据结构

    • TreeMap底层使用红黑树(Red-Black Tree),和 HashMap 的红黑树结构一样。红黑树是一种自平衡的二叉查找树。
    • 每个节点(Entry)存储键值对数据,并通过左右子节点指针维护树的结构。

  2. 排序规则

    • TreeMap支持两种排序方式:自然排序(Natural Order)和自定义排序(Custom Order)。
    • 自然排序要求键对象实现Comparable接口,并根据对象的compareTo方法进行比较。
    • 自定义排序通过在构造时传入Comparator对象来指定排序规则。
Java语录精选
关注
  • 7
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【Java集合源码剖析】TreeMap源码剖析
兰亭风雨的专栏
07-07 1万+
前言 本文不打算延续前几篇的风格（对所有的源码加入注释），因为要理解透TreeMap的所有源码，对博主来说，确实需要耗费大量的时间和经历，目前看来不大可能有这么多时间的投入，故这里意在通过于阅读源码对TreeMap有个宏观上的把握，并就其中一些方法的实现做比较深入的分析。 红黑树简介 TreeMap是基于红黑树实现的，这里只对红黑树做个简单的介绍，红黑树是一种特殊的二叉排序树，关于二叉排序树，参见：http://blog.csdn.net/ns_code/article/details/
Java TreeMap 源码解析
12-22
继上篇文章介绍完了HashMap，这篇文章开始介绍Map系列另一个比较重要的类TreeMap。 大家也许能感觉到，网络上介绍HashMap的文章比较多，但是介绍TreeMap反而不那么多，这里面是有原因：一方面HashMap的使用场景比较...
Java 集合系列12之 TreeMap详细介绍(源码解析)和使用示例
荒岛码农
10-08 2578
概要 这一章，我们对TreeMap进行学习。 我们先对TreeMap有个整体认识，然后再学习它的源码，最后再通过实例来学会使用TreeMap。内容包括： 第1部分 TreeMap介绍 第2部分 TreeMap数据结构 第3部分 TreeMap源码解析(基于JDK1.6.0_45) 第4部分 TreeMap遍历方式 第5部分 TreeMap示例 转载请注明出处：http:
TreeMap源码分析
茫然背影的博客
01-11 292
目录 TreeMap底层采用红黑树存储 TreeMap构造函数 TreeMap Put分析 TreeMap Get分析 TreeMap Remove分析 TreeMap底层采用红黑树存储 TreeMap构造函数 public TreeMap() { comparator = null;//只是把比较器置为null,并未开辟空间 } TreeMap Put分析 初...
TreeMap源码解析
上善若泪
11-13 496
文章目录1 TreeMap1.1 二叉查询树、红黑树1.2 TreeMap的底层实现 1 TreeMap TreeMap是基于红黑树结构实现的一种Map，要分析TreeMap的实现首先就要对红黑树有所了解。 要了解什么是红黑树，就要了解它的存在主要是为了解决什么问题，对比其他数据结构比如数组，链表，Hash表等树这种结构又有什么优点。 1.1 二叉查询树、红黑树 简单总结一下数组，链表，Hash表以及树的优缺点： 数组 优点：(1)随机访问效率高(根据下标查询)，(2)搜索效率较高(可使用折半方法)
TreeMap源码分析！
xuhuaabc的博客
06-13 492
1.TreeMap的继承关系 继承了AbstractMap抽象类，实现了Map接口； public class TreeMap<K,V> extends AbstractMap<K,V> implements NavigableMap<K,V>, Cloneable, java.io.Serializable NavigableMap继承了SortedMap类...
java TreeMap源码解析详解
08-30
Java的TreeMap是一种基于红黑树数据结构的有序映射容器。它继承了AbstractMap类，实现了SortedMap和NavigableMap接口，提供了丰富的操作方法...理解TreeMap的源码和工作原理对于优化Java应用的性能和内存管理至关重要。
Java源码解析TreeMap简介
08-26
Java源码解析TreeMap简介 TreeMap是Java中的一种常用的排序树，实现了NavigableMap接口。下面是对TreeMap的详细介绍： 1. TreeMap的实现机制 TreeMap是基于Red-Black树的数据结构，红黑树是一种自平衡的二叉查找...
尚硅谷——Java TreeMap源码解析
01-31
关于TreeMap的源码解析，它继承自AbstractMap，实现了NavigableMap和SortedMap接口。AbstractMap类提供了Map接口的通用实现，以减少实现Map接口时的重复代码。TreeMap通过维护一个红黑树来保证元素的顺序，而...
TreeMap源码
01-13
总的来说，TreeMap源码的学习可以帮助我们理解红黑树的数据结构和其实现原理，这对于优化和调试涉及大量数据的操作至关重要。同时，掌握TreeMap的内部机制也能提升我们在实际开发中使用Java集合框架的能力。
TreeMap 源码解析
最新发布
流华追梦的专栏
10-27 138
TreeMap 按照 key 的顺序的 Map 实现类，底层采用红黑树来实现存储。TreeMap 因为采用树结构，所以无需初始考虑像 HashMap 考虑容量问题，也不存在扩容问题。TreeMap 的 key 不允许为空( null )，可能是因为红黑树是一颗二叉查找树，需要对 key 进行排序。相比 HashMap 来说，TreeMap 不仅仅支持指定 key 的查找，也支持 key 范围的查找。当然，这也得益于 TreeMap 数据结构能够提供的有序特性。
TreeMap源码超详解析
m0_53837063的博客
03-12 188
TreeMap源码超详解析
sheng的学习笔记-TreeMap源码分析（源码版本16）
coldstarry的专栏
11-22 321
TreeMap的使用和源码解析
Java集合——TreeMap源码详解
weixin_30783913的博客
11-25 232
0. 前言本文对TreeMap的源码进行了解析，本文原创，转载请注明出处：http://blog.csdn.net/seu_calvin/article/details/52746000先对TreeMap的特性进行一个概述：（1）TreeMap 是一个有序的key-value集合，它是通过红黑树实现的。因为红黑树是平衡的二叉搜索树，所以其put（包含update操作）、get、remove的...
TreeMap源码解读
weixin_54412689的博客
02-24 121
TreeMap源码解读。
Java集合之TreeMap源码分析
小张的专栏
11-19 1148
在jdk 1.8 中 HashMap是数组+链表+红黑树实现的,当hash表某个位置上的元素个数超过某个阀值过后就采用红黑树结构，否则采用链表结构，在HashMap中元素 相对插入顺序是无序的，也就是说其遍历顺序不可预测。LinkedHashMap是基于HashMap实现的，使用了双向链表，保证按照插入顺序或者访问顺序进行迭代，TreeMap 支持按键值进行升序访问，或者由传入的比较器（Comparator）来控制。
java TreeMap源码解析（jdk1.7）
qq_41786692的博客
04-15 641
一、TreeMap概述1.TreeMap继承了AbstractMap，是一个key-value集合；2.TreeMap实现了NavigableMap接口（可以针对给定搜索目标返回最接近匹配项的导航方法），比如按照key升序或者降序返回；3.TreeMap是一个有序的key-value，是通过红黑树来实现的；二、红黑树介绍1.红黑树概念    红黑树是一种自平衡二叉查找树，是在插入和删除操作时通过特...
JDK源码解析：红黑树TreeMap深度剖析
"这份资源是关于JDK源码分析的PPT，重点讲解了红黑树（Red-Black Tree，RBT）在TreeMap中的应用。内容包括红黑树的基本概念、性质、删除操作的几种情况，以及与其他数据结构如AVL树的对比。课程还涉及了源码剖析、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Java语录精选

你的鼓励是我坚持下去的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值