treemap是java中基于红黑树实现的有序映射，能按键的自然顺序或自定义comparator自动排序，适用于需要键有序的场景，其插入、删除和查找操作的时间复杂度为o(log n)；与hashmap（无序，基于哈希表，平均时间复杂度o(1)）和linkedhashmap（保持插入顺序，基于哈希表加链表）不同，treemap的优势在于有序性，适合范围查询和按序遍历；在并发环境下，treemap本身非线程安全，可通过collections.synchronizedsortedmap进行包装或使用concurrentskiplistmap来实现线程安全，后者在高并发场景下性能更优。
Java集合框架中，
TreeMap
是一个非常实用的实现，它能自动根据键的自然顺序或者你指定的
Comparator
来对键值对进行排序。简单来说，当你需要一个总是保持键有序的映射表时，
TreeMap
就是你的首选，它底层基于红黑树实现，确保了插入、删除和查找操作的平均时间复杂度为O(log n)。
TreeMap
的使用其实非常直观，它继承自
AbstractMap
并实现了
SortedMap
接口，这意味着它天然就具备了排序能力。最常见的用法就是直接创建实例并往里面
put
数据。
import java.util.Comparator; import java.util.Map; import java.util.TreeMap; // 示例1: 使用键的自然顺序 public class TreeMapBasicUsage { public static void main(String[] args) { // 创建一个TreeMap，键（Integer）会按自然顺序（升序）排列 Map<Integer, String> studentScores = new TreeMap<>(); studentScores.put(95, "张三"); studentScores.put(88, "李四"); studentScores.put(72, "王五"); studentScores.put(95, "赵六"); // 键相同会覆盖值 System.out.println("按分数升序排列的学生："); for (Map.Entry<Integer, String> entry : studentScores.entrySet()) { System.out.println("分数: " + entry.getKey() + ", 姓名: " + entry.getValue()); } // 示例2: 使用自定义Comparator进行降序排序 // 如果我们想让分数从高到低排列，就需要提供一个Comparator Map<Integer, String> studentScoresDesc = new TreeMap<>(Comparator.reverseOrder()); studentScoresDesc.put(95, "张三"); studentScoresDesc.put(88, "李四"); studentScoresDesc.put(72, "王五"); System.out.println("n按分数降序排列的学生："); for (Map.Entry<Integer, String> entry : studentScoresDesc.entrySet()) { System.out.println("分数: " + entry.getKey() + ", 姓名: " + entry.getValue()); } // 获取特定键的值 System.out.println("n分数95的学生是: " + studentScores.get(95)); // 输出：赵六 // 移除一个键值对 studentScores.remove(72); System.out.println("n移除分数72后的学生列表："); for (Map.Entry<Integer, String> entry : studentScores.entrySet()) { System.out.println("分数: " + entry.getKey() + ", 姓名: " + entry.getValue()); } } }
可以看到，
TreeMap
在存入数据时就完成了排序，遍历时直接就是有序的，这省去了我们手动排序的麻烦，尤其是在处理需要有序集合的业务场景时，比如排行榜、时间轴事件等，简直是神器。
立即学习“Java免费学习笔记（深入）”；
自定义排序：TreeMap如何使用Comparator接口？
很多时候，键的自然顺序（比如数字的升序、字符串的字典序）并不能满足我们的需求。比如，我们可能想让分数从高到低排列，或者根据一个自定义对象的某个特定属性来排序。这时候，
Comparator
接口就派上用场了。
Comparator
是一个函数式接口，它定义了一个
compare(T o1, T o2)
方法，用于比较两个对象。当你创建
TreeMap
时，可以通过构造函数传入一个
Comparator
实例，告诉
TreeMap
应该如何比较键。如果你不传入
Comparator
，那么
TreeMap
就会尝试使用键的自然顺序，这就要求键的类型必须实现
Comparable
接口。
在我看来，
Comparator
的灵活性是
TreeMap
强大之处的关键。你可以为同一个类定义多种排序规则，或者对那些没有实现
Comparable
接口的类进行排序。
import java.util.Comparator; import java.util.Map; import java.util.TreeMap; class MyObject { String name; int value; public MyObject(String name, int value) { this.name = name; this.value = value; } @Override public String toString() { return "{" + name + ", " + value + "}"; } } public class TreeMapCustomComparator { public static void main(String[] args) { // 自定义Comparator：根据MyObject的value属性降序排序 Comparator<MyObject> myObjectComparator = new Comparator<MyObject>() { @Override public int compare(MyObject o1, MyObject o2) { // 注意：如果想降序，o2.value - o1.value // 如果想升序，o1.value - o2.value return Integer.compare(o2.value, o1.value); } }; Map<MyObject, String> customSortedMap = new TreeMap<>(myObjectComparator); customSortedMap.put(new MyObject("A", 10), "数据A"); customSortedMap.put(new MyObject("B", 50), "数据B"); customSortedMap.put(new MyObject("C", 20), "数据C"); customSortedMap.put(new MyObject("D", 50), "数据D"); // 注意：如果Comparator认为键相等，会覆盖 System.out.println("按MyObject的value降序排列的Map："); for (Map.Entry<MyObject, String> entry : customSortedMap.entrySet()) { System.out.println("键: " + entry.getKey() + ", 值: " + entry.getValue()); } // 另一个例子：按字符串长度排序（升序） Map<String, Integer> stringLengthMap = new TreeMap<>(Comparator.comparingInt(String::length)); stringLengthMap.put("apple", 5); stringLengthMap.put("banana", 6); stringLengthMap.put("cat", 3); stringLengthMap.put("dog", 3); // 注意：如果长度相同，会按字典序排，因为Comparator.comparingInt只比较了长度 System.out.println("n按字符串长度升序排列的Map："); for (Map.Entry<String, Integer> entry : stringLengthMap.entrySet()) { System.out.println("键: " + entry.getKey() + ", 值: " + entry.getValue()); } } }
在
Comparator
中，如果
compare
方法返回0，
TreeMap
会认为这两个键是相等的，新插入的键值对会覆盖旧的。这一点在设计自定义排序时非常重要，因为这直接影响到
TreeMap
中是否能存储“逻辑上相等但物理上不同”的键。
TreeMap与HashMap、LinkedHashMap有什么区别？
在Java集合框架的Map家族里，
TreeMap
、
HashMap
和
LinkedHashMap
是最常用的三兄弟，但它们各有侧重，解决的问题也不尽相同。理解它们之间的差异，能帮助我们更明智地选择合适的工具。
-
HashMap
: 这是最基础、最常用的Map实现。它的特点是无序，不保证元素的顺序。底层基于哈希表实现，通过哈希码来快速定位键值对。在理想情况下（哈希冲突少），它的
put
、
get
、
remove
操作的平均时间复杂度是O(1)，效率非常高。它适用于那些对元素顺序没有要求，只追求快速存取数据的场景。但如果哈希冲突严重，性能会下降。
-
LinkedHashMap
: 顾名思义，它在
HashMap
的基础上增加了链表结构，维护了元素的插入顺序。也就是说，当你遍历
LinkedHashMap
时，元素的顺序和你插入它们的顺序是一致的。它依然基于哈希表提供O(1)的平均存取速度，同时兼顾了顺序性。它常用于实现LRU（最近最少使用）缓存，或者需要保持插入顺序的配置项。
-
TreeMap
: 就像我们前面说的，
TreeMap
的杀手锏是有序。它底层使用红黑树（一种自平衡二叉查找树）来实现，所以它能保证键总是处于排序状态。无论是自然顺序还是自定义顺序，
TreeMap
都能做到。但这种有序性是有代价的：
put
、
get
、
remove
操作的时间复杂度是O(log n)，比
HashMap
的O(1)要慢一些。它最适合那些需要对键进行范围查询、查找最大/最小键，或者需要按特定顺序遍历所有键值对的场景。比如，你想获取一个分数段内的所有学生，或者按字母顺序显示所有商品。
选择哪个Map，很大程度上取决于你对数据顺序的需求。如果顺序不重要，
HashMap
通常是最佳选择。如果需要保持插入顺序，
LinkedHashMap
是首选。而如果数据必须按键排序，并且你经常需要进行范围查询或获取有序数据，那么
TreeMap
无疑是王者。我个人在处理日志分析或者需要按时间戳排序的事件时，就经常会倾向于使用
TreeMap
。
TreeMap在并发环境下的考量与线程安全性
谈到集合框架，尤其是在多线程环境中，线程安全性是一个绕不开的话题。对于
TreeMap
来说，答案很明确：
TreeMap
本身不是线程安全的。这意味着，如果在多个线程同时对一个
TreeMap
实例进行修改操作（如
put
、
remove
），就可能导致数据不一致、结构损坏甚至程序崩溃。
这是因为
TreeMap
的底层红黑树结构在进行插入或删除操作时，会涉及复杂的节点旋转和颜色调整，这些操作如果不同步，就可能出现竞态条件。比如，一个线程正在调整树的结构，另一个线程同时读取或写入，就可能读到不完整或错误的数据，或者破坏了树的平衡性，导致后续操作出错。
那么，在并发环境下，我们如何安全地使用类似
TreeMap
的功能呢？
-
外部同步: 最简单直接的方式是使用
Collections.synchronizedSortedMap()
方法包装你的
TreeMap
。它会返回一个线程安全的
SortedMap
视图，所有对这个视图的操作都会被内部的同步锁保护起来。
import java.util.Collections; import java.util.Map; import java.util.SortedMap; import java.util.TreeMap; // ... 在多线程中使用 SortedMap<Integer, String> syncTreeMap = Collections.synchronizedSortedMap(new TreeMap<>()); // 现在对syncTreeMap的所有操作都是线程安全的
这种方式虽然简单，但同步粒度较大，每次操作都需要获取锁，在高并发场景下可能会成为性能瓶颈。
-
使用并发集合: Java的
java.util.concurrent
包提供了更高级、更细粒度的并发集合实现。对于需要有序键的场景，
ConcurrentSkipListMap
是一个非常好的选择。它是一个基于跳表（Skip List）实现的并发
SortedMap
，提供了与
TreeMap
类似的有序功能，但在并发性能上远超
Collections.synchronizedSortedMap()
包装的
TreeMap
。
import java.util.concurrent.ConcurrentSkipListMap; import java.util.concurrent.ConcurrentMap; // ... 在多线程中使用 ConcurrentMap<Integer, String> concurrentTreeMap = new ConcurrentSkipListMap<>(); // concurrentTreeMap现在是线程安全的，并且并发性能更优
ConcurrentSkipListMap
通过非阻塞算法（CAS操作）实现并发控制，允许多个读操作并行进行，并且在写操作时也能保持较高的并发度。在实际开发中，如果你的应用对并发性能有较高要求，并且需要一个有序的Map，那么
ConcurrentSkipListMap
通常是比同步
TreeMap
更好的选择。
总结来说，虽然
TreeMap
本身不具备线程安全性，但Java提供了成熟的解决方案。选择哪种方案，取决于你的具体需求和对性能的考量。在低并发场景下，外部同步可能足够；而在高并发、对性能要求严苛的系统中，
ConcurrentSkipListMap
无疑是更专业的选择。
评论（已关闭）
评论已关闭