HashSet中的add方法

1，对HashSet新建对象的分析

HashSet<String> set=new HashSet<String>();
创建一个HashSet类的对象，new HashSet<String>()调用了HashSet中的无参构造方法
 public HashSet（）{
 	 map=new HashMap<>();
 }

实质又调用了HashMap中的无参构造方法
 public HashMap() {
   	 this.loadFactor = DEFAULT_LOAD_FACTOR; 
 }

2，hash方法

因为在对add方法进行分析时，会用到hash方法，先分析hash方法

01，传入String类型的值:比较内容是否相同，相同的内容返回值是相同的

	public class Test(){
	 static int hash(Object key) {
	        int h;
	        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
	 }	//	hash方法：返回值为int类型的，其中又调用了hashCode方法
	 
	 public static void main(String[] args) {
	
	int hash=hash("tom");		//hash方法中传入String类型的值后，key不为空，执行三目运算中冒号后边部分，调用hashCode方法
	System.out.println(hash);
	hash=hash(new String("tom"));
	System.out.println(hash);
	}
	
输出为：
115027
115027

其中String类中的hashCode方法如下，经过运算返回int类型的值

public int hashCode() {
    int h = hash;
    if (h == 0 && value.length > 0) {
        char val[] = value;

        for (int i = 0; i < value.length; i++) {
            h = 31 * h + val[i];
        }
        hash = h;
    }
    return h;
}

02，传入int类型的值，比较数值，数值相同返回值相同。

public class Test(){
 static int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
 }	//	hash方法：返回值为int类型的，其中又调用了hashCode方法
 
 public static void main(String[] args) {
	 hash=hash(15);
	 System.out.println(hash);
	 hash=hash(15);
	 System.out.println(hash);
 }
 
 输出为：
 15
 15

其中Integer 类中的hashCode方法如下，经过运算返回int类型的值，传入返回的值。

public static int hashCode(int value) {
    return value;
}

03，对传入的自定义类的对象：比较地址，返回int类型的值

public class Test(){
 static int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
 }	//	hash方法：返回值为int类型的，其中又调用了hashCode方法
 
 public static void main(String[] args) {
 	hash=hash(new Student());
 	System.out.println(hash);
 	hash=hash(new Student());	//两个地址：运算结果不同
 	System.out.println(hash);
	}
 }

//自定义类：
class Student{

}

输出为：
5433712
2430314

自定义类中的HashCode说明

因为自定义类中没有重写父类的hashCode方法，所以该类中的hashCode方法默认继承自父类Object，经过运算返回int类型的值。

//Object类中定义的hashCode方法：
public native int hashCode();

3，HashSet中add方法是怎样执行的

HashSet<String> set=new HashSet<String>();	
	set.add("tom");		
	set.add("tom");
	set.add("lucy");
	
代码分析：每次执行代码set.add();时调用add方法，传入的e的值为tom，再调用HashMap中的put方法，传入的key的值为tom，（HashSet存储的数据实质存在了HashMap的key），再调用putVal方法（其中的hash(key)返回int类型的数值）
//HashSet中的add方法
	public boolean add(E e) {
	        return map.put(e, PRESENT)==null;
	}
//HashMap中的put方法
	public V put(K key, V value) {																			
	        return putVal(hash(key), key, value, false, true);
	}
//HashMap中的putVal方法
	//详述putval方法
	
//第一次存储tom时
 final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {		//Node<K,V>[] tab;定义了一个集合，Node<K,V> p;定义集合中的值,table是全局变量，未初始化之前默认值为null.
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    if ((tab = table) == null || (n = tab.length) == 0)		//该if语句执行，将值赋给tab后，前半部分返回值为true，因为逻辑或遇真短路（后半部分不再运算），所以if条件满足，执行下一行代码。
        n = (tab = resize()).length;	//resize()方法将集合重置，重置后有了长度,且重置后的长度为16，因为调用了HashMpa中定义的常量【static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16】，然后执行下一行代码。
    if ((p = tab[i = (n - 1) & hash]) == null)		//i = (n - 1) & hash语句得到一个位置下标，对于p = tab[i = (n - 1) & hash]，第一次存储集合为空，所以if条件成立，执行下一行代码添加tom，然后跳出该if语句。
        tab[i] = newNode(hash, key, value, null);	
    else {
        Node<K,V> e; K k;
        if (p.hash == hash &&
            ((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 {
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) 
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { 
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;			//跳出if语句后执行该语句，实现将tom存储。
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

	//关于resize()方法
	 final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;	//table是null，返回值为newTab，是一个重置的有长度的集合。
	.......
	 if (oldTab != null) {

	 }
        return newTab;
	 }

//第二次存储tom时.
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    if ((tab = table) == null || (n = tab.length) == 0)		//table不为空，n = tab.length也不等于0,执行下一个if语句.
        n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == null)	//因为同一个String类型的值，hash相同，n为固定的长度，所以获取的下标与第一次相同，此时位置不为空，所以不添加到tab[i]，执行else语句
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))		//两次都是tom，所以hash相同，p.hash == hash返回true，((k = p.key) == key || (key != null && key.equals(k)))返回true，执行e=p;语句，执行下一个if语句
            e = p;
        else if (p instanceof TreeNode)
            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);
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { 			//此时e不为空，所以一定会执行return oldValue；
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;		//关掉方法，不存储数据。
        }
    }
    ++modCount;
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

//第三次时：存储lucy。

 final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    if ((tab = table) == null || (n = tab.length) == 0)	//table不为空，n = tab.length也不等于0,执行下一个if语句.
        n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == null)	//lucy调用hash方法后得到得值与tom不同，所以经过运算之后得到一个i，且此时该下标处为空，将lucy添加进去，跳出这个if语句。
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        if (p.hash == hash &&
            ((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 {
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1)
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { 
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }			
    ++modCount;		//跳出if语句后执行该语句，实现将lucy存储。
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

//常量池机制：在常量池中存储值时，先判断常量池中是否存在该值，如果存在将不再进行添加，不存在时才添加。