// 基于本地 JDK 源码 (D:/1ForCode/JAVA_Source, java.base, 2024 版), java.util.HashSet
public class HashSet<E>
    extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable
{
    // ...

    transient HashMap<E,Object> map;    // 唯一的实例字段。transient：序列化自己写，不走默认机制

    // Dummy value to associate with an Object in the backing Map
    static final Object PRESENT = new Object();    // 全类共享一个哨兵，不占额外内存；不能用 null，因为 map.put 返回 null 有"原来没这个 key"的语义

    public HashSet() {
        map = new HashMap<>();          // 默认容量 16、负载因子 0.75，全部沿用 HashMap 的默认值
    }

    @SuppressWarnings("this-escape")
    public HashSet(Collection<? extends E> c) {
        map = HashMap.newHashMap(Math.max(c.size(), 12));   // 按 size/0.75 向上取整算容量，保证 addAll 不触发扩容；下限 12 防止空/小集合建出过小的表
        addAll(c);
    }

    public HashSet(int initialCapacity, float loadFactor) {
        map = new HashMap<>(initialCapacity, loadFactor);   // 参数原样透传，连 IllegalArgumentException 都是 HashMap 抛的
    }

    public HashSet(int initialCapacity) {
        map = new HashMap<>(initialCapacity);
    }

    HashSet(int initialCapacity, float loadFactor, boolean dummy) {
        map = new LinkedHashMap<>(initialCapacity, loadFactor);  // 包私有，专供 LinkedHashSet：dummy 参数只为区分重载签名
    }

    public Iterator<E> iterator() {
        return map.keySet().iterator();     // 迭代即遍历 key 视图，fail-fast 行为也是继承来的
    }

    public int size() {
        return map.size();
    }

    // ...

    public boolean contains(Object o) {
        return map.containsKey(o);
    }

    public boolean add(E e) {
        return map.put(e, PRESENT)==null;   // put 返回旧 value：null 表示 key 原本不存在 -> 添加成功。"元素已存在则不动"的语义靠这一个返回值判断
    }

    public boolean remove(Object o) {
        return map.remove(o)==PRESENT;      // 同理：删掉的 value 是 PRESENT 说明 key 真的在；用 == 比 != null 更精确
    }

    // ...

    public static <T> HashSet<T> newHashSet(int numElements) {      // JDK 19+：传"预期元素数"而不是"容量"，替用户算好 size/0.75
        if (numElements < 0) {
            throw new IllegalArgumentException("Negative number of elements: " + numElements);
        }
        return new HashSet<>(HashMap.calculateHashMapCapacity(numElements));
    }
}

// 基于本地 JDK 源码 (D:/1ForCode/JAVA_Source, java.base, 2024 版), java.util.HashSet
    @java.io.Serial
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        // Consume and ignore stream fields (currently zero).
        s.readFields();

        // Read capacity and verify non-negative.
        int capacity = s.readInt();
        if (capacity < 0) {
            throw new InvalidObjectException("Illegal capacity: " +
                                             capacity);
        }

        // Read load factor and verify positive and non NaN.
        float loadFactor = s.readFloat();
        if (loadFactor <= 0 || Float.isNaN(loadFactor)) {
            throw new InvalidObjectException("Illegal load factor: " +
                                             loadFactor);
        }
        // Clamp load factor to range of 0.25...4.0.
        loadFactor = Math.clamp(loadFactor, 0.25f, 4.0f);   // 流里的负载因子只在合理区间内被信任，防止 0.0001 这种值把表撑爆

        // Read size and verify non-negative.
        int size = s.readInt();
        if (size < 0) {
            throw new InvalidObjectException("Illegal size: " + size);
        }

        // 关键：容量不用流里写的 capacity，而是按 size 重算，保证表至少 25% 满且不超上限
        capacity = (int) Math.min(size * Math.min(1 / loadFactor, 4.0f),
                HashMap.MAXIMUM_CAPACITY);

        // 建表前先向序列化框架申报即将分配的数组大小，超过流的允许上限直接拒绝(防 OOM 攻击)
        SharedSecrets.getJavaObjectInputStreamAccess()
                     .checkArray(s, Map.Entry[].class, HashMap.tableSizeFor(capacity));

        // Create backing HashMap
        map = (this instanceof LinkedHashSet ?
               new LinkedHashMap<>(capacity, loadFactor) :
               new HashMap<>(capacity, loadFactor));    // LinkedHashSet 没有自己的 readObject，靠这个 instanceof 复用父类逻辑

        // Read in all elements in the proper order.
        for (int i=0; i<size; i++) {
            @SuppressWarnings("unchecked")
                E e = (E) s.readObject();
            map.put(e, PRESENT);        // 逐个 put 回去，等于重新哈希一遍，不信任流里的桶布局
        }
    }

为什么 value 用一个共享的静态 PRESENT,而不是 null 或者每次 new?用 null 不行,因为 `map.put` 返回 null 时你分不清是"key 不存在"还是"key 存在但 value 是 null",去重判断直接失效;每次 new 则白白多造对象。
static final 的哨兵让所有 HashSet 实例共享同一个引用,`remove` 里 `==PRESENT` 用引用相等判断即可,零额外内存开销。