12.Java集合框架_Map接口
Map接口
特点
- Map用于保存具有映射关系的数据:key-value(双列元素)。
- Map中的key和value可以是任何引用类型的数据,会封装到HashMap$Node对象中。
- Map中的Key不允许重复,原因和HashSet一样,当有相同的key时,等价于替换。
- Map中的value可以重复。
- Map的key可以为null,value也可以为null,注意key为null的只能有一个。
- 常用String类作为Map的key,因为String类重写了HashCode()和equals()。具体情况具体分析可以使用任意类型。
- key和value之间存在单向一对一关系,即通过指定的key总能找到对应的value。
- Map存放数据的key-value示意图,一对k-v是放在一个Node中的,又因为Node实现了Entry接口,有些书上也说,一对k-v是一个Entry。
代码示例
import java.util.HashMap;
public class HashMapDemo {
public static void main(String[] args) {
HashMap map = new HashMap();
map.put("no1", "Kobe"); //OK
map.put("no2", "James"); //OK
System.out.println(map); //{no2=James, no1=Kobe}
map.put("no1", "Curry"); //当有相同的key时,等价于替换
System.out.println(map); //{no2=James, no1=Curry}
map.put("no3", "Curry"); //value可以相同
System.out.println(map); //{no2=James, no1=Curry, no3=Curry}
map.put(null, null); //OK
map.put(null, "Duck"); //等价于替换
map.put("no4", null); //OK
System.out.println(map); //{no2=James, null=Duck, no1=Curry, no4=null, no3=Curry}
map.put(23, "Jordon"); //OK
map.put(new Object(), "Paul"); //OK
System.out.println(map); //{no2=James, null=Duck, no1=Curry, no4=null, no3=Curry, java.lang.Object@515f550a=Paul, 23=Jordon}
//通过get方法,传入key,返回对应的value
System.out.println(map.get(23)); //Jordon
}
}
Map中的EntrySet
帮助理解Map的第8个特点(Map中只有Entry内部类,EntrySet 、KeySet、Values是其实现类HashMap中的内部类):
- k-v最后是HashMap$Node node = newNode(hash, key, value, null);
- k-v为了方便程序员的遍历,还会创建EntrySet集合,该集合存放的元素的类型Entry,而一个Entry对象就有k,v 即: transient Set<Map.Entry<K,V>> entrySet;
- 在entrySet中,定义的类型是Map.Entry ,但是实际上存放的还是HashMap$Node,这是因为HashMap$Node implements Map.Entry
- 这样当把HashMap$Node对象存放在 EntrySet ,就方便我们的遍历 ,因为Map.Entry提供了重要方法
K getKey(); V getValue();
,Node对象没有这两个方法。
代码:
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
//Map中的EntrySet
public class HashMapDemo {
public static void main(String[] args) {
HashMap map = new HashMap();
map.put("no1", "Kobe"); //k-v
map.put("no2", "Jack"); //k-v
//K getKey(); V getValue();
Set entrySet = map.entrySet();
System.out.println(entrySet.getClass()); //class java.util.HashMap$EntrySet
for (Object object : entrySet) {
System.out.print(object + " ");
} //no2=Jack no1=Kobe
System.out.println();
for (Object object : entrySet) {
//为了从HashMap$Node中取出k-v
//1.先做一个向下转型
Map.Entry entry = (Map.Entry) object;
System.out.println("key:" + entry.getKey() + " - value:" + entry.getValue());
}
/*
输出结果:
key:no2 - value:Jack
key:no1 - value:Kobe
*/
Set keySet = map.keySet();
System.out.println(keySet.getClass()); //class java.util.HashMap$KeySet
System.out.println(keySet); //[no2, no1]
Collection values = map.values();
System.out.println(values.getClass()); //class java.util.HashMap$Values
System.out.println(values); //[Jack, Kobe]
}
}
Map接口常用方法
- put:添加
- remove:根据键删除映射关系
- get:根据键获取值
- size:获取元素个数
- isEmpty:判断个数是否为0
- clear:清除
- containsKey:查找键是否存在
- containsValue:查找值是否存在
代码:
import java.util.HashMap;
//Map接口常用方法
public class HashMapDemo {
public static void main(String[] args) {
//1.put方法 返回key原先对应的value
HashMap map = new HashMap();
System.out.println(map.put("no1", "Kobe")); //null
System.out.println(map.put("no2", "Jack")); //null
System.out.println(map.put("Curry", null)); //null
System.out.println(map.put(null, "林黛玉")); //null
System.out.println(map.put(null, null)); //林黛玉(替换)
System.out.println(map); //{no2=Jack, Curry=null, null=null, no1=Kobe}
//2.remove(key) 返回key对应的value
//remove(key,value) 返回是否成功
System.out.println(map.remove("Curry")); //null
System.out.println(map.remove("no2", "Curry")); //false
System.out.println(map); //{no2=Jack, null=null, no1=Kobe}
//3.get(key) 返回key对应的value
System.out.println(map.get("no1")); //Kobe
//4.size 返回集合的元素个数
System.out.println(map.size()); //3
//5.isEmpty 判断集合的元素个数是否为0
System.out.println(map.isEmpty()); //false
//6.clear 清除集合中的所有元素
map.clear();
System.out.println(map); //{}
//7.constainKey(key) 判断集合中key是否存在
System.out.println(map.containsKey("java")); //false
map.put("java", "no1");
System.out.println(map.containsKey("java")); //true
//8.constainValue(value) 判断集合中value是否存在
System.out.println(map.containsValue("no1")); //true
map.put("java", "no2");
System.out.println(map.containsValue("no1")); //false
}
}
遍历方式
取k-v对:四种
取值:两种
import java.util.*;
//HashMap遍历方式
public class HashMapDemo {
public static void main(String[] args) {
HashMap map = new HashMap();
map.put("no1", "林黛玉");
map.put("no2", "孙悟空");
map.put("no3", "刘玄德");
map.put("no4", "宋公明");
System.out.println(map); //{no2=孙悟空, no1=林黛玉, no4=宋公明, no3=刘玄德}
//遍历方式
//1.先取出所有key,通过key取key-value
Set keySet = map.keySet();
//1.1 增强for循环
System.out.println("=====第一种方式=====");
for (Object key : keySet) {
System.out.println(key + ":" + map.get(key));
}
//1.2 迭代器
System.out.println("=====第二种方式=====");
Iterator iterator = keySet.iterator();
while (iterator.hasNext()) {
Object key = iterator.next();
System.out.println(key + ":" + map.get(key));
}
//2.把所有的value取出
Collection values = map.values();
//2.1 增强for循环
System.out.println("=====第三种方式=====");
values.forEach(System.out::println);
//2.2 迭代器
System.out.println("=====第四种方式=====");
Iterator iterator1 = values.iterator();
while (iterator1.hasNext()) {
Object next = iterator1.next();
System.out.println(next);
}
//3.通过EntrySet来获取k-v
Set entrySet = map.entrySet();
//3.1 增强for
System.out.println("=====第五种方式=====");
for (Object entry : entrySet) {
//转换为Map.Entry对象
Map.Entry entry1 = (Map.Entry) entry;
System.out.println(entry1.getKey() + ":" + entry1.getValue());
}
//3.2 迭代器
System.out.println("=====第六种方式=====");
Iterator iterator2 = entrySet.iterator();
while (iterator2.hasNext()) {
Object next = iterator2.next();
System.out.println(next.getClass()); //class java.util.HashMap$Node
Map.Entry entry2 = (Map.Entry) next;
System.out.println(entry2.getKey() + ":" + entry2.getValue());
}
}
}
HashMap
特点
- Map接口的常用实现类:HashMap、Hashtable和Properties。
- HashMap是Map接口使用频率最高的实现类。
- HashMap是以key-value对的方式来存储数据(HashMap$Node类型)。
- Key不能重复,但是值可以重复,允许使用null键和null值。
- 如果添加相同的key,则会覆盖原来的key-value,等同于修改(key不会替换,value会替换)。
- 与HashSet一样,不保证映射的顺序,因为底层是以hash表的方式来存储的。(数组+链表+红黑树)
- HashMap没有实现同步,因此是线程不安全的,方法上没有做同步互斥操作,没有synchronized。
底层机制
- (k,v)是一个Node实现了Map.Entry<K,V>,查看HashMap的源码可以看到。
- jdk7.0的HashMap底层实现【数组+链表】,jdk8.0的HashMap底层实现【数组+链表+红黑树】。
扩容机制
HashSet的底层就是HashMap,所以两者的扩容机制相同。
- HashMap底层维护了Node类型的数组table,默认为null。
- 当创建对象时,将加载因子(loadfactor)初始化为0.75。
- 当添加 key-value时,通过key的哈希值得到在table的索引。然后判断该索引处是否有元素,如果没有元素直接添加。如果该索引处有元素,继续判断该元素的key是否和准备加入的key相同,如果相等,则直接替换value;如果不相等需要判断是树结构还是链表,做出相应处理。如果添加时发现容量不够,则需扩容。
- 第一次添加,则需要扩容table容量为16,临界值(threshold)为12 (16 *0.75)。
- 以后再扩容,则需要扩容table容量为原来的2倍,临界值为原来的2倍,即24,依次类推。
- 在Java8种,如果一条链表的元素个数超过 TREEIFY_THRESHOLD(默认是8),并且table的大小 >= MIN_TREEIEF_CAPACITY(默认是64),就会进行树化(红黑树)。
put()源码分析
import java.util.HashMap;
//HashMap put()方法的源码分析
public class HashMapDemo05 {
public static void main(String[] args) {
HashMap hashMap = new HashMap();
hashMap.put("java", 10);
hashMap.put("php", 20);
hashMap.put("java", 30);
System.out.println("hashMap:"+hashMap); //hashMap:{java=30, php=20}
/*
源码分析
1.执行构造器 new HashMap()
初始化加载因子this.loadFactor = DEFAULT_LOAD_FACTOR;//0.75
HashMap$Node[] table = null;
2. 执行put 调用hash方法,计算key的hash值() (h = key.hashCode()) ^ (h >>> 16);
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
3.执行putVal
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
// 定义辅助变量 tab、p、n、i
Node<K,V>[] tab; Node<K,V> p; int n, i;
// table 是hashMap的一个属性,类型是Node[] 存放 node节点的数组
// 如果 table为null或者大小为0,执行resize()方法,table第一次扩容16个空间
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 取出hash值对应的table的索引位置的Node,如果为null,就直接把加入的k-v,创建成一个Node,加入该位置
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
// 如果 table的索引位置的key的hash和新的key的hash相同,
// 并且满足(table现有的节点的key和准备添加的可以是同一个对象) 或者 equals返回真
// 就认为不能加入新的 k-v
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode) // 如果当前table的node已经是红黑树,就按照红黑树的方式处理
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
// 如果找到的节点,后面是链表,就循环比较
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) { // 如果整个链表,没有和他相同的,就加在该链表后
p.next = newNode(hash, key, value, null);
// 判断当前链表个数是否已经到8个,到8个后,进行红黑树的树化
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
//如果table为null,或者大小还没有到64,暂时不树化,而是进行扩容
break;
}
if (e.hash == hash && // 如果在循环比较过程种,如果有相同的,就直接break
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
// 替换 value
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
// 操作次数,每增加一个Node,就size++
++modCount;
// 判断是否需要扩容,threshold为扩容操作临界值,默认为12,tab超过12执行扩容
if (++size > threshold)
resize();
//空方法,是HashMap 给其子类留的 让其子类执行一些操作
afterNodeInsertion(evict);
// 放回 null,代表成功
return null;
}
4. 关于树化(转成红黑树)
//如果table为null,或者大小还没有到64,暂时不树化,而是进行扩容
//否则才会真正的树化 -> 剪枝
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode<K,V> hd = null, tl = null;
do {
TreeNode<K,V> p = replacementTreeNode(e, null);
if (tl == null)
hd = p;
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
if ((tab[index] = hd) != null)
hd.treeify(tab);
}
}
*/
}
}
resize()源码分析
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
//如果原table不为空
if (oldCap > 0) {
//如果原容量已经达到最大容量了,无法进行扩容,直接返回
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//设置新容量为旧容量的两倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//阈值也变为原来的两倍
newThr = oldThr << 1; // double threshold
}
/**
* 从构造方法我们可以知道
* 如果没有指定initialCapacity, 则不会给threshold赋值, 该值被初始化为0
* 如果指定了initialCapacity, 该值被初始化成大于initialCapacity的最小的2的次幂
* 这里这种情况指的是原table为空,并且在初始化的时候指定了容量,
* 则用threshold作为table的实际大小
*/
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
//构造方法中没有指定容量,则使用默认值
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 计算指定了initialCapacity情况下的新的 threshold
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
/**从以上操作我们知道, 初始化HashMap时,
* 如果构造函数没有指定initialCapacity, 则table大小为16
* 如果构造函数指定了initialCapacity, 则table大小为threshold,
* 即大于指定initialCapacity的最小的2的整数次幂
* 从下面开始, 初始化table或者扩容, 实际上都是通过新建一个table来完成
*/
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
/** 这里注意, table中存放的只是Node的引用,这里将oldTab[j]=null只是清除旧表的引用,
* 但是真正的node节点还在, 只是现在由e指向它
*/
oldTab[j] = null;
//桶中只有一个节点,直接放入新桶中
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
//桶中为红黑树,则对树进行拆分
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
//桶中为链表,对链表进行拆分
else { // preserve order
//下面为对链表的拆分,我们单独来讲一下。
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
resize最重要的操作之一就是对链表的拆分了,那么resize是如何拆分链表的呢?再来看一下代码:
HashMap.Node<K,V> loHead = null, loTail = null;
HashMap.Node<K,V> hiHead = null, hiTail = null;
HashMap.Node<K,V> next;
//遍历该桶
do {
next = e.next;
//找出拆分后仍处在同一个桶中的节点
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
这里定义了4个变量:loHead,loTail,hiHead,hiTail,这四个变量从字面意思可以看出应该是两个头节点,两个尾节点。那么为什么需要两个链表的头尾节点呢?看一张图就明白了:
这张图中index=2的桶中有四个节点,在未扩容之前,它们的hash& cap都等于2。在扩容之后,它们之中2、18还在一起,10、26却换了一个桶。这就是这句代码的含义:选择出扩容后在同一个桶中的节点。
if ((e.hash & oldCap) == 0)
e.hash & oldCap == 0为什么可以判断当前节点是否需要移位, 而不是再次计算hash,假设oldCap = 8,newCap为16,则原来桶的索引计算为e.hash & (oldCap-1),新的桶计算为e.hash & (newCap-1),发现其实两者的差别就是e.hash & oldCap
old (8-1): 111
new (16-1): 1111 = 111 + 1000 (oldCap=1000)
如图计算结果,8(oldCap)的二进制为:1000
2的二进制为:0010 & 1000 =0000
10的二进制为:1010,1010 & 1000 = 1000,
18的二进制为:10010, 10010 & 1000 = 0000,
26的二进制为:11010,11010 & 1000 = 1000,
从与操作后的结果可以看出来,2和18应该在同一个桶中,10和26应该在同一个桶中。
所以lo和hi这两个链表的作用就是保存原链表拆分成的两个链表。找到拆分后仍处于同一个桶的节点,将这些节点重新连接起来。
然后将拆分完的链表放进桶里的操作,比较简单,只需要将头节点放进桶里就ok了,newTab[j]和newTab[j + oldCap]分别代表了扩容之后原位置与新位置,就相当于之前那张图中的2和10。
resize()总结
-
什么时候进行resize操作?
- 初始化table;
- 在size超过threshold之后进行扩容。
-
扩容后的新数组容量为多大比较合适?
扩容后的数组应该为原数组的两倍,并且这里的数组大小必须是2的幂。
-
节点在转移的过程中是一个个节点复制还是一串一串的转移?
从源码中我们可以看出,扩容时是先找到拆分后处于同一个桶的节点,将这些节点连接好,然后把头节点存入桶中即可。
⭐️总结一下加入相同hash值元素(equals不相同)的过程:(带色的是加入的第几个元素)
0 1 16 9 32 10 64 11 树化
如果不发生树化的table大小变化,括号内为阈值(threshold)
if (++size > threshold)
resize();
0 => 16(12) => 32(24) =>64(64*0.75=48)=>128(96)=>…=>1 << 30(Integer.MAX_VALUE)
HashTable
基本介绍
- 存放的元素是键值对:K-V。
- Hashtable的键和值都不能为null,否则会抛出NullPointerException。
- Hashtable使用方法基本上和HashMap一样。
- Hashtable是线程安全的(synchorized),HashMap是线程不安全的。
代码:
import java.util.Hashtable;
//Hashtable
public class HashtableDemo {
public static void main(String[] args) {
Hashtable hashtable = new Hashtable();
hashtable.put("John", 100);
//hashtable.put(null, 100); //NullPointerException
//hashtable.put("John", null); //NullPointerException
hashtable.put("Lucy", 200);
hashtable.put("Lic", 100);
hashtable.put("Lic", 80); //替换
hashtable.put("hello1", 1);
hashtable.put("hello2", 1);
hashtable.put("hello3", 1);
hashtable.put("hello4", 1);
hashtable.put("hello5", 1);
hashtable.put("hello6", 1);
hashtable.put("hello7", 1);
System.out.println(hashtable); //{hello7=1, hello6=1, hello5=1, hello4=1, hello3=1, hello2=1, hello1=1, Lic=80, John=100, Lucy=200}
/*
Hashtable底层机制:
1. 底层有一个数组 Hashtable$Entry[] 初始化大小为11
2. 临界值 threshold 8 = 11 * 0.75
3. 扩容:按照自己的扩容机制运行
4. put()中发现无相同元素时,执行 addEntry(hash, key, value, index); 添加 k-v 封装到 Entry
5. 当 if(count >= threshold) 满足时,没加之前table的count,就进行扩容
6. 按照 int newCapacity = (oldCapaticy << 1 ) + 1; 即[old*2+1]的大小扩容
*/
}
}
HashMap和Hashtable的比较
Map实现类 | 版本 | 线程安全(同步) | 效率 | 允许null键null值 |
---|---|---|---|---|
HashMap | 1.2 | 不安全 | 高 | 可以 |
Hashtable | 1.0 | 安全 | 较低 | 不可以 |
Properties
基本介绍
- Properties类继承HashTable类并且实现了Map接口,也是使用一种键值对的形式来保存数据。
- 他的使用特点和Hashtable类似。
- Properties还可以从xxx.properties文件中,加载数据到Properties类对象,并进行读取和修改。
- 说明:xxx.properties文件通常作为配置文件。
代码:
import java.util.Properties;
//Properties
public class PropertiesDemo {
public static void main(String[] args) {
//1.Properties继承自Hashtable
//2.可以通过k-v存放数据,key和value不能为null
Properties properties = new Properties();
properties.put("John", 100);
//properties.put(null, 100); //NullPointerException
//properties.put("John", null); //NullPointerException
properties.put("Jane", 200);
properties.put("Lic", 300);
properties.put("Lic", 80);
System.out.println(properties); //{Jane=200, John=100, Lic=80}
//3.通过key获取对应的值
System.out.println(properties.get("Jane")); //200
//4.删除
properties.remove("Lic");
System.out.println(properties);
//5.修改
properties.put("John", "java");
System.out.println(properties); //{Jane=200, John=java}
}
}
TreeMap
基本介绍
- 唯一
- 有序(按照升序或降序排列)
- 底层:二叉树,key遵照二叉树特点
- key对应的类型内部一定要实现比较器(内部比较器,外部比较器自选)
代码:
import java.util.Comparator;
import java.util.TreeMap;
//TreeMap
public class TreeMapDemo {
public static void main(String[] args) {
//使用默认构造器创建TreeMap
//TreeMap treeMap = new TreeMap();
//使用有参构造器创建TreeMap
TreeMap treeMap = new TreeMap(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
//按照传入的k(String)的大小进行排序
//return ((String) o2).compareTo((String) o1);
//按照字符串长度大小排序
return ((String) o1).length() - ((String) o2).length();
}
});
treeMap.put("Jack", "杰克");
treeMap.put("Tom", "汤姆");
treeMap.put("Audrey", "奥黛丽");
treeMap.put("Smith", "史密斯");
treeMap.put("Smith", "123");
System.out.println(treeMap.size());
System.out.println(treeMap); //{Tom=汤姆, Jack=杰克, Smith=123, Audrey=奥黛丽}
}
}
原理
通过节点对象属性,按照排序规则判断元素的对象,指定子节点的位置。
源码
-
节点类型:
private transient Entry<K,V> root; //根节点
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; }
-
构造器
public TreeMap() { comparator = null; // 如果使用空构造器,那么底层就不使用外部比较器 } public TreeMap(Comparator<? super K> comparator) { this.comparator = comparator; // 如果使用有参构造器,就相当于指定了外部比较器 }
-
put方法
public V put(K key, V value) { // k,v的类型在创建对象时就指定了 // 首次添加元素 ,t的值为null Entry<K,V> t = root; // 第二次添加节点时,root已经是跟节点了 if (t == null) { // 自己跟自己比 compare(key, key); // type (and possibly null) check //跟节点确定为root root = new Entry<>(key, value, null); size = 1; modCount++; return null; } int cmp; Entry<K,V> parent; // split comparator and comparable paths // 将外部比较器 赋给 cpr Comparator<? super K> cpr = comparator; // cpr 不等于 null, 意味着创建对象时调用了有参构造器,指定了外部比较器 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); } // cpr 等于 null, 意味着创建对象时调用了 空构造器,没有指定外部比较器,会使用内部比较器 else { if (key == null) throw new NullPointerException(); @SuppressWarnings("unchecked") Comparable<? super K> k = (Comparable<? super K>) key; do {//遍历所有的key parent = t; cmp = k.compareTo(t.key); //将元素的key值作比较 // cpm 返回的值为int类型的值 if (cmp < 0) t = t.left; else if (cmp > 0) t = t.right; else // cmp == 0 // 表示两个key 一样,key不变(key唯一),将原来的value替换为新的value 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; }
如何选择集合实现类
在开发中,选择哪种集合实现类,主要取决于业务操作特点,然后根据集合实现类特性进行选择,分析如下:
-
先判断存储的类型(一组对象[单列]或一组键值对[双列])
-
一组对象[单列]:Collection接口
-
允许重复:List
- 增删多:LinkedList[底层维护了一个双向链表]
- 改查多:ArrayList[底层维护Object类型的可变数组]
-
不允许重复:Set
- 无序:HashSet[底层是HashMap,维护了一个哈希表,即(数组+链表+红黑树)]
- 排序:TreeSet
- 插入和取出顺序一致:LinkedHashSet[底层是LinkedHashMap,维护了一个数组+双向链表]
-
-
一组键值对:Map
- 键无序:HashMap[底层是哈希表 jdk7:数组+链表,jdk8:数组+链表+红黑树]
- 键排序:TreeMap
- 键插入和取出顺序一致:LinkedHashMap
- 读取文件:Properties
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】凌霞软件回馈社区,博客园 & 1Panel & Halo 联合会员上线
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】博客园社区专享云产品让利特惠,阿里云新客6.5折上折
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步
· 微软正式发布.NET 10 Preview 1:开启下一代开发框架新篇章
· 没有源码,如何修改代码逻辑?
· DeepSeek R1 简明指南:架构、训练、本地部署及硬件要求
· NetPad:一个.NET开源、跨平台的C#编辑器
· 面试官:你是如何进行SQL调优的?