JDK容器与并发—Map—TreeMap

最新推荐文章于 2024-07-04 16:30:50 发布
最新推荐文章于 2024-07-04 16:30:50 发布
阅读量937 收藏
点赞数
分类专栏： JDK容器与并发 文章标签： jdk 容器 TreeMap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Architect0719/article/details/51154300
版权

概述

      基于红黑树的NavigableMap，非线程安全。

1）containsKey、get、put、remove操作的时间复杂度为log(n)；

2）迭代器fail-fast。

数据结构

      红黑树：

private transient Entry<K,V> root = null; // 根节点

// tree节点
static final class Entry<K,V> implements Map.Entry<K,V> {
	K key;
	V value;
	Entry<K,V> left = null;
	Entry<K,V> right = null;
	Entry<K,V> parent;
	boolean color = BLACK;

	/**
	 * Make a new cell with given key, value, and parent, and with
	 * {@code null} child links, and BLACK color.
	 */
	Entry(K key, V value, Entry<K,V> parent) {
		this.key = key;
		this.value = value;
		this.parent = parent;
	}

	/**
	 * Returns the key.
	 *
	 * @return the key
	 */
	public K getKey() {
		return key;
	}

	/**
	 * Returns the value associated with the key.
	 *
	 * @return the value associated with the key
	 */
	public V getValue() {
		return value;
	}

	/**
	 * Replaces the value currently associated with the key with the given
	 * value.
	 *
	 * @return the value associated with the key before this method was
	 *         called
	 */
	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;
	}
}

构造器

// 无参构造
public TreeMap() {
	comparator = null;
}

// 带comparator构造
public TreeMap(Comparator<? super K> comparator) {
	this.comparator = comparator;
}

// 带Map构造
public TreeMap(Map<? extends K, ? extends V> m) {
	comparator = null;
	putAll(m);
}

// 带SortedMap构造
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) {
	}
}

增删改查

基础方法

// 根据key排序，获取第一个Entry
// TreeMap为空则返回null
final Entry<K,V> getFirstEntry() {
	Entry<K,V> p = root; // 从根节点开始
	if (p != null)
		while (p.left != null)
			p = p.left; // 一直往左子树找
	return p;
}

// 根据key排序，获取最后一个Entry
// TreeMap为空则返回null
final Entry<K,V> getLastEntry() {
	Entry<K,V> p = root;
	if (p != null)
		while (p.right != null)
			p = p.right;
	return p;
}

// 获取key关联的Entry，没有则返回null
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();
	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;
}

// 获取>=key最小的Enntry
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;
}

// 获取<=key最大的Enntry
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;
}

// 获取>key最小的Enntry
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;
}

// 获取<key最大的Enntry
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;
}

// 将Entry封装成不可变的SimpleImmutableEntry
static <K,V> Map.Entry<K,V> exportEntry(TreeMap.Entry<K,V> e) {
	return (e == null) ? null :
		new AbstractMap.SimpleImmutableEntry<>(e);
}

// 查找指定Entry的后继节点
static <K,V> TreeMap.Entry<K,V> successor(Entry<K,V> t) {
	if (t == null)
		return null;
	else if (t.right != null) {
		Entry<K,V> p = t.right;
		while (p.left != null)
			p = p.left;
		return p;
	} else {
		Entry<K,V> p = t.parent;
		Entry<K,V> ch = t;
		while (p != null && ch == p.right) {
			ch = p;
			p = p.parent;
		}
		return p;
	}
}

// 查找指定Entry的前驱节点
static <K,V> Entry<K,V> predecessor(Entry<K,V> t) {
	if (t == null)
		return null;
	else if (t.left != null) {
		Entry<K,V> p = t.left;
		while (p.right != null)
			p = p.right;
		return p;
	} else {
		Entry<K,V> p = t.parent;
		Entry<K,V> ch = t;
		while (p != null && ch == p.left) {
			ch = p;
			p = p.parent;
		}
		return p;
	}
}


private static <K,V> boolean colorOf(Entry<K,V> p) {
	return (p == null ? BLACK : p.color);
}

private static <K,V> Entry<K,V> parentOf(Entry<K,V> p) {
	return (p == null ? null: p.parent);
}

private static <K,V> void setColor(Entry<K,V> p, boolean c) {
	if (p != null)
		p.color = c;
}

private static <K,V> Entry<K,V> leftOf(Entry<K,V> p) {
	return (p == null) ? null: p.left;
}

private static <K,V> Entry<K,V> rightOf(Entry<K,V> p) {
	return (p == null) ? null: p.right;
}

