java-collections-map——面题
Map
Map常用子类
- HashMap：HashMap 是最常用的 Map 实现之一，它基于哈希表实现，提供了 O(1) 时间复杂度的插入、删除和查找操作。
- Hashtable：Hashtable 是较早期的 Java 集合类，它是线程安全的，但性能通常比 HashMap 差，因为它的方法是同步的。
- TreeMap：TreeMap 是基于红黑树实现的有序 Map，它根据键的自然顺序或自定义顺序进行排序。TreeMap 提供了一些附加的方法来处理有序映射。
- LinkedHashMap：LinkedHashMap 继承自 HashMap，它使用双向链表维护插入顺序或者访问顺序，因此迭代顺序可以预测。
- ConcurrentHashMap：ConcurrentHashMap是Hashtable替代，相比性能较好，线程安全，无序。
- ConcurrentSkipListMap：线程安全，有序。
扩展：还有其他子类比如ConcurrentHashMap、WeakHashMap、IdentityHashMap、EnumMap...
EnumMap 是针对枚举类型的特定实现，它的键必须是枚举类型的值。
HashMap
/**
* hashMap_demo
* HashMap：非线程安全的 Map 实现
* 数据结构：数组 + 链表 + （1.8加的红黑树）
* 遍历顺序：无序
* 是否线程安全：线程不安全
* 扩容机制： 当HashMap容量大小(默认16)达到容量的加载因子的大小(默认0.75)自动扩容两倍
* 最大容量：2^30 - 1 (即 1,073,741,823)
* null值操作：允许使用一个 null 键，多个 null 值
*/
@Test
public void hashMap_demo() {
HashMap<String,String> hashMap = new HashMap<>(16, 0.75f);
for (int i = 1; i <= 3; i++) {
hashMap.put("test"+i,"test");
}
hashMap.put(null,"test");
for (Map.Entry<String, String> entry : hashMap.entrySet()) {
System.out.print(" Key: " + entry.getKey());
}
}
执行打印
Key: null Key: test2 Key: test3 Key: test1
Hashtable
/**
* hashtable_demo
* Hashtable：线程安全无序的 Map 实现
* 实现方式：数组 + 链表
* 遍历顺序：无序
* 是否线程安全：线程安全，所有公共方法都是同步的 synchronization 多线程环境中，当一个线程正在修改 Hashtable 时，其他线程进入等待。
* 扩容机制： 当HashMap容量大小(默认11)达到容量的加载因子的大小(默认0.75)自动扩容两倍
* null值操作：不允许使用 null 键或 null 值
*/
@Test
public void hashtable_demo() {
Hashtable<String,String> hashtable = new Hashtable<>(11, 0.75f);
for (int i = 1; i <= 3; i++) {
hashtable.put("test"+i,"test");
}
//hashtable.put(null,"test");//键设置为null 抛出java.lang.NullPointerException
for (Map.Entry<String, String> entry : hashtable.entrySet()) {
System.out.print(" Key: " + entry.getKey());
}
}
执行打印
Key: test2 Key: test3 Key: test1
TreeMap
/**
* treeMap_demo
* TreeMap 线程安全有序 Map 实现
* 实现方式：基于红黑树数据结构
* 遍历顺序：默认键顺序按照自然顺序来排序，也可以重写compare方法自定义排序逻辑
* 是否线程安全：线程安全
* 扩容机制： 基于红黑树，没有扩容机制
*/
@Test
public void treeMap_demo() {
//TreeMap<String,String> treeMap = new TreeMap<>();//默认键顺序按照自然顺序来排序
TreeMap<String,String> treeMap = new TreeMap<>(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
//return o1.compareTo(o2); // 默认自然顺序
return o2.length() - o1.length(); // 使用自定义逻辑 例如，根据字符串长度倒序排序
}
});
treeMap.put("az2","test");
treeMap.put("nam3","test");
treeMap.put("mapf4","test");
for (Map.Entry<String, String> entry : treeMap.entrySet()) {
System.out.print(" Key: " + entry.getKey());
}
}
执行打印
Key: mapf4 Key: nam3 Key: az2
LinkedHashMap
/**
* linkedHashMap_demo
* LinkedHashMap：非线程安全无序 Map 实现，继承 HashMap
* 实现方式：哈希表 + 双向链表
* 是否线程安全：线程不安全
* 遍历顺序：当元素添加时位置到链表末尾，遍历时，按照插入的顺序返回
* 设置访问顺序参数策略： 默认是false，设置为true的是如果有get或put操作，将被操作的元素追加到链表的末尾，顺序排后
* 扩容机制：与 HashMap 相同
*/
@Test
public void linkedHashMap_demo(){
//设置顺序方式 默认是false
LinkedHashMap<String,String> linkedHashMap = new LinkedHashMap<>(16, 0.75f, false);
//LinkedHashMap<String,String> linkedHashMap = new LinkedHashMap<>(16, 0.75f, true);
for (int i = 1; i <= 3; i++) {
linkedHashMap.put("test"+i,"test");
}
// 默认按照插入顺序，遍历所有的键和值
for (Map.Entry<String, String> entry : linkedHashMap.entrySet()) {
System.out.print(" Key: " + entry.getKey());
}
System.out.println("\n --------------");
linkedHashMap.put("test0","test");
linkedHashMap.get("test1");
for (Map.Entry<String, String> entry : linkedHashMap.entrySet()) {
System.out.print(" Key: " + entry.getKey());
}
}
执行打印
1.设置为false的结果：
Key: test1 Key: test2 Key: test3
//--------------
Key: test1 Key: test2 Key: test3 Key: test0
2.设置为true的结果：
Key: test1 Key: test2 Key: test3
//--------------
Key: test2 Key: test3 Key: test0 Key: test1
ConcurrentHashMap
/**
* concurrentHashMap_demo
* ConcurrentHashMap：线程安全无序 Map 实现
* 实现方式：数组 + 链表 + 红黑树
* 是否线程安全：线程安全 1.8开始使用 CAS 操作和循环来保证对数据的修改是线程安全的，之前使用分段锁。
* 遍历顺序：无序
* 扩容机制：与 HashMap 相同
*/
@Test
public void concurrentHashMap_demo(){
ConcurrentHashMap<String,String> concurrentHashMap = new ConcurrentHashMap<>(16, 0.75f);
for (int i = 1; i <= 3; i++) {
concurrentHashMap.put("test"+i,"test");
}
for (Map.Entry<String, String> entry : concurrentHashMap.entrySet()) {
System.out.print(" Key: " + entry.getKey());
}
}
执行打印
Key: test2 Key: test3 Key: test1
ConcurrentSkipListMap
/**
* concurrentSkipListMap_demo
* ConcurrentSkipListMap：线程安全有序 Map 实现
* 实现方式：基于跳表（Skip List）数据结构,提供了有序集合的快速查找、插入和删除操作。
* 是否线程安全：线程安全
* 遍历顺序：有序
* 顺序机制：默认键顺序按照自然顺序来排序，也可以重写compare方法自定义排序逻辑
* 扩容机制：ConcurrentSkipListMap 不是一个动态扩容的数据结构，而是由用户根据需要手动进行扩容的。
*/
@Test
public void concurrentSkipListMap_demo() throws InterruptedException {
// ConcurrentSkipListMap<String,String> concurrentSkipListMap = new ConcurrentSkipListMap<>();
ConcurrentSkipListMap<Integer, String> concurrentSkipListMap = new ConcurrentSkipListMap<>(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
System.out.print("o1:"+o1 +" o2:"+o2+"\n");
// 定义比较逻辑
// return o1.compareTo(o2);
return Integer.compare(o2,o1);//倒序
}
});
for (int i = 1; i <= 3; i++) {
concurrentSkipListMap.put( i,"test");
}
for (Map.Entry<Integer, String> entry : concurrentSkipListMap.entrySet()) {
System.out.print(" Key: " + entry.getKey());
}
}
执行打印
o1:2 o2:1
o1:3 o2:2
Key: 3 Key: 2 Key: 1
