HashSetソースコード分析-要素が繰り返されないようにする方法

中心的な質問：セットは、要素が繰り返されていないことをどのように認識しますか？

HashSetソースコード分析

HashMapの構築

最下層はHashMapを実装することです

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

メソッドの追加

追加操作は、要素をキーとしてマップに配置し、毎回現在の値を格納することです。この値は意味がなく、毎回スペースを浪費します。

public boolean add(E e) {
    
    
    return map.put(e, PRESENT)==null;
}

// Dummy value to associate with an Object in the backing Map
private static final Object PRESENT = new Object();

マップのソースコード

putメソッド

public V put(K key, V value) {
    
    
    return putVal(hash(key), key, value, false, true);
}

ハッシュ法

static final int hash(Object key) {
    
    
    int h;
    //计算hash值，根据传入的对象类型调用不同的hash函数
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

putValueメソッド

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    
    
    //tab存放 当前的哈希桶， p用作临时链表节点  
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    //table为null，初始化table长度
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    //i是散列值，table[i]上没有数据，没有发生哈希碰撞。存放数据
    if ((p = tab[i = (n - 1) & hash]) == null)
        //table[i]上存放节点Node
        tab[i] = newNode(hash, key, value, null);
    //table[i]上有数据,发生哈希碰撞
    else {
    
    
        Node<K,V> e; K k;
        //hash是节点p的属性
        //先比较hash是否一样，在比较key是否一样，如果相同,记录当前的节点e。（后面覆盖value会用到）
        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);
        //当前节点的hash一致，但是key不同，则在当前节点.next插入一个节点，变为链表
        else {
    
    
            //遍历到链表尾部看是否有相同的key，没有则加，有则替换Node（后面替换value会用到）
            for (int binCount = 0; ; ++binCount) {
    
    
                //后面没有节点，可以创建节点，退出循环
                if ((e = p.next) == null) {
    
    
                    p.next = newNode(hash, key, value, null);
                    //如果追加节点后，binCount >=7(也就是8个节点的时候)，则转化为红黑树
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                //当前节点后面有节点，并且这个节点和当前的节点的hash和key都相同则找到了要替换的节点位置，退出循环（已经在e = p.next中更新了节点）
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                //p指向下一个节点，在前面的代码中e = p.next
                p = e;
            }
        }
        //如果e不是null，说明有需要覆盖的节点，
        if (e != null) {
    
     // existing mapping for key
            //则覆盖节点值，并返回原oldValue
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            //这是一个空实现的函数，用作LinkedHashMap重写使用。
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    //更新size，并判断是否需要扩容--大于初始容量。
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

static final int TREEIFY_THRESHOLD = 8;

なぜ（n-1）＆ハッシュ？

一般に、ハッシュ値を使用してハッシュテーブルのハッシュの長さを調整することを考えます（つまり、除算ハッシュメソッド）。このメソッドはHashtableにも実装されています。このメソッドは、基本的に要素がハッシュテーブルでハッシュされることを保証できます。 。は比較的均一ですが、モジュラスは除算演算を使用するため、非常に非効率的です。HashMapでは、（length-1）＆hashメソッドを使用してモジュラスを置き換えます。これも均一なハッシュを実現しますが、効率ははるかに高くなります。これはHashMapでもあり、Hashtableの改良版です。

ハッシュテーブルの容量が2の累乗でなければならないのはなぜですか？

まず、長さが2の整数乗の場合、（n-1）＆hashは、モジュラスを長さにすることと同等です。これにより、ハッシュの均一性が保証され、効率も向上します。

次に、長さが2の整数乗の場合、偶数であるため、長さ-1は奇数であり、奇数の最後の桁は1です。これにより、（n-1）＆の最後の桁が保証されます。ハッシュは0または可能です。1（hの値によって異なります）、つまり、ANDの後の結果は偶数または奇数になる可能性があるため、ハッシュの均一性が保証され、長さが奇数の場合は長さ-1が偶数であり、その最後の桁が0であることは明らかです。したがって、（n-1）とハッシュの最後の桁は0でなければなりません。つまり、偶数にすることしかできないため、ハッシュ値は次のようになります。配列の偶数の添え字位置にハッシュされます。スペースのほぼ半分が無駄になります。したがって、長さを2の累乗にすることは、異なるハッシュ値の衝突の確率を小さくして、要素を均等にハッシュできるようにすることです。ハッシュテーブル内。

静的内部クラスノード

/**
 * The table, initialized on first use, and resized as
 * necessary. When allocated, length is always a power of two.
 * (We also tolerate length zero in some operations to allow
 * bootstrapping mechanics that are currently not needed.)
 */
//map底层实现是一个Node数组
transient Node<K,V>[] table;

ノードの最下層には、キー、値、およびハッシュ値が格納されます

/**
 * Basic hash bin node, used for most entries.  (See below for
 * TreeNode subclass, and in LinkedHashMap for its Entry subclass.)
 */
static class Node<K,V> implements Map.Entry<K,V> {
    
    
    final int hash;
    final K key;
    V value;
    Node<K,V> next;

    Node(int hash, K key, V value, Node<K,V> next) {
    
    
        this.hash = hash;
        this.key = key;
        this.value = value;
        this.next = next;
    }

    public final K getKey()        {
    
     return key; }
    public final V getValue()      {
    
     return value; }
    public final String toString() {
    
     return key + "=" + value; }

    public final int hashCode() {
    
    
        return Objects.hashCode(key) ^ Objects.hashCode(value);
    }

    public final V setValue(V newValue) {
    
    
        V oldValue = value;
        value = newValue;
        return oldValue;
    }

    public final boolean equals(Object o) {
    
    
        if (o == this)
            return true;
        if (o instanceof Map.Entry) {
    
    
            Map.Entry<?,?> e = (Map.Entry<?,?>)o;
            if (Objects.equals(key, e.getKey()) &&
                Objects.equals(value, e.getValue()))
                return true;
        }
        return false;
    }
}

回答：

セットの最下層はマップによって実装されます。要素を格納するときにハッシュ（キー）が実行されます。繰り返されるキーがオーバーライドされると、ノードが上書きされ（実際には値が上書きされます）、値が固定され、同じなので、重複する要素はありません。