// 左旋转
private void rotateLeft(Entry<K,V> p) {
	if (p != null) {
		Entry<K,V> r = p.right;
		p.right = r.left;
		if (r.left != null)
			r.left.parent = p;
		r.parent = p.parent;
		if (p.parent == null)
			root = r;
		else if (p.parent.left == p)
			p.parent.left = r;
		else
			p.parent.right = r;
		r.left = p;
		p.parent = r;
	}
}

// 右旋转
private void rotateRight(Entry<K,V> p) {
	if (p != null) {
		Entry<K,V> l = p.left;
		p.left = l.right;
		if (l.right != null) l.right.parent = p;
		l.parent = p.parent;
		if (p.parent == null)
			root = l;
		else if (p.parent.right == p)
			p.parent.right = l;
		else p.parent.left = l;
		l.right = p;
		p.parent = l;
	}
}

增、改

      步骤：
1）从root节点开始，基于key的排序比较，进行查找；
2）若已存在相等key的键值对节点，则替换新的value，返回旧value；
3）否则，根据key、value创建新节点，将其添加到TreeMap中来；
4）因有新节点添加，所以需保持红黑树平衡。

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();
		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);
	}
	// 根据key、value创建新节点，添加到TreeMap中来
	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;
}

private void fixAfterInsertion(Entry<K,V> x) {
	x.color = RED;

	while (x != null && x != root && x.parent.color == RED) {
		if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {
			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 = parentOf(parentOf(x));
			} else {
				if (x == rightOf(parentOf(x))) {
					x = parentOf(x);
					rotateLeft(x);
				}
				setColor(parentOf(x), BLACK);
				setColor(parentOf(parentOf(x)), RED);
				rotateRight(parentOf(parentOf(x)));
			}
		} else {
			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;
}

删

步骤：
1）从root节点开始，基于key的排序比较，进行查找；
2）若不存在相等key关联的键值对节点，则返回null；
3）否则，删除相等key关联的键值对节点；
4）保持红黑树平衡；
5）返回旧value。

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

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

/**
 * Delete node p, and then rebalance the tree.
 */
private void deleteEntry(Entry<K,V> p) {
	modCount++;
	size--;

	// If strictly internal, copy successor's element to p and then make p
	// point to successor.
	if (p.left != null && p.right != null) {
		Entry<K,V> s = successor(p);
		p.key = s.key;
		p.value = s.value;
		p = s;
	} // p has 2 children

	// Start fixup at replacement node, if it exists.
	Entry<K,V> replacement = (p.left != null ? p.left : p.right);

	if (replacement != null) {
		// Link replacement to parent
		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;

		// Null out links so they are OK to use by fixAfterDeletion.
		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;
		}
	}
}

