TreeMap总结

已于 2022-07-26 21:49:10 修改
阅读量306 收藏 1
点赞数
文章标签： java 数据结构 开发语言
于 2022-01-18 10:26:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_23412557/article/details/122552821
版权

概述

TreeMap实现了SotredMap接口，它是有序的集合。而且是一个红黑树结构，每个key-value都作为一个红黑树的节点。如果在调用TreeMap的构造函数时没有指定比较器，则根据key执行自然排序。这点会在接下来的代码中做说明，如果指定了比较器则按照比较器来进行排序。 （也就是在创建TreeMap时如果没有传入Comparator比较器，那么key就必须实现Comparable接口）

TreeMap传入比较器或者key本身实现可比较接口，除了是满足treeMap树结构的排序功能，同时还有去重的功能。

继承关系 

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



//间接实现了SortedMap接口

public interface NavigableMap<K,V> extends SortedMap<K,V>

 基本属性

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;

数据结构

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;
        }
        //重写equals()方法
        public boolean equals(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry<?,?> e = (Map.Entry<?,?>)o;
            //两个节点的key相等，value相等，这两个节点才相等
            return valEquals(key,e.getKey()) && valEquals(value,e.getValue());
        }
        重写hashCode()方法
        public int hashCode() {
            int keyHash = (key==null ? 0 : key.hashCode());
            int valueHash = (value==null ? 0 : value.hashCode());
            key和vale hash值得异或运算，相同则为零，不同则为1
            return keyHash ^ valueHash;
        }

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

 构造方法

//构造方法，comparator用键的顺序做比较
public TreeMap() {
    comparator = null;
}
 
//构造方法，提供比较器，用指定比较器排序
public TreeMap(Comparator<? super K> comparator) {
    his.comparator = comparator;
}
 
//将m中的元素转化daoTreeMap中，按照键的顺序做比较排序
public TreeMap(Map<? extends K, ? extends V> m) {
    comparator = null;
    putAll(m);
}
 
//构造方法，指定的参数为SortedMap
//采用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) {
    }
}

TreeMap提供了四个构造方法，实现了方法的重载。无参构造方法中比较器的值为null,采用自然排序的方法，如果指定了比较器则称之为定制排序.

  • 自然排序：TreeMap的所有key必须实现Comparable接口，所有的key都是同一个类的对象
  • 定制排序：创建TreeMap对象传入了一个Comparator对象，该对象负责对TreeMap中所有的key进行排序，采用定制排序不要求Map的key实现Comparable接口。等下面分析到比较方法的时候在分析这两种比较有何不同。 

操作 

对于Map来说，使用的最多的就是put()/get()/remove()等方法，下面依次进行分析 

put() 

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

红黑树是一个更高效的检索二叉树，有如下特点：

  1. 每个节点只能是红色或者黑色
  2. 根节点永远是黑色的
  3. 所有的叶子的子节点都是空节点，并且都是黑色的
  4. 每个红色节点的两个子节点都是黑色的（不会有两个连续的红色节点）
  5. 从任一个节点到其子树中每个叶子节点的路径都包含相同数量的黑色节点（叶子节点到根节点的黑色节点数量每条路径都相同）

 remove()

删除的逻辑，实际上是以替换的方式做删除，找到继承节点代替该节点，然后将继承节点删除。

  1. 首先判断改节点是否存在同时存在左右两个子节点，如果同时存在，那么就查询到当前节点的右孩子节点或者右孩子节点的最小左孩子，作为继承节点
  2. 若当前节点只有一个子节点，那么就用唯一的子节点作为该节点的继承节点即可
  3. 当前节点的值用继承节点的值替换
  4. 删除继承节点
  5. 再进行红黑树的平衡

public V remove(Object key) {
    Entry<K,V> p = getEntry(key);  //根据key查找节点，并返回该节点
    if (p == null)
        return null;
 
    V oldValue = p.value;    //获取key对应的值
    deleteEntry(p);     //删除节点
    return oldValue;   //返回key对应的值
}
 
