1. 为什么 hashset 中使用 present 而不是 null 作为 value
无意之中碰到了这个问题，在此记录一下
1.1. present 是个什么玩意
hashset 的部分源码如下
public class hashset<e> extends abstractset<e> implements set<e>, cloneable, java.io.serializable {
static final long serialversionuid = -5024744406713321676l;
private transient hashmap<e,object> map;
// dummy value to associate with an object in the backing map
private static final object present = new object();
}
1.2. hashset 的构造方法
// 默认构造函数 底层创建一个hashmap
public hashset() {
// 调用hashmap的默认构造函数，创建map
map = new hashmap<e,object>();
}
// 带集合的构造函数
public hashset(collection<? extends e> c) {
// 创建map。
map = new hashmap<e,object>(math.max((int) (c.size()/.75f) + 1, 16));
// 将集合(c)中的全部元素添加到hashset中
addall(c);
}
// 指定hashset初始容量和加载因子的构造函数
public hashset(int initialcapacity, float loadfactor) {
map = new hashmap<e,object>(initialcapacity, loadfactor);
}
// 指定hashset初始容量的构造函数
public hashset(int initialcapacity) {
map = new hashmap<e,object>(initialcapacity);
}
hashset(int initialcapacity, float loadfactor, boolean dummy) {
map = new linkedhashmap<e,object>(initialcapacity, loadfactor);
}
1.3. present 何时会被用到
- add(e) 方法
- remove(object) 方法
1.3.1. hashset 中的 add(e) 方法
/**
* add(e) 方法返回 null 时，表示 hashset 添加数据成功
*
* @return true 如果不包含该元素
*/
public boolean add(e e) {
return map.put(e, present)==null;
}
直接调用的是 hashmap 的 put(k, v) 方法，此时传入的 value 值是 present
public v put(k key, v value) {
return putval(hash(key), key, value, false, true);
}
final v putval(int hash, k key, v value, boolean onlyifabsent,
boolean evict) {
// tab表示 node<k,v>类型的数组，p表示某一个具体的单链表 node<k,v> 节点
node<k,v>[] tab; node<k,v> p; int n, i;
// 判断 table[] 是否为空，如果是空的就创建一个 table[]，并获取他的长度n
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// tab[i = (n - 1) & hash] 表示数组中的某一个具体位置的数据
// 如果单链表 node<k,v> p == tab[i = (n - 1) & hash]) == null，
// 就直接 put 进单链表中，说明此时并没有发生 hash 冲突
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newnode(hash, key, value, null);
else {
// 说明索引位置已经放入过数据了，已经在单链表处产生了hash冲突
node<k,v> e; k k;
// 判断 put 的数据和之前的数据是否重复
if (p.hash == hash &&
// 进行 key 的 hash 值和 key 的 equals() 和 == 比较，如果都相等，则初始化数组 node<k,v> e
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 判断是否是红黑树，如果是红黑树就直接插入树中
else if (p instanceof treenode)
e = ((treenode<k,v>)p).puttreeval(this, tab, hash, key, value);
else {
// 如果不是红黑树，就遍历每个节点，判断单链表长度是否大于等于 7，
// 如果单链表长度大于等于 7，数组的长度小于 64 时，会优先选择扩容
// 如果单链表长度大于等于 7，数组的长度大于 64 时，才会选择单链表--->红黑树
for (int bincount = 0; ; ++bincount) {
if ((e = p.next) == null) {
// 采用尾插法，在单链表中插入数据
p.next = newnode(hash, key, value, null);
// 如果 bincount >= 8 - 1
if (bincount >= treeify_threshold - 1)
treeifybin(tab, hash);
break;
}
// 判断索引每个元素的key是否可要插入的key相同，如果相同就直接覆盖
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) {
// 此时说明 key 的 hash 值和 key 的 equals() 和 == 比较结果都相等
// 说明数组或者单链表中有完全相同的 key
// 因此只需要将value覆盖，并将oldvalue返回即可
v oldvalue = e.value;
if (!onlyifabsent || oldvalue == null)
e.value = value;
afternodeaccess(e);
return oldvalue;
}
}
// 说明没有key相同，因此要插入一个key-value，并记录内部结构变化次数
++modcount;
// 判断是否扩容
if (++size > threshold)
resize();
afternodeinsertion(evict);
return null;
}
关于 hashmap 的 put(k, v) 方法的
- 如果 return oldvalue 说明发生了 value 覆盖，也就是说此时返回了 present，自然而然 hashmap 添加数据失败
- 如果 return null 说明 hashmap 添加数据成功
而如果将 present 替换为 null 作为 value 值，那么 hashset 的 add(e) 方法将无法判断添加元素的成功与失败；因为不管是成功与失败都会返回结果 null
1.3.2. hashmap 进行 put 元素示例
1.3.3. hashset 中的 remove(object) 方法
hashset 的 remove(object) 方法源码
public boolean remove(object o) {
return map.remove(o)==present;
}
hashset 的 remove(object) 依旧直接使用 hashmap 的 remove(object) 方法
public v remove(object key) {
node<k,v> e;
return (e = removenode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
hashmap 的 remove(object) 方法会返回 null 或 value
- 有该值，返回 value 也就是 present，表示 remove 成功
- 无该值，返回 null，自然而然 remove 失败
而如果将 present 替换为 null 作为 value 值，那么 hashset 的 remove(object) 方法将无法判断移除元素的成功与失败；因为不管是成功与失败都会返回结果 null
以上为个人经验，希望能给大家一个参考，也希望大家多多支持。
