关于java中set集合的除重原理

1
2
3
public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public V put(K key, V value) {
if (table == EMPTY_TABLE) {
inflateTable(threshold);
}
if (key == null)
return putForNullKey(value);
int hash = hash(key);
int i = indexFor(hash, table.length);
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(hash, key, value, i);
return null;
}

1
2
3
一、非空校验，Set集合只允许一个null。
二、遍历查找相同元素
三、返回null ，add（）方法返回  null == null  即true。

1
2
3
  if (table == EMPTY_TABLE) {
        inflateTable(threshold);
        }

1
2
 if (key == null)
      return putForNullKey(value);

1
2
3
4
5
6
7
若你传入的元素为空的话 --> return putForNullKey(value); -->结束put方法并把方法的结果返回给调用者(add)
                    putForNullKey(value)-->见名知意 专门为放null值的方法
            第二板块的作用:
                判断你传入的参数是不是null:
                    若不是null,继续下面的判断
                    若是null,把这个null值存到集合中,当是当你第二次传入null值的时候,不允许再添加null
            -->Set集合可以有null值的元素,但是只能有一个!!!

1
2
 int hash = hash(key);
        int i = indexFor(hash, table.length);

1
2
3
4
5
6
7
8
9
10
11
12
 final int hash(Object k) {
            int h = hashSeed;
            if (0 != h && k instanceof String) {
                return sun.misc.Hashing.stringHash32((String) k);
            }
            h ^= k.hashCode();
            // This function ensures that hashCodes that differ only by
            // constant multiples at each bit position have a bounded
            // number of collisions (approximately 8 at default load factor).
            h ^= (h >>> 20) ^ (h >>> 12);
            return h ^ (h >>> 7) ^ (h >>> 4);
    }

1
2
        我们可以看到,hash(Object k)的返回值跟hashCode()有关.我们在自己定义一个类时,对hashCode()进行了重写,
        hashCode()返回了运算后属性值的地址,通过比较hashCode()的值来判断是否是同一个对象.

1
2
3
4
5
6
7
8
9
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

1
2
3
for (Entry<K,V> e = table[i]; e != null; e = e.next)  
这个for循环是在做遍历,遍历老的Set集合,找有没有重复的元素,e接收了老的Set集合

1
2
3
4
5
6
7
8
9
10
11
12
if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
 
 左边:e.hash == hash
通过比较属性值的地址,判断新传入的Set集合是否跟老Set集合的某个是同一个对象
 右边:((k = e.key) == key || key.equals(k)))
       左边:(k = e.key) == key
        这是将老Set集合中的key的地址值赋给k,然后和新传入的key的地址值比较.
        对于引用数据类型的对象,每次创建对象的地址值是不同的,所以k!=key
        对于集合包装类的对象,拿对象名比较时,会拆箱比较基本数据类型的值,所以存在k == key.
        右边:key.equals(k)
         这里重写了equals方法,比较的是属性值是否相同.
           

1
2
3
4
5
6
7
8
9
 //整理逻辑
        若e.hash == hash,则说明对象的运算后属性地址值相同                
            情况一:集合包装类,判断(k = e.key) == key,若相同,则执行if的语句,
返回跟新传入Set相同的老Set集合,即return oldValue
            情况二:引用数据类型,判断key.equals(k)),若相同,则属性值相同,执行if的语句,
返回跟新传入Set相同的老Set集合,即return oldValue
      
        若e.hash != hash,则说明对象的运算后属性地址值不相同,不执行if的语句   一定不是相同的对象
        

1
2
3
 modCount++;
addEntry(hash, key, value, i);
return null;