final Entry<K,V> getEntry(Object key) {
    //根据键寻找节点，有非为两种方式，如果定制了比较器，采用定制排序方式，否则使用自然排序
    if (comparator != null) 
        return getEntryUsingComparator(key); //循环遍历树，寻找和key相等的节点
    if (key == null)
        throw new NullPointerException();
    Comparable<? super K> k = (Comparable<? super K>) key;
    Entry<K,V> p = root;
    while (p != null) {  //循环遍历树，寻找和key相等的节点
        int cmp = k.compareTo(p.key);
        if (cmp < 0)
            p = p.left;
        else if (cmp > 0)
            p = p.right;
        else
            return p;
    }
    return null;
}
//删除节点
private void deleteEntry(Entry<K,V> p) {
    modCount++;  //记录修改的次数
    size--;   //数量减1
 
    //当前节点的两个孩子都不为空
    if (p.left != null && p.right != null) {
        //寻找继承者，继承者为当前节点的右孩子节点或者右孩子节点的最小左孩子
        Entry<K,V> s = successor(p);
        p.key = s.key;     //key - value  的替换 ，并没有替换颜色
        p.value = s.value;
        p = s;  //指向继承者
    } // p has 2 children
 
    // Start fixup at replacement node, if it exists.
    //开始修复树结构，继承者的左孩子不为空，返回左孩子，否则返回右孩子
    //不可能存在左右两个孩子都存在的情况，successor寻找的就是最小节点，它的左孩子节点为null
    Entry<K,V> replacement = (p.left != null ? p.left : p.right);
 
    if (replacement != null) {
        // Link replacement to parent
        //已经被选为继承者，当前拥有的一切放弃，所以将孩子交给爷爷抚养
        replacement.parent = p.parent;
        //p节点没有父节点，则指向根节点
        if (p.parent == null)
           root = replacement;
        //如果p为左孩子，如果p为左孩子，则将p.parent.left = p.left
        else if (p == p.parent.left)
            p.parent.left  = replacement;
        else
            p.parent.right = replacement;
 
        //删除p节点到左右分支，和父节点的引用
        p.left = p.right = p.parent = null;
 
        // Fix replacement
        if (p.color == BLACK)
            //恢复颜色分配
            fixAfterDeletion(replacement);
    } else if (p.parent == null) { // return if we are the only node.
        //红黑书中父节点为空的只能是根节点。
        root = null;
    } else { //  No children. Use self as phantom replacement and unlink.
        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;
        }
    }
}

 

 entrySet()遍历

class EntrySet extends AbstractSet<Map.Entry<K,V>> {
        public Iterator<Map.Entry<K,V>> iterator() {
            return new EntryIterator(getFirstEntry());
        }
final class EntryIterator extends PrivateEntryIterator<Map.Entry<K,V>> {
        EntryIterator(Entry<K,V> first) {
            super(first);
        }
        public Map.Entry<K,V> next() {
            return nextEntry();
        }
    }

 其他方法