private void fixAfterDeletion(Entry<K,V> x) {
	while (x != root && colorOf(x) == BLACK) {
		if (x == leftOf(parentOf(x))) {
			Entry<K,V> sib = rightOf(parentOf(x));

			if (colorOf(sib) == RED) {
				setColor(sib, BLACK);
				setColor(parentOf(x), RED);
				rotateLeft(parentOf(x));
				sib = rightOf(parentOf(x));
			}

			if (colorOf(leftOf(sib))  == BLACK &&
				colorOf(rightOf(sib)) == BLACK) {
				setColor(sib, RED);
				x = parentOf(x);
			} else {
				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
			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);
}

查

步骤：
1）从root节点开始，基于key的排序比较，进行查找；
2）若不存在相等key关联的键值对节点，则返回null；
3）否则，相等key关联的键值对节点的value。

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

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

迭代器

      PrivateEntryIterator为基础迭代器：

abstract class PrivateEntryIterator<T> implements Iterator<T> {
	Entry<K,V> next;
	Entry<K,V> lastReturned;
	int expectedModCount;

	PrivateEntryIterator(Entry<K,V> first) {
		expectedModCount = modCount;
		lastReturned = null;
		next = first;
	}

	public final boolean hasNext() {
		return next != null;
	}

	final Entry<K,V> nextEntry() {
		Entry<K,V> e = next;
		if (e == null)
			throw new NoSuchElementException();
		if (modCount != expectedModCount)
			throw new ConcurrentModificationException();
		next = successor(e);
		lastReturned = e;
		return e;
	}

	final Entry<K,V> prevEntry() {
		Entry<K,V> e = next;
		if (e == null)
			throw new NoSuchElementException();
		if (modCount != expectedModCount)
			throw new ConcurrentModificationException();
		next = predecessor(e);
		lastReturned = e;
		return e;
	}

	public void remove() {
		if (lastReturned == null)
			throw new IllegalStateException();
		if (modCount != expectedModCount)
			throw new ConcurrentModificationException();
		// deleted entries are replaced by their successors
		if (lastReturned.left != null && lastReturned.right != null)
			next = lastReturned;
		deleteEntry(lastReturned);
		expectedModCount = modCount;
		lastReturned = null;
	}
}

特性

      基于红黑树的特性，实现log(n)的快速查找，当然付出的成本就是需要更大的内存空间。

Architect0719
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
并发中的Map容器
wolfcode_cn的博客
10-10 349
本文作者：王一飞，叩丁狼高级讲师。原创文章，转载请注明出处。   上几篇讨论了并发环境下list容器的操作, 本篇我们来聊下另外一个集合容器:Map 家族体系 Map:以key-value对的形式存在,一种数据结构,一个key, 映射一个value值, map中不能包含重复的key值, 一个key最多只能映射到一个值。 常用方法有: 添加: V put(K key, V value); 删除...
JDK容器类Map源码解读
一个无限死循环的博客
07-29 130
java.util.Map接口是JDK1.2开始提供的一个基于键值对的散列表接口，其设计的初衷是为了替换JDK1.0中的java.util.Dictionary抽象类。Dictionary是JDK最初的键值对类，它不可以存储null作为key和value，目前这个类早已不被使用了。目前都是在使用Map接口，它是可以存储null值作为key和value，但Map的key是不可以重复的。其常用的实现类...
Java里多个Map的性能比较（TreeMap、HashMap、ConcurrentSkipListMap）
12-30
比较Java原生的 3种Map的效率。 1. TreeMap 2. HashMap 3. ConcurrentSkipListMap 本测试查找方法使用Map的get方法，循环、离散获取。对于ConcurrentSkipListMap，获得顺序片段，可用subMap()方法，提取50w的子序列只需要1ms，具有巨大优势。 SkipListMap的范围查询效率比HashMap和TreeMap效率都要高。
splay tree java,Java中TreeMap的并发修改
weixin_39800971的博客
02-21 142
I have following container in C++:std::unordered_map::iterator> Container;Somewhere in my code I use this container to quickly access elements in std::map container, and I can concurrently modify t...
【JDK源码】TreeMap
最新发布
2401_85406000的博客
07-04 361
1、看视频进行系统学习这几年的Crud经历，让我明白自己真的算是菜鸡中的战斗机，也正因为Crud，导致自己技术比较零散，也不够深入不够系统，所以重新进行学习是很有必要的。我差的是系统知识，差的结构框架和思路，所以通过视频来学习，效果更好，也更全面。关于视频学习，个人可以推荐去B站进行学习，B站上有很多学习视频，唯一的缺点就是免费的容易过时。2、读源码，看实战笔记，学习大神思路“编程语言是程序员的表达的方式，而架构是程序员对世界的认知”。所以，程序员要想快速认知并学习架构，读源码是必不可少的。
java并发(十八)——HashMap、TreeMap、ConcurrentHashMap、ConcurrentSkipListMap
hxyascx的博客
01-02 643
HashMap 下面来看下HashMap的主要两种存储方式是示意图： 这就是java8的HashMap的数据结构，跟之前版本不一样的是当table达到一定的阀值时，bucket就会由链表转换为红黑树的方式进行存储，下面会做具体的源码分析。 Node 自JDK1.8.0开始HashMap使用静态内部类Node来存储键值对结构, 不再使用Map.Entry: static class Node&lt...
java中treemap_Java TreeMap – Java中的TreeMap
从零开始的教程世界
07-07 419
java中treemapJava TreeMap is one of the Map implementation and it’s part of Java Collections framework. Java TreeMap是Map实现之一，它是Java Collections框架的一部分。 Java TreeMap (Java TreeMap) Some of the importa...
高并发第九弹:逃不掉的Map --> HashMap,TreeMap,ConcurrentHashMap
weixin_30471065的博客
09-21 110
平时大家都会经常使用到 Map,面试的时候又经常会遇到问Map的,其中主要就是ConcurrentHashMap,在说ConcurrentHashMap.我们还是先看一下, 其他两个基础的 Map 类: HashMap 和 TreeMap HashMap: public class HashMap<K,V> extends AbstractMap<K,V&gt...
并发编程之并发容器（Map、List、Set）实战及其原理
2201_75955594的博客
05-07 403
并发容器原理
JDK11源码学习01 | Map接口
gdut_yy的博客
10-24 595
JDK11源码学习01 | Map接口 package java.util; import java.util.function.BiConsumer; import java.util.function.BiFunction; import java.util.function.Function; import java.io.Serializable; /** * An object t...
阿里三面，讲讲不同场景下并发 Map 容器最优使用。凉凉送给自己
m0_69804655的博客
03-21 111
跳跃表是基于链表扩展实现的一种特殊链表，类似于树的实现，跳跃表不仅实现了横向链表，还实现了垂直方向的分层索引。一个跳跃表由若干层链表组成，每一层都实现了一个有序链表索引，只有最底层包含了所有数据，每一层由下往上依次通过一个指针指向上层相同值的元素，每层数据依次减少，等到了最顶层就只会保留部分数据了。跳跃表的这种结构，是利用了空间换时间的方法来提高了查询效率。程序总是从最顶层开始查询访问，通过判断元素值来缩小查询范围。我们通过以下图文信息来了解下跳跃表的具体实现原理。
TreeMap的put方法
qq_34579060的博客
06-27 2629
TreeMap通过put()和deleteEntry()实现红黑树的增加和删除节点操作 新增节点前提： 需要调整的节点总是红色的 如果插入新节点的父节点是黑色的，无须调整 如果插入新节点的父节点是红色的，因为红黑树规定不能出现相邻的两个红色节点，所以 进入循环判断，或重新着色，或左右旋转，最终达到红黑树的约束条件 退出条件如下： while （x != null &&am...
【原创】Java并发编程系列03 | 重排序-可见性和有序性问题根源
Java进阶架构师
10-02 243
点击上方“java进阶架构师”，选择右上角“置顶公众号”20大进阶架构专题每日送达思维导图写在前面 并发编程的三大问题：原子性、可见性、有序性。缓存不能及时刷新导致了可见...
TreeMap源码分析-java8
iCoding91
03-23 411
1.特征分析 TreeMap是基于NavigableMap的红黑树的实现。 默认排序方式：对key升序排序。 TreeMap是非线程同步的。 支持浅拷贝，序列化 红黑树put节点时，分有无比较器分开讨论，这主要是从性能角度考虑的。 代理模式：定义在subMap中的方法，将其行为委托给了NavigableMap来实现，代理模式的使用,消除了需要对Iterator方法进行类型检...
TreeMap的put之后底层经历了什么（个人经验总结）
当时只道是平常
12-04 4690
一：TreeMap的实现就是红黑树的实现，红黑树的五点特质： 1、每个节点都只能是红色或者黑色 2、根节点是黑色 3、每个叶节点（NIL节点，空节点）是黑色的。 4、如果一个结点是红的，则它两个子节点都是黑的。也就是说在一条路径上不能出现相邻的两个红色结点。 5、从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。 二：以下五种情况涵盖了绝大部分的新增可能，不管这棵红黑树多么复杂...
基于JDK TreeMap分析树的后继结点查询算法
iwts
02-13 1414
只要理解二叉搜索树，就能看懂这个方法了。注释为： Returns the successor of the specified Entry, or null if no such. 就是说返回当前结点的后继结点。然而TreeMap底层是红黑树谈何后继结点？这个方法最早出现是在containsValue方法中。也就是传入一个Value，判定是否存在。也就是说我们需要遍历整个...
TreeMap方法successor/predecessor图解
dengjili的专栏
01-23 1960
方法功能介绍 TreeMap遍历算法属于二叉排序树范畴 二叉树：https://blog.csdn.net/dengjili/article/details/111350037 二叉排序树参考：https://blog.csdn.net/dengjili/article/details/111503799 根据二叉树前序遍历，假设遍历结果为，a、b、c、d；当前节点为c 那么前驱节点为b；后驱节点为d 对应方法分别如下 successor，寻找当前节点后驱节点 predecessor，寻找当前节点前驱
TreeMap
My Blog
08-24 782
TreeMap 是 SortedMap 的子类，所以它具有排序功能。
JAVA基础（八）TreeMap
Coder Wang
05-08 269
eee
尚硅谷大厂面试题精华：Java Map实现与并发编程详解
在尚硅谷大厂面试题第二季的Java后端开发面试题库中，博主精心整理了关于HashMap、LinkedHashMap、HashTable、ConcurrentHashMap和TreeMap这五种Java基础集合类的深入讲解和实战应用。HashMap作为主要实现类，以其...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值