HashSet如何保證元素不重復(面試必問)

// 創建 HashSet 集合
HashSet<String> strSet = new HashSet<>();
// 給 HashSet 添加數據
strSet.add("Java");
strSet.add("MySQL");
strSet.add("Redis");
// 循環打印 HashSet 中的所有元素
strSet.forEach(s -> System.out.println(s));

HashSet<String> mapSet = new HashSet<>();
mapSet.add("深圳");
mapSet.add("北京");
mapSet.add("西安");
// 循環打印 HashSet 中的所有元素
mapSet.forEach(m -> System.out.println(m));

HashSet<Long> longSet = new HashSet<>();
longSet.add(666l);
longSet.add(777l);
longSet.add(999l);
longSet.add(666l);
// 循環打印 HashSet 中的所有元素
longSet.forEach(l -> System.out.println(l));

public class HashSetExample {
    public static void main(String[] args) {
        HashSet<Person> personSet = new HashSet<>();
        personSet.add(new Person("曹操", "123"));
        personSet.add(new Person("孫權", "123"));
        personSet.add(new Person("曹操", "123"));
        // 循環打印 HashSet 中的所有元素
        personSet.forEach(p -> System.out.println(p));
    }
}
@Getter
@Setter
@ToString
class Person {
    private String name;
    private String password;

    public Person(String name, String password) {
        this.name = name;
        this.password = password;
    }
}

@Override
public int hashCode() {
    return Long.hashCode(value);
}
public boolean equals(Object obj) {
    if (obj instanceof Long) {
        return value == ((Long)obj).longValue();
    }
    return false;
}
//省略其他源碼......

@Setter
@Getter
@ToString
class Person {
    private String name;
    private String password;
    public Person(String name, String password) {
        this.name = name;
        this.password = password;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true; // 引用相等返回 true
        // 如果等於 null，或者對象類型不同返回 false
        if (o == null || getClass() != o.getClass()) return false;
        // 強轉為自定義 Person 類型
        Person persion = (Person) o;
        // 如果 name 和 password 都相等，就返回 true
        return Objects.equals(name, persion.name) &&
                Objects.equals(password, persion.password);
    }
    @Override
    public int hashCode() {
        // 對比 name 和 password 是否相等
        return Objects.hash(name, password);
    }
}

// hashmap 中 put() 返回 null 時，表示操作成功
public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}

// 返回值：如果插入位置沒有元素則返回 null，否則返回上一個元素
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) {
        Node<K, V>[] tab;
        Node<K, V> p;
        int n, i;
        //如果哈希表為空，調用 resize() 創建一個哈希表，並用變量 n 記錄哈希表長度
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        /**
         * 如果指定參數 hash 在表中沒有對應的桶，即為沒有碰撞
         * Hash函數，(n - 1) & hash 計算 key 將被放置的槽位
         * (n - 1) & hash 本質上是 hash % n 位運算更快
         */
        if ((p = tab[i = (n - 1) & hash]) == null)
            // 直接將鍵值對插入到 map 中即可
            tab[i] = newNode(hash, key, value, null);
        else {// 桶中已經存在元素
            Node<K, V> e;
            K k;
            // 比較桶中第一個元素(數組中的結點)的 hash 值相等，key 相等
            if (p.hash == hash &&
                    ((k = p.key) == key || (key != null && key.equals(k))))
                // 將第一個元素賦值給 e，用 e 來記錄
                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;
                    }
                    // 鏈表節點的<key, value>與 put 操作<key, value>
                    // 相同時，不做重復操作，跳出循環
                    if (e.hash == hash &&
                            ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            // 找到或新建一個 key 和 hashCode 與插入元素相等的鍵值對，進行 put 操作
            if (e != null) { // existing mapping for key
                // 記錄 e 的 value
                V oldValue = e.value;
                /**
                 * onlyIfAbsent 為 false 或舊值為 null 時，允許替換舊值
                 * 否則無需替換
                 */
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                // 訪問後回調
                afterNodeAccess(e);
                // 返回舊值
                return oldValue;
            }
        }
        // 更新結構化修改信息
        ++modCount;
        // 鍵值對數目超過閾值時，進行 rehash
        if (++size > threshold)
            resize();
        // 插入後回調
        afterNodeInsertion(evict);
        return null;
    }