TreeMap

最新推荐文章于 2024-07-11 17:24:34 发布
最新推荐文章于 2024-07-11 17:24:34 发布
阅读量157 收藏
点赞数
分类专栏： java集合 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45400916/article/details/120115352
版权

说明

基于红黑树的 NavigableMap 实现。Map根据其键的 Comparable natural ordering 进行排序，或者根据Map创建时提供的 Comparator 进行排序，具体取决于使用的构造函数。

此实现为 containsKey、 get、 put 和 remove操作提供了保证的 log(n) 时间成本。算法改编自 Cormen、Leiserson 和 Rivest 的算法简介。

请注意，树形映射维护的排序，就像任何排序映射一样，无论是否提供显式比较器，必须与 equals 一致，如果此排序映射要正确实现 Map}接口。 之所以如此，是因为 Map接口是根据 equals 操作，但排序映射使用其 compareTo（或 compare）方法执行所有键比较，因此从排序映射的角度来看，此方法认为相等的两个键是相等的。有序映射的行为 是明确定义的，即使它的排序与 equals 不一致；它只是不遵守 Map 接口的一般约定。

注意这个实现不是同步的。如果多个线程同时访问一个映射，并且至少有一个线程在结构上修改了映射，它必须在外部同步。 （结构修改是添加或删除一个或多个映射的任何操作；仅更改与现有键关联的值不是结构修改。）这通常是通过同步一些自然封装映射的对象来完成的。如果不存在此类对象，则应使用 CollectionssynchronizedSortedMap Collections.synchronizedSortedMap 方法“包装”Map。这最好在创建时完成，以防止对地图的意外不同步访问： SortedMap m = Collections.synchronizedSortedMap(new TreeMap(...));

返回的迭代器iterator 类的所有“集合视图方法”返回的集合的方法都是fail-fast：如果在迭代器创建后的任何时间对Map进行结构修改，除了通过迭代器的自己的 remove 方法，迭代器将抛出一个 ConcurrentModificationException。因此，面对并发修改，迭代器快速而干净地失败，而不是在未来不确定的时间冒着任意、非确定性行为的风险。

请注意，无法保证迭代器的快速失败行为，因为一般来说，在存在非同步并发修改的情况下不可能做出任何硬性保证。快速失败的迭代器会尽最大努力抛出 ConcurrentModificationException。因此，编写一个依赖此异常来确保其正确性的程序是错误的：迭代器的快速失败行为应该仅用于检测错误。

所有 Map.Entry此类中的方法及其视图返回的对表示映射生成时的快照。他们不支持 Entry.setValue 方法。 （但请注意，可以使用 put 更改关联映射中的映射。）

