Java-01-源码篇-04集合-04-SortedMap & NavigableMap & TreeMap

土司先生

已于 2024-07-09 23:38:08 修改

阅读量628

点赞数 16

分类专栏： java SE 17 源码篇文章标签： java python 开发语言

于 2024-07-08 05:45:55 首次发布

本文链接：https://blog.csdn.net/qq_45281820/article/details/140256679

版权

java SE 17 源码篇专栏收录该内容

16 篇文章 1 订阅

订阅专栏

3.4.5.1 PrivateEntryIterator 迭代器

3.4.5.2 ValueIterator 迭代器

3.4.5.3 KeyIterator 迭代器

3.4.5.4 EntryIterator 迭代器

3.4.5.5 DescendingKeyIterator 倒排 key 迭代器

3.4.6 相关子集Map

3.4.7 相关分割器

3.4.8 Entry 映射实体类（红黑树节点）

3.5 TreeMap 新增业务

3.5.1 put(key, value)

3.5.2 putIfAbsent(key, value)

3.5.3 put(key, value, replaceOld)

3.5.4 addEntryToEmptyMap(key, value)

3.5.5 addEntry(key, value, parent, addToLeft)

3.8 TreeMap的 NavigableMap 的 lowerEntry(key)

2.9 TreeMap 与 HashMap 区别

一，SortedMap

SortedMap 是 Java 中 Map 接口的一个子接口，它提供一些额外的方法来处理有序的简直对映射。SortedMap 保证键以自然顺序或指定的比较器顺序排序。其接口方法源码如下：

package java.util;

/**
 * @since 1.2
 */
public interface SortedMap<K,V> extends Map<K,V> {
    /** 用于对键进行排序的比较器。如果使用键的自然顺序进行排序，则返回 null */
    Comparator<? super K> comparator();

    /** 
     * 获取一个子映射[fromKey, toKey)，用于处理特定范围的键值对 
     * @param fromKey    
     * @param toKey     
     */
    SortedMap<K,V> subMap(K fromKey, K toKey);

    /**
     * 获取所有键小于 toKey 值的子映射
     */
    SortedMap<K,V> headMap(K toKey);

    /**
     * 获取所有键大于等于 fromKey值 的子映射
     */
    SortedMap<K,V> tailMap(K fromKey);
    
    /** 返回当前映射中第一个（最小的）键。 */
    K firstKey();

    /** 返回当前映射中最后一个（最大的）键 */
    K lastKey();

    /** 返回一个包含此映射中所有键的 Set 视图。集合中的键按照升序排列 */
    Set<K> keySet();

    /** 返回一个包含此映射中所有值的 Collection 视图。集合中的值按照对应键的升序排列。*/
    Collection<V> values();

    /** 返回一个包含此映射中所有键值对的 Set 视图。集合中的条目按照键的升序排列 */
    Set<Map.Entry<K, V>> entrySet();
}

SortedMap 提供了一些用于处理有序键值对映射的额外方法，这些方法允许你获取子映射、获取特定范围的映射，以及按顺序访问键、值和键值对。

二，`NavigableMap`

NavigableMap 是 Java 集合框架中的一个接口，扩展了 SortedMap 接口，提供了导航方法来检索按顺序映射的键及其关联的值。它允许更灵活地处理键和值，并提供了查找最接近的匹配项的方法。

NavigableMap 主要用于处理有序键值对，并提供了额外的导航方法，例如获取最接近的键，逆向视图等。与 SortedMap 不同， NavigableMap 提供了更丰富的方法集，使得更加灵活的操作有序映射。其接口源码如下：

package java.util;

/**
 * @author Doug Lea
 * @author Josh Bloch
 * @param <K> the type of keys maintained by this map
 * @param <V> the type of mapped values
 * @since 1.6
 */
public interface NavigableMap<K,V> extends SortedMap<K,V> {
    /************************** 基本导航方法 **************************/
    /**
     * 查找 小于 指定键的最大键值的键值对映射，如果没有返回 null
     * @param key the key
     * @return 
     * @throws ClassCastException
     * @throws NullPointerException
     */
    Map.Entry<K,V> lowerEntry(K key);

    /**
     * 查找 小于 指定键的最大键值，如果没有返回 null
     *
     * @param key the key
     * @throws ClassCastException
     * @throws NullPointerException
     */
    K lowerKey(K key);