  • firstEntry() 返回Map中最小的key
  • higherEntry(Object key ) 返回该Map中位于key后一位的key-value
  • lowerEntry(Object key ) 返回该Map中唯一key前一位的key-value
  • tailMap(Object key , boolean inclusive) 返回该Map的子Map

BigHong123
关注
Java集合之TreeMap总结
再见时光的博客
03-27 1910
TreeMap 的总结写的比较简单，关于红黑树是可以写很长的篇幅的。但是这篇博客只是描述 TreeMap 的特性和使用场景，它就是红黑树实现的，要了解实现原理只有先去百度了解红黑树是什么，结合 TreeMap 的源码看是怎么实现的，才能理解。
红黑树TreeMap总结
brycegao321的博客
12-30 526
   红黑树是自平衡的二叉查找树，又称二叉B树。它可以在O(logN)时间复杂度内完成查找、增加、删除操作。红黑树是在二叉查找树基础上增加了着色和左右旋转使得红黑树相对平衡， 与AVL树相比，红黑树并不追求所有子树的高度差不超过1，而是保证从根节点到叶子节点的最长路径不超过最短路径的2倍。红黑树通过如下性质实现了自平衡： 1. 节点必须是黑色或红色； 2.根节点必须是黑色； 3.所有NIL节...
Java集合TreeMap用法总结
雪雪
01-03 2008
Java的TreeMap是集合框架中的一个实现类，TreeMap继承了AbstractMap。 TreeMap实现了NavigableMap接口，提供了多种方便的查找功能； TreeMap实现了Cloneable接口，可以克隆； TreeMap实现了Serialiable接口，可以序列化。 构造方法 TreeMap() 创建一个空的TreeMap，并且按照key的自然升序排序； TreeMa...
ConcurrentHashMap，hashMap，TreeMap全总结（不看后悔哦）
mmxgl的博客
03-15 556
JDK8中的HashMap与JDK7的HashMap有什么不一样？ JDK8中新增了红黑树，JDK8是通过数组+链表+红黑树来实现的 JDK7中链表的插入是用的头插法，而JDK8中则改为了尾插法 JDK8中的因为使用了红黑树保证了插入和查询了效率，所以实际上JDK8中的Hash算法实现的复杂度降低了 JDK8中数组扩容的条件也发了变化，只会判断是否当前元素个数是否超过了阈值，而不再判断当前put进来的元素对应的数组下标位置是否有值。 JDK7中是先扩容再添加新元素，JDK8中是先添加新元素然后再扩容 Ha
java HashMap,TreeMap与LinkedHashMap的详解
09-01
总结起来，`HashMap`适合于对顺序无要求且需要高效查找的场景；`TreeMap`适用于需要排序的Map，例如根据键的自然顺序或自定义比较器；而`LinkedHashMap`则在需要保持元素插入或访问顺序时发挥作用。选择哪种Map实现...
TreeMap源码阅读总结
weixin_37731688的博客
03-04 144
TreeMap结构和特性 TreeMap结构：是由排序二叉树存储数据的，继承自AbstractMap，实现了如下接口。 NavigableMap, Cloneable, java.io.Serializable 特性：存储的数据是有序的，插入和删除都需要进行调整（有可能进行树的旋转）
关于 TreeMap 和 HashMap 的去重操作
qq_38823937的博客
09-14 401
HashMap HashMap中对于 Key 的去重是根据hashCode 和 equals 实现的 示例代码 /** * @author wu */ public class Main { public static void main(String[] args) { Map<Example, String> map = new HashMap<>(); Example test1 = new Example(1, "wu");
TreeMap<K,V>类以及LinkedList<E>
11-25
7_4.有集合A={1,2,3,4}和B={1,3,7,9,11}，编写一个应用程序输出A和B交集、并集和差集 7_5.有10个硬盘，有两个重要的属性：价格和容量。编写一个应用程序，使用TreeMap<K,V>类，分别按照价格和容量排序并输出10个硬盘的详细信息 9_5.编写一个应用程序，要求将LinkedList<E>创建的对象写入到文件，然后读出一个LinkedList<E>对象，并遍历LinkedList<E>节点中的数据
TreeMap是如何实现去重和排序的
czx2018的博客
07-18 6230
TreeMap实现了SortedMap接口，它是一个key有序的Map类。 TreeMap的默认排序规则 TreeMap并不是根据插入的顺序来排序，而是根据key元素的 compareTo 方法来排序。 测试代码： Map<Integer, Object> map = new TreeMap<>(); map.put(5, new Object()); map.put(10, new Object()); map.put(8, new Object()); map.put(12, n
TreeSet和TreeMap不能存放重复元素？能不能存放null?其实不是这样的——灵活的二叉树
热门推荐
u010698072的博客
02-16 1万+
问题一：本来认为TreeMap不能存放重复元素？其实并非如此； 其实一般情况下是不允许存放重复元素的，但是它并非这么死板，在一些情况下是可以存放重复元素的，存了又会有引入其他问题。 问题二：能不能存放null呢？正常情况下是不能的，会报异常，但是经过一些处理后是可以的。 解答问题一： 1、存放元素时，TreeMap实现外部比较器接口Comparator，并重写其compare方法，当判断元素
TreeMap<K,V>的使用
whaleluo的博客
05-11 2079
类 TreeMap public class TreeMap extends AbstractMapimplements NavigableMap, Cloneable, Serializable  基于红黑树（Red-Black tree）的 NavigableMap 实现。  该映射根据其键的自然顺序进行排序，  或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用
java treemap用法_JAVA作业，使用TreeMap<K,V>类
weixin_30647853的博客
02-24 266
展开全部importjava.util.ArrayList;importjava.util.Iterator;importjava.util.List;importjava.util.Map;importjava.util.TreeMap;importjava.util.Map.Entry;publicclassTest{publicstaticvoidmain(Strin...
重复Key：value数据排序后去重，TreeMap,List.sort()
weixin_43671743的博客
08-20 398
领导要求整理一批source修改记录，主要是记录修改的源文件+修改时间+文件在工程中的目录 。首先从类似禅道的web站获取数据（根据日期履历复制到本地），然后找出文件的最终修改时间。主要时间消耗在按日期复制修改文件履历上面。主要难点在于后期数据去重，对被修改文件的最新时间获取。 起初想着一条一条在excel上面人工检索核对，大概有四个月的数据，不停的搜索然后去重就可以了。比较费劲，懒惰是程序员的优良品质，想到重复工作还是写个方法吧。 数据类似 ：目录–>时间形式，键值对形式直接使用map处理，目录文件
Set : 无序的 不可重复 HashSet: TreeSet: Map: HashMap TreeMap Collections: Properties :
sun_yi_wen的博客
07-20 263
List ：有序的,可重复的 新增了一些根据索引操作的方法 ArrayList Vector LinkedList Set : 无序的 不可重复 新增功能: static <E> Set<E> of(E... elements) 返回包含任意数量元素的不可修改集。 其他方法从Collection继承 遍历方式: foreach iterator 注意: 存放数.
使用TreeMap减少重复代码
步行者的专栏
09-05 2408
  TreeMap是基于红黑树（Red-Black tree）的 NavigableMap 实现。该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。    此实现为 containsKey、get、put 和 remove 操作提供受保证的 log
Java中TreeMap、TreeSet存储对象和ArrayList.sort()的对象需要实现equals方法吗
ZZXN的博客
04-11 341
不需要，只需实现Comparable或者传入Comparator即可，但是这样是不好的，除非是局部临时使用，应当避免。 不需要的原因是TreeMap、TreeSet、ArrayList.sort()都只是用compareTo()方法，而不会使用equals()和hashcode()方法。特别地，ArrayList.sort()内部使用的是Arrays.sort()，而Arrays.sort()对于...
treemap有序存储
最新发布
07-27
Treemap是一种有序存储的数据结构，它基于红黑树实现。红黑树是一种自平衡的二叉搜索树，它保持了节点的有序性，并且具有较好的性能。 在Treemap中，每个节点包含一个键值对，键用于进行排序，值则是所存储的数据。Treemap根据键的比较结果来确定节点的位置，较小的键位于左子树，较大的键位于右子树。这样就保证了Treemap中的所有节点按照键的顺序排列。 通过这种有序存储方式，Treemap可以高效地支持一些操作，例如插入、删除和查找等。由于红黑树的平衡性质，这些操作的时间复杂度为O(log n)，其中n是Treemap中存储的键值对数量。 总结起来，Treemap是一种有序存储的数据结构，通过红黑树实现，可以高效地支持插入、删除和查找等操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值