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

HashSet<String> mapSet = new HashSet<>();
mapSet.add("深圳");
mapSet.add("北京");
mapSet.add("西安");
// 循環(huán)打印 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);
// 循環(huán)打印 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("孫權(quán)", "123"));
        personSet.add(new Person("曹操", "123"));
        // 循環(huán)打印 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，或者對(duì)象類型不同返回 false
        if (o == null || getClass() != o.getClass()) return false;
        // 強(qiáng)轉(zhuǎn)為自定義 Person 類型
        Person persion = (Person) o;
        // 如果 name 和 password 都相等，就返回 true
        return Objects.equals(name, persion.name) &&
                Objects.equals(password, persion.password);
    }
    @Override
    public int hashCode() {
        // 對(duì)比 name 和 password 是否相等
        return Objects.hash(name, password);
    }
}

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

// 返回值：如果插入位置沒有元素則返回 null，否則返回上一個(gè)元素
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;
        //如果哈希表為空，調(diào)用 resize() 創(chuàng)建一個(gè)哈希表，并用變量 n 記錄哈希表長度
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        /**
         * 如果指定參數(shù) hash 在表中沒有對(duì)應(yīng)的桶，即為沒有碰撞
         * Hash函數(shù)，(n - 1) & hash 計(jì)算 key 將被放置的槽位
         * (n - 1) & hash 本質(zhì)上是 hash % n 位運(yùn)算更快
         */
        if ((p = tab[i = (n - 1) & hash]) == null)
            // 直接將鍵值對(duì)插入到 map 中即可
            tab[i] = newNode(hash, key, value, null);
        else {// 桶中已經(jīng)存在元素
            Node<K, V> e;
            K k;
            // 比較桶中第一個(gè)元素(數(shù)組中的結(jié)點(diǎn))的 hash 值相等，key 相等
            if (p.hash == hash &&
                    ((k = p.key) == key || (key != null && key.equals(k))))
                // 將第一個(gè)元素賦值給 e，用 e 來記錄
                e = p;
                // 當(dāng)前桶中無該鍵值對(duì)，且桶是紅黑樹結(jié)構(gòu)，按照紅黑樹結(jié)構(gòu)插入
            else if (p instanceof TreeNode)
                e = ((TreeNode<K, V>) p).putTreeVal(this, tab, hash, key, value);
                // 當(dāng)前桶中無該鍵值對(duì)，且桶是鏈表結(jié)構(gòu)，按照鏈表結(jié)構(gòu)插入到尾部
            else {
                for (int binCount = 0; ; ++binCount) {
                    // 遍歷到鏈表尾部
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        // 檢查鏈表長度是否達(dá)到閾值，達(dá)到將該槽位節(jié)點(diǎn)組織形式轉(zhuǎn)為紅黑樹
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    // 鏈表節(jié)點(diǎn)的<key, value>與 put 操作<key, value>
                    // 相同時(shí)，不做重復(fù)操作，跳出循環(huán)
                    if (e.hash == hash &&
                            ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            // 找到或新建一個(gè) key 和 hashCode 與插入元素相等的鍵值對(duì)，進(jìn)行 put 操作
            if (e != null) { // existing mapping for key
                // 記錄 e 的 value
                V oldValue = e.value;
                /**
                 * onlyIfAbsent 為 false 或舊值為 null 時(shí)，允許替換舊值
                 * 否則無需替換
                 */
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                // 訪問后回調(diào)
                afterNodeAccess(e);
                // 返回舊值
                return oldValue;
            }
        }
        // 更新結(jié)構(gòu)化修改信息
        ++modCount;
        // 鍵值對(duì)數(shù)目超過閾值時(shí)，進(jìn)行 rehash
        if (++size > threshold)
            resize();
        // 插入后回調(diào)
        afterNodeInsertion(evict);
        return null;
    }