    /**
     * 查找 小于或等于 指定键的最大键值对，如果没有返回 null
     *
     * @param key the key
     * @throws ClassCastException 
     * @throws NullPointerException
     */
    Map.Entry<K,V> floorEntry(K key);

    /**
     * 查找 小于或等于 指定键的最大键
     *
     * @param key the key
     * @throws ClassCastException 
     * @throws NullPointerException
     */
    K floorKey(K key);

    /**
     * 查找 大于或等于 指定键的最小键值对，如果没有返回null
     *
     * @param key the key
     * @throws ClassCastException 
     * @throws NullPointerException
     */
    Map.Entry<K,V> ceilingEntry(K key);

    /**
     * 查找 大于或等于 指定键的最小键。
     *
     * @param key the key
     * @throws ClassCastException 
     * @throws NullPointerException
     */
    K ceilingKey(K key);

    /**
     * 查找 大于 指定键的最小键值对。
     *
     * @param key the key
     * @throws ClassCastException
     * @throws NullPointerException 
     */
    Map.Entry<K,V> higherEntry(K key);

    /**
     * 查找 大于 指定键的最小键
     *
     * @param key the key
     * @throws ClassCastException 
     * @throws NullPointerException 
     */
    K higherKey(K key);

    /************************** 最小和最大方法 **************************/
    /**
     * 获取映射中的第一个键值对
     * @return 返回映射中的第一个（键的最小）键值映射，或返回 null 如果映射为空
     */
    Map.Entry<K,V> firstEntry();

    /**
     * 返回映射中的最后一个（键的最大）键值映射，或返回 null 如果映射为空。
     * @return 获取映射中的最后一个键值对
     */
    Map.Entry<K,V> lastEntry();

    /**
     * 移除并返回映射中的第一个（键的最小）键值映射，或返回 null 如果映射为空
     * 简单理解：删除并返回映射中的第一个键值对。
     */
    Map.Entry<K,V> pollFirstEntry();

    /**
     * 移除并返回映射中的最后一个（键的最大）键值映射，或返回 null 如果映射为空。
     * 简单理解：删除并返回映射中的最后一个键值对
     */
    Map.Entry<K,V> pollLastEntry();

    /************************** 视图操作 **************************/
    /** 获取映射的键按逆序排列的视图。 */
    NavigableMap<K,V> descendingMap();

    /** 获取所有键的 NavigableSet 视图 */
    NavigableSet<K> navigableKeySet();

    /** 获取所有键的逆序 NavigableSet 视图 */
    NavigableSet<K> descendingKeySet();

    /************************** 子映射操作 **************************/
    /**
     * 返回键在 fromKey 到 toKey 范围内的子映射，是否包含边界由 fromInclusive 和 toInclusive 决定。
     * @param fromKey 子映射集合的起点
     * @param fromInclusive 子映射是否包含起点 true - 包含 | false - 不包含
     * @param toKey high 子映射集合的终点
     * @param toInclusive 子映射是否包含终点 true - 包含 | false - 不包含
     * @throws ClassCastException 
     * @throws NullPointerException 
     * @throws IllegalArgumentException 
     */
    NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive,
                             K toKey,   boolean toInclusive);

    /**
     * 返回键小于（或等于，如果 inclusive 为 true）toKey 的子映射
     * @param toKey 子映射集合的终点
     * @param inclusive 子映射是否包含终点 true - 包含 | false - 不包含
     * @throws ClassCastException
     * @throws NullPointerException
     * @throws IllegalArgumentException
     */
    NavigableMap<K,V> headMap(K toKey, boolean inclusive);

    /**
     * 返回键大于（或等于，如果 inclusive 为 true）fromKey 的子映射
     * @param fromKey 子映射集合的起点
     * @param inclusive 子映射是否包含起点 true - 包含 | false - 不包含
     * @throws ClassCastException 
     * @throws NullPointerException 
     * @throws IllegalArgumentException
     */
    NavigableMap<K,V> tailMap(K fromKey, boolean inclusive);

    /************************** SortedMap 兼容方法 **************************/
    /**
     * 等价于 subMap(fromKey, true, toKey, false)
     * @throws ClassCastException       {@inheritDoc}
     * @throws NullPointerException     {@inheritDoc}
     * @throws IllegalArgumentException {@inheritDoc}
     */
    SortedMap<K,V> subMap(K fromKey, K toKey);

    /**
     * 等价于 headMap(toKey, false)
     * @throws ClassCastException       {@inheritDoc}
     * @throws NullPointerException     {@inheritDoc}
     * @throws IllegalArgumentException {@inheritDoc}
     */
    SortedMap<K,V> headMap(K toKey);

    /**
     * 等价于 tailMap(fromKey, true)
     * @throws ClassCastException       {@inheritDoc}
     * @throws NullPointerException     {@inheritDoc}
     * @throws IllegalArgumentException {@inheritDoc}
     */
    SortedMap<K,V> tailMap(K fromKey);
}