源码说明（部分）

 /**
     * 用于维护此树图中顺序的比较器，如果使用其键的自然顺序，则为 null。
     */
    private final Comparator<? super K> comparator;

    private transient Entry<K,V> root;

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

    /**
     * 对树的结构修改次数。
     */
    private transient int modCount = 0;

    /**
     * 使用其键的自然顺序构造一个新的空树映射。
     */
    public TreeMap() {
        comparator = null;
    }

    /**
     * 使用给定的键的顺序构造一个新的空树映射
     */
    public TreeMap(Comparator<? super K> comparator) {
        this.comparator = comparator;
    }

    /**
     * 构造一个包含与给定映射相同的映射的新树映射，根据其键的自然排序排序。
     */
    public TreeMap(Map<? extends K, ? extends V> m) {
        comparator = null;
        putAll(m);
    }

    /**
     * 构造一个包含相同映射并使用与指定排序映射相同的排序的新树映射。此方法在线性时间内运行。
     */
    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) {
        }
    }
  /**
     *返回键值映射的数量

     */
    public int size() {
        return size;
    }

    /**
     *map中是否存在相应的键值，存在返回true
     
     */
    public boolean containsKey(Object key) {
        return getEntry(key) != null;
    }

    /**
     * map中是否存在一个或多个相应的value值。
     */
    public boolean containsValue(Object value) {
        for (Entry<K,V> e = getFirstEntry(); e != null; e = successor(e))
            if (valEquals(value, e.value))
                return true;
        return false;
    }

    /**
     * 获得相应键值对应的value，如果存在该key，则返回value，否则null
     */
    public V get(Object key) {
        Entry<K,V> p = getEntry(key);
        return (p==null ? null : p.value);
    }

    public Comparator<? super K> comparator() {
        return comparator;
    }

    /**
     * 获得第一个key
     */
    public K firstKey() {
        return key(getFirstEntry());
    }

    /**
     * 获得最后一个key
     */
    public K lastKey() {
        return key(getLastEntry());
    }

    /**
     * 复制给定的map到当前map中
     */
    public void putAll(Map<? extends K, ? extends V> map) {
        int mapSize = map.size();
        if (size==0 && mapSize!=0 && map instanceof SortedMap) {
            Comparator<?> c = ((SortedMap<?,?>)map).comparator();
            if (c == comparator || (c != null && c.equals(comparator))) {
                ++modCount;
                try {
                    buildFromSorted(mapSize, map.entrySet().iterator(),
                                    null, null);
                } catch (java.io.IOException cannotHappen) {
                } catch (ClassNotFoundException cannotHappen) {
                }
                return;
            }
        }
        super.putAll(map);
    }
     /**
     *获得给定key的Entry
     */
    final Entry<K,V> getEntry(Object key) {
        // Offload comparator-based version for sake of performance
        if (comparator != null)
            return getEntryUsingComparator(key);
        if (key == null)
            throw new NullPointerException();
        @SuppressWarnings("unchecked")
            Comparable<? super K> k = (Comparable<? super K>) key;
        Entry<K,V> p = root;
        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 Entry<K,V> getEntryUsingComparator(Object key) {
        @SuppressWarnings("unchecked")
            K k = (K) key;
        Comparator<? super K> cpr = comparator;
        if (cpr != null) {
            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;
    }

    /**
     * 获取指定键对应的条目；如果不存在这样的条目，则返回大于指定键的最小键的条目；如果不存在这样的条目（即树中最大的键小于指定的键），则返回 null。
     */
    final Entry<K,V> getCeilingEntry(K key) {
        Entry<K,V> p = root;
        while (p != null) {
            int cmp = compare(key, p.key);
            if (cmp < 0) {
                if (p.left != null)
                    p = p.left;
                else
                    return p;
            } else if (cmp > 0) {
                if (p.right != null) {
                    p = p.right;
                } else {
                    Entry<K,V> parent = p.parent;
                    Entry<K,V> ch = p;
                    while (parent != null && ch == parent.right) {
                        ch = parent;
                        parent = parent.parent;
                    }
                    return parent;
                }
            } else
                return p;
        }
        return null;
    }

    /**
     * 获取指定键对应的条目；如果不存在这样的条目，则返回小于指定键的最大键的条目；如果不存在这样的条目，则返回  null。
     */
    final Entry<K,V> getFloorEntry(K key) {
        Entry<K,V> p = root;
        while (p != null) {
            int cmp = compare(key, p.key);
            if (cmp > 0) {
                if (p.right != null)
                    p = p.right;
                else
                    return p;
            } else if (cmp < 0) {
                if (p.left != null) {
                    p = p.left;
                } else {
                    Entry<K,V> parent = p.parent;
                    Entry<K,V> ch = p;
                    while (parent != null && ch == parent.left) {
                        ch = parent;
                        parent = parent.parent;
                    }
                    return parent;
                }
            } else
                return p;

        }
        return null;
    }

    /**
     * 获取大于指定键的最小键的条目；如果不存在这样的条目，则返回大于指定键的最小键的条目；如果不存在这样的条目，则返回  null。
     */
    final Entry<K,V> getHigherEntry(K key) {
        Entry<K,V> p = root;
        while (p != null) {
            int cmp = compare(key, p.key);
            if (cmp < 0) {
                if (p.left != null)
                    p = p.left;
                else
                    return p;
            } else {
                if (p.right != null) {
                    p = p.right;
                } else {
                    Entry<K,V> parent = p.parent;
                    Entry<K,V> ch = p;
                    while (parent != null && ch == parent.right) {
                        ch = parent;
                        parent = parent.parent;
                    }
                    return parent;
                }
            }
        }
        return null;
    }

    /**
     *返回小于指定键的最大键的条目；如果不存在这样的条目（即树中的最小键大于指定的键），则返回  null。
     */
    final Entry<K,V> getLowerEntry(K key) {
        Entry<K,V> p = root;
        while (p != null) {
            int cmp = compare(key, p.key);
            if (cmp > 0) {
                if (p.right != null)
                    p = p.right;
                else
                    return p;
            } else {
                if (p.left != null) {
                    p = p.left;
                } else {
                    Entry<K,V> parent = p.parent;
                    Entry<K,V> ch = p;
                    while (parent != null && ch == parent.left) {
                        ch = parent;
                        parent = parent.parent;
                    }
                    return parent;
                }
            }
        }
        return null;
    }

    /**
     * A将指定值与此映射中的指定键相关联。如果映射先前包含键的映射，则旧值将被替换。
     */
    public V put(K key, V value) {
        Entry<K,V> t = root;
        if (t == null) {
            compare(key, key); // type (and possibly null) check

            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;
                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);
        }
        else {
            if (key == null)
                throw new NullPointerException();
            @SuppressWarnings("unchecked")
                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++;
        modCount++;
        return null;
    }

    /**
     * 如果存在该键值，则返回键所对应的值，并且移除
     */
    public V remove(Object key) {
        Entry<K,V> p = getEntry(key);
        if (p == null)
            return null;

        V oldValue = p.value;
        deleteEntry(p);
        return oldValue;
    }

    /**
     * 清空该map
     */
    public void clear() {
        modCount++;
        size = 0;
        root = null;
    }

总结

简单概述

  1. TreeMap存储K-V键值对，通过红黑树（R-B tree）实现；
  2. TreeMap继承了NavigableMap接口，NavigableMap接口继承了
  3. SortedMap接口，可支持一系列的导航定位以及导航操作的方法，当然只是提供了接口，需要TreeMap自己去实现；
  4. TreeMap实现了Cloneable接口，可被克隆，实现了Serializable接口，可序列化；
  5. TreeMap因为是通过红黑树实现，红黑树结构天然支持排序，默认情况下通过Key值的自然顺序进行排序；
    对于红黑树的了解可以查看红黑树

红黑树

红黑树规则特点：

  1. 节点分为红色或者黑色；
  2. 根节点必为黑色；
  3. 叶子节点都为黑色，且为null；
  4. 连接红色节点的两个子节点都为黑色（红黑树不会出现相邻的红色节点）；
  5. 从任意节点出发，到其每个叶子节点的路径中包含相同数量的黑色节点；
  6. 新加入到红黑树的节点为红色节点；

红黑树自平衡基本操作：

  1. 变色：在不违反上述红黑树规则特点情况下，将红黑树某个node节点颜色由红变黑，或者由黑变红；
  2. 左旋：逆时针旋转两个节点，让一个节点被其右子节点取代，而该节点成为右子节点的左子节点
  3. 右旋：顺时针旋转两个节点，让一个节点被其左子节点取代，而该节点成为左子节点的右子节点

Entry的实现

Entry静态内部类实现了Map的内部接口Entry，提供了红黑树存储结构的java实现，通过left属性可以建立左子树，通过right属性可以建立右子树，通过parent可以往上找到父节点。
在这里插入图片描述

构造函数可以见上述源码分析。

put方法流程

在这里插入图片描述
代码见源码分析。
其他操作可以通过源码查看。
具体内容详见TreeMap

((٩(//̀/́/)۶))
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
排行榜，分值相同名次一样，求名次前100
GQ_666的博客
12-29 1918
实现的需求：排行榜前100名，分值相同的排名相同。这样从100万数据里面求前100名，可能有1000多个。 实现办法如下（配置Redis自行完成，下面代码拿取即可使用）： @RestController public class SortBoardController { @Autowired private RedisTemplate redisTemplate; /** * 获取前100数据 * * @return */
TreeMap<K,V> 映射的使用 TreeMap 排序
故不积跬步，无以至千里。
02-21 1096
需求 ：会员计划   会员等级  先按照 会员计划的listorder 排序 再按照会员等级的listorder排序 排序 获取最高的  获得最高级别的卡 最高会员计划 ListOrder 最高会员等级 listOrder 最高卡号 ORDER BY obj.id DESC public class Sort62 { public static void main(String[]
Java 集合系列12之 TreeMap详细介绍(源码解析)和使用示例
荒岛码农
10-08 2554
概要 这一章，我们对TreeMap进行学习。 我们先对TreeMap有个整体认识，然后再学习它的源码，最后再通过实例来学会使用TreeMap。内容包括： 第1部分 TreeMap介绍 第2部分 TreeMap数据结构 第3部分 TreeMap源码解析(基于JDK1.6.0_45) 第4部分 TreeMap遍历方式 第5部分 TreeMap示例 转载请注明出处：http:
TreeMap的简单应用
ZJJG4的博客
04-01 1089
前面介绍了Map接口的实现类LinkedHashMap，LinkedHashMap存储的元素是有序的，可以保持元素的插入顺序，但不能对元素进行自动排序。在一些编程应用场景中，如果在数据的存储过程中，能够自动对数据进行排序，将会极大提高编程效率，程序员无需再为数据排序编写必要的代码。例如，一般大量的数据都被存储在大型数据库中，程序员需要能够按照多个键对索引排序以提供搜索效率。 Map接口有一个重要的...
Java TreeMap 介绍和使用
热门推荐
x_i_y_u_e的专栏
06-05 3万+
概要 这一章，我们对TreeMap进行学习。 我们先对TreeMap有个整体认识，然后再学习它的源码，最后再通过实例来学会使用TreeMap。内容包括： 第1部分 TreeMap介绍 第2部分 TreeMap数据结构 第3部分 TreeMap遍历方式 转载请注明出处：http://www.cnblogs.com/skywang12345/admin/EditPosts.as
java treemap_Java TreeMap的排序
weixin_39525243的博客
02-15 202
TreeMap 和 HashMap 用法大致相同，但实际需求中，我们需要把一些数据进行排序；以前在项目中，从数据库查询出来的数据放在List中，顺序都还是对的，但放在HashMap中，顺序就完全乱了。为了处理排序的问题：1. 对于一些简单的排序，如:数字，英文字母等TreeMap hm = new TreeMap(newComparator() {public intcompare(Object ...
Java中HashMap和TreeMap的区别深入理解
09-05
HashMap和TreeMap是Java中两种常用的Map实现，它们各自具有不同的特性和使用场景。 HashMap是基于哈希表实现的，其核心思想是通过键对象的hashCode()方法来快速定位到对应的桶（bucket），从而提高查找效率。...
vue_echarts_treemap.zip
06-28
ECharts 是百度开发的一个基于 JavaScript 的数据可视化库，它提供了丰富的图表类型，包括柱状图、折线图、饼图以及我们关注的 TreeMap。TreeMap 是一种用以表示层次结构数据的可视化方式，通过不同大小的矩形来展示...
TreeMap源码
01-13
TreeMap是Java集合框架中的一种有序映射数据结构，它实现了SortedMap接口，提供了按自然顺序或自定义比较器顺序存储键值对的能力。在深入理解TreeMap的源码之前，我们首先要了解其背后的基石——红黑树。 红黑树...
Java TreeMap排序算法实例
08-30
Java TreeMap排序算法实例 Java TreeMap排序算法是Java中的一种常用的排序算法，主要用于对Map中的键值对进行排序。TreeMap排序算法的实现原理是基于红黑树数据结构的，通过将键值对插入到红黑树中，并对树中的节点...
TreeMap in Java_java_treemap_
09-30
Java中的`TreeMap`是一个基于红黑树（Red-Black Tree）数据结构的有序映射容器。它维护了键的自然顺序或者根据提供的比较器进行排序。`TreeMap`类继承自`AbstractMap`，实现了`NavigableMap`、`SortedMap`接口，因此...
配置Java开发环境
Broken_x的博客
07-10 1069
Java开发环境配置
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 275
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 1782
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
java Object 转 Integer
servepeople的博客
07-09 1180
在 Java 中，可以通过多种方法将一个Object转换为Integer。
java占位符替换五种方式
weixin_61478518的博客
07-08 352
在业务开发中，经常需要输出文本串。其中，部分场景下大部分文本内容是一样的，只有少部分点是不一样。简单做法是直接拼接字段，但是这会有个问题。后面如果想要修改内容，那么每个地方都要修改，这不符合设计模式中的开闭原则，面向应该对扩展开放，对修改关闭。如何解决这个问题？先来看现实生活中的例子，个人信息填写。一般会要填写表格，已经定义好了姓名，性别，年龄等字段，只要填写对应的个人信息就好了。在程序开发中，我们会预先定义好一个字符串模板，需要改动的点使用占位符。
Java方法练习-双色球彩票系统
最新发布
T1798218285的博客
07-11 52
红色球号码从1-33中选择；蓝色球号码从1-16中选择。投注号码由6个红色球号码和1个蓝色球号码组成。三等奖 5+1 / 5+0 3000。四等奖4+1 / 4+0 200。六等奖1+1 / 1+0 5。一等奖6+1 1000w。二等奖6+0 500w。五等奖3+1 / 2+1。
echarts treemap
12-08
Echarts Treemap是一种可视化图表，它可以将数据以矩形的形式展示出来，矩形的大小和颜色可以反映数据的大小和比例。下面是一个使用Python的pyecharts库绘制Echarts Treemap的例子： ```python import json from pyecharts import options as opts from pyecharts.charts import TreeMap def treemap_base() -> TreeMap: with open("/home/user/Data/disk.tree.json","r") as tree_f: data = json.load(tree_f) c = ( TreeMap() .add("present data", data) .set_global_opts(title_opts=opts.TitleOpts(title="TreeMap")) ) return c c = treemap_base() c.render("/home/user/Desktop/treemap.html") ``` 这个例子中，我们使用了pyecharts库中的TreeMap类来创建一个Echarts Treemap图表。首先，我们从JSON文件中读取数据，然后将数据添加到TreeMap中。最后，我们设置了图表的标题，并将图表保存到本地文件中。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值