HashSet集合中add（）方法存储自定义类型的执行过程

首先创建一个自定义类

class Student{
	
	String id;

	public Student(String id) {//构造方法
		this.id = id;
	}
}

在一个main方法中测试

public static void main(String[] args) {
		HashSet <Student> set = new HashSet<>();
		//调用了HashSet无参构造方法->HashMap无参构造方法->HashMap table为null
		
		set.add(new Student("1"));
		//tab=resize（）->resize（）为table变量赋值，该值即是该方法返回值——>tab局部变量与table全局变量指向一个数组，数组长度为16——>来自于代码static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
		set.add(new Student("1"));
		System.out.println(set.size());
	}

此时执行结果为2；

初步思考：由于Student类中并没有重写hashCode（）方法，所以在调用hash（Object key）时，比较的是传入对象的地址，在main方法的两个对象（看似是同一个对象，实则非也）地址都不相同，因而hash值不同；所以这两个对象都可以存储在集合中。

此时，如果我们的目标是不能添加重复id对象的话，只需要在自定义类中重写hashCode（）方法

	@Override
	public int hashCode() {		
		return id.hashCode();
	}

but…此时执行结果仍然是2？？？
我们先找到putVal方法的代码方便分析：

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)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            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) // -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) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

继续分析：
当执行main方法中第一个add方法时：

第一步：

执行if ((tab = table) == null || (n = tab.length) == 0)判断语句，第一次add时，table数组为空，执行if语句内部代码tab=resize（）给tab一个数组空间，table为全局变量，初始值为null，tab和table指向同一个数组；这里的resize()返回的值为默认的长度为16，并把resize()赋给tab，resize()和tab指向的同一个对象；而table也赋值给tab.所以这三个指向同一对象

第二步：

执行if(p = tab[i = (n - 1) & hash]) == null)判断；这里通过把表达式((n - 1) & hash)结果赋给i，可以找tab[i]的值，判断tab[i]是否为null,如果为空就把对象存进去.，同样的table作为全局变量指向的对象，就把对象存入了；也就是，此时tab/table数组中已经存储了一个id为1的对象

第三步：跳过else，直接执行 return null语句返回null

当执行第二个add方法时：

第一步：

执行if ((tab = table) == null || (n = tab.length) == 0)判断语句，此时tab指向的数组中已经有一个id为1的对象，所以条件不成立，跳过执行后边的语句；

第二步：

执行if(p = tab[i = (n - 1) & hash]) == null)判断语句，此时的hash与上一步的hash值相同，所以i的值没有变化，因而跳转到else中语句执行下列代码

 if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;

p.hash == hash是在比较两次传入的对象hash值是否相同，显然为true；在(k = p.key) == key语句中，k = p.key即k和p中存储的都是第一个对象的地址，key则为本次传入对象的地址，所以结果显然为false，所以执行key != null && key.equals(k)语句，key != null成立执行key.equals（k），此处调用的仍然是Object类的equals方法，结果必然为false；

所以，此处可以在自定义类中重写equals方法

@Override
	public boolean equals(Object obj) {
		Student student = (Student)obj;//类型转换
		return id.equals(student.id);
	}

重写equals方法后，此处调用了自定义类中的equals方法，实际上调用的是String类的equals方法，比较内容是否相同，显然为true；执行e=p语句

最后：执行下列代码

 if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }

e不为空所以执行if语句中的内容，方法返回值也不为null，添加就失败了

此时再执行main方法结果为1，要求的功能基本也就实现了；

此处给出自定义类的完整代码

class Student{
	
	String id;

	public Student(String id) {
		this.id = id;
	}

	@Override
	public int hashCode() {		
		return id.hashCode();
	}

	@Override
	public boolean equals(Object obj) {
		Student student = (Student)obj;//类型转换
		return id.equals(student.id);
	}	
}

思考一个问题，如果我们创建一个Dog类：

public class Dog {

	public String id;

	public Dog(String id) {
		this.id = id;
	}

	@Override
	public int hashCode() {		
		return id.hashCode();
	}
}

main方法

public static void main(String[] args) {
		HashSet <Object> set = new HashSet<>();
			
		set.add(new Dog("1"));
		set.add(new Student("1"));		
		System.out.println(set.size());
	}

执行结果：

Exception in thread "main" java.lang.ClassCastException: com.jd.Dog cannot be cast to com.jd.Student
	at com.jd.Student.equals(Test.java:35)
	at java.util.HashMap.putVal(HashMap.java:634)
	at java.util.HashMap.put(HashMap.java:611)
	at java.util.HashSet.add(HashSet.java:219)
	at com.jd.Test.main(Test.java:13)

原来是，类型转换错误，在前边博文中有提到过，使用instanceof就可以轻松解决，只修改自定义类的equals方法即可

@Override
	public boolean equals(Object obj) {
	
			if (obj instanceof Student) {
				Student student = (Student) obj;//类型转换
				return id.equals(student.id);
			}		
			return false;
	} //main方法执行结果为2；

最后
再备注一句：hashCode()与equals(Object obj)的执行顺序是hashcode()先执行，在hashcode相等的情况下执行equals(Object obj)