NavigableMap 的这些方法使得对有序映射的操作更加灵活和方便，可以轻松实现查找、子集和导航等操作。Java 中的 TreeMap 是 NavigableMap 接口的一个常见实现

三，TreeMap

TreeMap 是 NavigableMap 的子类，并且是一颗通过红黑树实现 NavigableMap。

3.1 TreeMap 继承结构

package java.util;
public class TreeMap<K,V>
    extends AbstractMap<K,V>
    implements NavigableMap<K,V>, Cloneable, java.io.Serializable
{/** 忽略代码 */}

3.2 TreeMap 属性

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

    /** 比较器，用于 key 排序 */
    @SuppressWarnings("serial")
    private final Comparator<? super K> comparator;

    /** TreeMap 的根节点，毕竟是一颗红黑树 */
    private transient Entry<K,V> root;

    /** 当前 TreeMap 的元素数量大小 */
    private transient int size = 0;

    /** 当前集合修改次数 */
    private transient int modCount = 0;

    /** 忽略其他代码 */
}

3.3 TreeMap 构造器

【无参构造】默认指定比较器，默认使用key的自然排序

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

【单参构造】指定SortedMap 元素集进行构造，并且直接使用 SortedMap的比较器

    public TreeMap(SortedMap<K, ? extends V> m) {
        comparator = m.comparator();
        try {
            buildFromSorted(m.size(), m.entrySet().iterator(), null, null);
        } catch (java.io.IOException | ClassNotFoundException cannotHappen) {
        }
    }

3.4 TreeMap 内部类

3.4.1 Values

Values 是 TreeMap 中所有 value 的视图集合。

3.4.2 KeySet

KeySet 是 TreeMap 中所有 key 的视图集合，类型为 Set 集合，原因是 key 是不允许有重复的；该类还实现NavigableSet 意味着同样丰富的导航视图方法

3.4.3 EntrySet

key 有对应的视图，value 也有对应的视图，剩下就是key-value 的映射键值对没有对应的视图，所以EntrySet 就是 TreeMap 中所有映射键值对的视图集合。但是 TreeMap 本身就不是一个映射键值对的集合吗？为什么其内部还要在追加一个 EntrySet 视图集合？？？ EntrySet 视图集合的重点在于视图，一般视图都是重点在可读，也就是在迭代，查询等业务中使用到的。有一些特殊情况，也会提高一两个写的方法。比如下面的删除。

3.4.5 相关集合迭代器

3.4.5.1 PrivateEntryIterator 迭代器

privateEntryIterator 迭代器，是 TreeMap 所有迭代器的基类。

3.4.5.2 ValueIterator 迭代器

value 的迭代器，直接逐个迭代到最后一个为止

3.4.5.3 KeyIterator 迭代器

3.4.5.4 EntryIterator 迭代器

3.4.5.5 DescendingKeyIterator 倒排 key 迭代器

3.4.6 相关子集Map

3.4.7 相关分割器

3.4.8 Entry 映射实体类（红黑树节点）

    static final class Entry<K,V> implements Map.Entry<K,V> {
        K key; // key 真正元素
        V value; // 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) {
            return o instanceof Map.Entry<?, ?> e
                    && 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;
        }
    }

3.5 TreeMap 新增业务

3.5.1 put(key, value)

新增的key-value键值对，键值冲突进行替换旧键值

    public V put(K key, V value) {
        return put(key, value, true);
    }

3.5.2 putIfAbsent(key, value)

新增的key-value键值对，键值冲突不替换旧键值

    @Override
    public V putIfAbsent(K key, V value) {
        return put(key, value, false);
    }

3.5.3 put(key, value, replaceOld)

新增的key-value键值对,键值冲突替换不替换旧键值由replaceOld决定

/**
 *
 * @param key   要新增的key
 * @param value 要新增的value
 * @param replaceOld 是否替换旧的值 true - 替换 | false - 不替换
 */
private V put(K key, V value, boolean replaceOld) {
        Entry<K,V> t = root;
        // 如果树是空的（即根节点为 null），则调用 addEntryToEmptyMap 方法插入第一个节点，并返回 null
        if (t == null) {
            addEntryToEmptyMap(key, value);
            return null;
        }
        
        int cmp; // 比较结果
        Entry<K,V> parent; // 父节点
        // cpr：比较器，如果有提供比较器，则使用它进行键的比较；否则，使用键的自然顺序进行比较。
        Comparator<? super K> cpr = comparator;
        if (cpr != null) { // 使用比较器
            do {
                parent = t;
                // 使用提供的比较器 cpr 进行键的比较
                cmp = cpr.compare(key, t.key);
                // 循环遍历树，比较当前键与节点键的大小，决定向左还是向右子树移动。
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                // 如果找到相同的键，根据 replaceOld 参数决定是否替换旧值，并返回旧值
                else {
                    V oldValue = t.value;
                    if (replaceOld || oldValue == null) {
                        t.value = value;
                    }
                    return oldValue;
                }
            } while (t != null);
        } else { // 否则使用自然排序比较
            Objects.requireNonNull(key);
            @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;
                // 如果找到相同的键，根据 replaceOld 参数决定是否替换旧值，并返回旧值
                else {
                    V oldValue = t.value;
                    if (replaceOld || oldValue == null) {
                        t.value = value;
                    }
                    return oldValue;
                }
            } while (t != null);
        }
        // 如果没有找到相同的键，在遍历结束后，根据比较结果 (cmp < 0) 决定新节点插入到父节点的左子树或右子树中。
        addEntry(key, value, parent, cmp < 0);
        return null; // 调用 addEntry 方法进行插入，并返回 null
    }

3.5.4 addEntryToEmptyMap(key, value)

addEntryToEmptyMap 方法在 TreeMap 为空时用于添加第一个节点（即根节点）。这是一个私有方法，只在 TreeMap 内部使用。

    private void addEntryToEmptyMap(K key, V value) {
        compare(key, key); // 目的是对键进行类型检查，并确保键非空
        root = new Entry<>(key, value, null);
        // 更新树的大小和修改计数
        size = 1;
        modCount++;
    }

3.5.5 addEntry(key, value, parent, addToLeft)

    /**
     * 新增新的Entry
     * @param key    要插入的key
     * @param value  要插入的value
     * @param parent 新节点的父节点
     * @param addToLeft 新节点是否应该作为父节点的左子节点
     */
    private void addEntry(K key, V value, Entry<K, V> parent, boolean addToLeft) {
        // 将数据封装成一个Entry节点类
        Entry<K,V> e = new Entry<>(key, value, parent);
        if (addToLeft) // 如果该节点是父节点的左子节点则加在左边
            parent.left = e;
        else // 否则是右子节点
            parent.right = e;
        /*
         * 调用 fixAfterInsertion 方法，以确保插入新节点后树仍然满足红黑树的性质
         * fixAfterInsertion 方法会调整节点的颜色和位置，以保持树的平衡性。
         */
        fixAfterInsertion(e);
        // 更新树的大小和修改计数
        size++;
        modCount++;
    }

3.6 TreeMap 删除业务

3.6.1 remove(key)

根据 key 进行删除 Entry 映射实体类

    public V remove(Object key) {
        Entry<K,V> p = getEntry(key);
        if (p == null)
            return null;

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

3.6.2 deleteEntry(e)

deleteEntry 方法用于从 TreeMap 中删除一个节点。该方法需要确保在删除节点后，树仍然保持红黑树的性质

    private void deleteEntry(Entry<K,V> p) {
        // 1. 更新修改计数和大小
        modCount++; // 增加 modCount 以记录对树结构的修改次数
        size--; // 减少 size，因为我们将删除一个节点

        // 2. 处理有两个子节点的节点
        if (p.left != null && p.right != null) {
            // 如果节点 p 有两个子节点，则找到它的后继节点 s
            Entry<K,V> s = successor(p);
            // 将后继节点 s 的键和值复制到节点 p
            p.key = s.key;
            p.value = s.value;
            // 将 p 更新为后继节点 s，以便在后续步骤中删除 s
            p = s;
        }


        /*
         * 3. 找到替换节点:如果 p 有左子节点，则 replacement 为 p 的左子节点。
         * 否则，如果 p 有右子节点，则 replacement 为 p 的右子节点。
         */
        Entry<K,V> replacement = (p.left != null ? p.left : p.right);

        if (replacement != null) { 
            // 3.1 如果替换节点存在，首先将其父节点指向 p 的父节点
            replacement.parent = p.parent;
            // 3.2 如果 p 是根节点，则将 root 设置为替换节点
            if (p.parent == null)
                root = replacement;
            // 3.3 否则，将替换节点链接到 p 的父节点（作为左子节点或右子节点）
            else if (p == p.parent.left)
                p.parent.left  = replacement;
            else
                p.parent.right = replacement;

            // 3.4 将 p 的左右子节点和父节点都置为 null
            p.left = p.right = p.parent = null;

            // 3.5 如果 p 的颜色是黑色，则调用 fixAfterDeletion 方法修复红黑树的性质。
            if (p.color == BLACK)
                fixAfterDeletion(replacement);
        // p 没有替换节点且是根节点的情况
        } else if (p.parent == null) { 
            root = null; // 如果 p 没有子节点且是根节点，则将 root 设置为 null。

        
        } else { // p 没有替换节点且不是根节点的情况
            // 如果 p 没有子节点且不是根节点，首先检查 p 的颜色。
            // 如果 p 的颜色是黑色，则调用 fixAfterDeletion 方法修复红黑树的性质。
            if (p.color == BLACK)
                fixAfterDeletion(p);

            // 将 p 从父节点的左子节点或右子节点中移除，并将 p 的父节点置为 null。
            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;
            }
        }
    }

3.7 TreeMap 查询业务

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

3.8 TreeMap的 NavigableMap 的 lowerEntry(key)

    public Map.Entry<K,V> lowerEntry(K key) {
        return exportEntry(getLowerEntry(key));
    }

    final Entry<K,V> getLowerEntry(K key) {
        Entry<K,V> p = root;
        // 进行循环比较
        while (p != null) {
            int cmp = compare(key, p.key);
            // key 和 p 比较  大于0 则key在 p 的右边
            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;
    }

其他的相关导航方法也都是类似。

2.9 TreeMap 与 HashMap 区别

1. 底层数据结构

TreeMap:
- 底层使用红黑树（Red-Black Tree）实现。
HashMap:
- 底层使用哈希表（Hash Table）实现。

2. 排序

TreeMap:
- 维护键的自然顺序（或者通过提供的 Comparator 进行排序）。
- 迭代时，元素是按升序排列的。
HashMap:
- 不保证顺序，键值对的顺序是不可预测的。

3. 性能

TreeMap:
- 插入、删除和查找操作的时间复杂度为 O(log⁡n)O(\log n)O(logn)。
HashMap:
- 插入、删除和查找操作的平均时间复杂度为 O(1)O(1)O(1)，但在最坏情况下为 O(n)O(n)O(n)（例如所有键都碰撞在同一个桶中）。

4. 空间复杂度

TreeMap:
- 相对来说空间开销较大，因为需要维护红黑树的结构。
HashMap:
- 空间利用率较高，因为哈希表通常只存储键值对和少量的元数据。

5. null 值

TreeMap:
- 不允许 null 键，但允许 null 值。
HashMap:
- 允许 null 键和 null 值。

6. 使用场景

TreeMap:
- 适用于需要键有序的情况，例如需要按顺序遍历键值对，或者需要范围查找（如子集、头部集或尾部集）。
HashMap:
- 适用于对顺序没有要求的情况，只需快速插入、删除和查找操作。

感谢各位花时间阅读这篇关于 TreeMap 博客文章。我希望这些内容对你所有帮助，如果你有任何问题或者想法，欢迎在评论区与toast小编同学分析一下，小编同学非常期待你们的反馈。

下一篇文章是：ConcurrentHashMap 集合相关的内容。内容比较多，可能会分两三章进行讲解。欢迎各位关注toast小编的博客。

土司先生

关注

16
点赞
踩
13

收藏

觉得还不错? 一键收藏
0
评论
Java-01-源码篇-04集合-04-SortedMap & NavigableMap & TreeMap

key 有对应的视图，value 也有对应的视图，剩下就是key-value 的映射键值对没有对应的视图，所以EntrySet 就是 TreeMap 中所有映射键值对的视图集合。EntrySet 视图集合的重点在于视图，一般视图都是重点在可读，也就是在迭代，查询等业务中使用到的。SortedMap 是 Java 中 Map 接口的一个子接口，它提供一些额外的方法来处理有序的简直对映射。提供了一些用于处理有序键值对映射的额外方法，这些方法允许你获取子映射、获取特定范围的映射，以及按顺序访问键、值和键值对。
复制链接

扫一扫