关闭

Java HashSet源码解析

标签: javaHashSet源码解析实现原理jdk
2697人阅读 评论(0) 收藏 举报
分类:

本解析源码来自JDK1.7,HashSet是基于HashMap实现的,方法实现大都直接调用HashMap的方法
另一篇HashMap的源码解析文章

概要

  • 实现了Set接口,实际是靠HashMap实现的
  • 不保证遍历时的顺序,不保证集合顺序的不变性
  • HashSet允许出现null值
  • 假定Hash算法能很好的分散元素,查询的时间复杂度为O(1)
  • 遍历的时间复杂度由set的size和其依靠的HashMap的capacity来决定
  • HashSet是非同步的可以通过Set s = Collections.synchronizedSet(new HashSet(...));的方式获得同步的set
  • HashSet的Iterator有fast-fail机制,但是并不能保证程序一定正确,fail-fast机制通常只用来检测bug

实现接口

  • Set接口包含集合常用方法
public class HashSet<E>
    extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable  
public interface Set<E> extends Collection<E> {
    // Query Operations
    int size();
    boolean isEmpty();
    boolean contains(Object o);
    Iterator<E> iterator();
    Object[] toArray();
    <T> T[] toArray(T[] a);
    // Modification Operations
    boolean add(E e);
    boolean remove(Object o);
    // Bulk Operations
    boolean containsAll(Collection<?> c);
    boolean addAll(Collection<? extends E> c);
    boolean retainAll(Collection<?> c);
    boolean removeAll(Collection<?> c);
    void clear();
    // Comparison and hashing
    boolean equals(Object o);
    int hashCode();
}  
  • Cloneable 对集合元素进行浅拷贝,调用了map的clone方法来克隆自身map域,由于HashMap执行的是浅拷贝,虽然创建了新的Entry,但是没有创建新的key和value,通过原Set和clone后的set对key和value的改变是等效的。
    public Object clone() {
        try {
            HashSet<E> newSet = (HashSet<E>) super.clone();
            newSet.map = (HashMap<E, Object>) map.clone();
            return newSet;
        } catch (CloneNotSupportedException e) {
            throw new InternalError();
        }
    }  
  • Serializable HashSet实现了自己readObject和writeObject方法,将map的keySet中的元素分别写入,对端读出后放入自己的map中去

主要成员

  • map用来装载set的元素,HashSet就是HashMap的keySet。transient表明序列化时略过,HashSet实现了自己的序列化方法。
  • 常量PRESENT用来填充HashMap的value,也就是说HashSet中的map的value都是同一个对象,高效的利用堆空间

NOTE:所有被装入集合(map,set,list)的对象,都只是将对象的引用复制一份到集合中。如果通过外部引用改变了对象的内容,集合中的对象的内容也会跟着改变。但是如果将外部引用指向其他对象,集合内部的引用并不会改变,还是会指向加入集合时引用指向的对象。也即元素被放入集合时,执行的是浅拷贝,引用复制而对象不会重新创建

    private transient HashMap<E,Object> map;
    // Dummy value to associate with an Object in the backing Map
    private static final Object PRESENT = new Object();  

构造函数

我们看到初始化HashSet就是初始化对应的HashMap对象map成员变量

    public HashSet() {
        map = new HashMap<>();
    } 
    public HashSet(Collection<? extends E> c) {
        map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
        addAll(c);
    }
    public HashSet(int initialCapacity, float loadFactor) {
        map = new HashMap<>(initialCapacity, loadFactor);
    }
    public HashSet(int initialCapacity) {
        map = new HashMap<>(initialCapacity);
    } 

集合相关方法

可以看到对HashSet的操作就是对对应的HashMap对象map的操作

    public Iterator<E> iterator() {
        return map.keySet().iterator();
    }
    public int size() {
        return map.size();
    }
    public boolean isEmpty() {
        return map.isEmpty();
    }
    public boolean contains(Object o) {
        return map.containsKey(o);
    }
    public boolean add(E e) {
        return map.put(e, PRESENT) == null;
    }
    public boolean remove(Object o) {
        return map.remove(o) == PRESENT;
    }
    public void clear() {
        map.clear();
    }  

HashMap解决扩容问题

  • 调整的时机 (负载因子)x(容量)>(Map 大小),则调整 Map大小 为之前的二倍,该过程包含了table的复制,性能消耗较大,如果map大小已知,可以在初始化时合理设定map的初始大小,避免扩容。
  • 如果数组大小已经到达最大容量,将阈值置为Integer.MAX_VAlUE,不再进行扩容
  • 新申请数组,重新定址并将原数组中的Entry转移到新数组中,由于容量变化,即使Hash值不变,Entry的index也会改变,index=hash&(length-1),取hash的低位,length增大,index取的位数增多
  • 依旧使用头插法将所有元素进行复制
    void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }
        Entry[] newTable = new Entry[newCapacity];
        transfer(newTable, initHashSeedAsNeeded(newCapacity));
        table = newTable;
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
    } 
    /**
     * Transfers all entries from current table to newTable.
     */
    void transfer(Entry[] newTable, boolean rehash) {
        int newCapacity = newTable.length;
        for (Entry<K,V> e : table) {
            while(null != e) {
                Entry<K,V> next = e.next;
                if (rehash) {
                    e.hash = null == e.key ? 0 : hash(e.key);
                }
                int i = indexFor(e.hash, newCapacity);
                e.next = newTable[i];
                newTable[i] = e;
                e = next;
            }
        }
    } 

HashMap 元素存储位置的计算 hash值

  • String类型的key的hashcode是根据与字符串内容相关的,由于可能引起很多碰撞,所以值单独计算
  • Object类型的key的HashCode是基于其内存地址的。为了充分利用Integer值的高位,需要将高位的影响引入低位,(由于多数map的length是比较小的)
  • 由于length是2的指数倍,所以可以用hash&(length-1)代替 hash%length,位运算有更高的效率
    final int hash(Object k) {
        int h = hashSeed;
        if (0 != h && k instanceof String) {
            return sun.misc.Hashing.stringHash32((String) k);
        }
        h ^= k.hashCode();
        // This function ensures that hashCodes that differ only by
        // constant multiples at each bit position have a bounded
        // number of collisions (approximately 8 at default load factor).
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }  
    static int indexFor(int h, int length) {
        // assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";
        return h & (length-1);
    }  

HashMap的put方法

下面以HashMap的put方法为例对HashSet的集合方法进行说明

  • 如果是key为null,遍历查找table中key是否有null,如果有更新value,否则添加null,value节点
  • 如果key不为null,根据Key的hashcode获取Hash值,根据Hash计算其在table中的索引。hash值计算时利用高位与低位进行异或操作,加入高位因素,来减少Hash碰撞。
  • 由于tablelength 都是2的指数次幂,所以indexFor用 HashCode&(table.lenght-1)取HashCode的低位,使用位运算提高运算效率
  • 如果table[i]不为null(并不表示Hash值相同,HashCode不同也可能碰撞),也就是发生了Hash碰撞,如果存在与keyHash相等(equals)或相同(==)的key,那么更新value
  • 如果table[i]为null,或者table[i]链表中不存在Hash值与Key相同且equals函数返回true的情况就根据Hash值添加新的节点
  • addEntry()方法首先判断大小是否超过阈值,然后使用头插法,插入元素
    NOTE
    在判断插入Entry是否为覆盖时,会先判断Key的hashCode是否和map中的key相等,然后判断Equals方法或者==,所以如果重写了equals方法,要记得重写hashcode方法,使得其逻辑相同,否则即使equals方法判断相等也不会发生覆盖
public V put(K key, V value) {
    // HashMap允许存放null键和null值。
    // 当key为null时,调用putForNullKey方法,将value放置在数组第一个位置。
    if (key == null)
        return putForNullKey(value);
    // 根据key的keyCode重新计算hash值。
    int hash = hash(key);//注意这里的实现是jdk1.7和以前的版本有区别的
    // 搜索指定hash值在对应table中的索引。
    int i = indexFor(hash, table.length);
    // 如果 i 索引处的 Entry 不为 null,通过循环不断遍历 e 元素的下一个元素。
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }
    // 如果i索引处的Entry为null,表明此处还没有Entry。
    modCount++;
    // 将key、value添加到i索引处。
    addEntry(hash, key, value, i);
    return null;
}
/**产生哈希码*/
final int hash(Object k) {
        int h = 0;
        if (useAltHashing) {
            if (k instanceof String) {
                return sun.misc.Hashing.stringHash32((String) k);
            }
            h = hashSeed;
        }

        h ^= k.hashCode();

        // This function ensures that hashCodes that differ only by
        // constant multiples at each bit position have a bounded
        // number of collisions (approximately 8 at default load factor).
        /*加入高位计算,防止低位不变,高位变化是引起hash冲突*/
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }
/**产生索引,由于索引产生是不确定的,因此也就造成了HashMap顺序的不确定性。
   需要注意的是不同的hash产生的索引完全有可能相同的
  该方法的实现十分的巧妙,它通过h & (length-1)来的到对象保存的
  索引,有可知道底层数组为2的n次方,这在速度上就有了明显的优化
  */
static int indexFor(int h, int length) {
        return h & (length-1);
    }
    private V putForNullKey(V value) {
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++;
        addEntry(0, null, value, 0);
        return null;
    }
    void addEntry(int hash, K key, V value, int bucketIndex) {
        if ((size >= threshold) && (null != table[bucketIndex])) {
            resize(2 * table.length);
            hash = (null != key) ? hash(key) : 0;
            bucketIndex = indexFor(hash, table.length);
        }
        createEntry(hash, key, value, bucketIndex);
    }  
    void createEntry(int hash, K key, V value, int bucketIndex) {
        Entry<K,V> e = table[bucketIndex];
        table[bucketIndex] = new Entry<>(hash, key, value, e);
        size++;
    }  

Clone方法

Clone方法是浅拷贝方法
Clone就是将对应的map进行复制

    public Object clone() {
        try {
            HashSet<E> newSet = (HashSet<E>) super.clone();
            newSet.map = (HashMap<E, Object>) map.clone();
            return newSet;
        } catch (CloneNotSupportedException e) {
            throw new InternalError();
        }
    }

HashMap的Clone方法

Clone实现的是浅拷贝,虽然重新创建了Entry但是并没有重新创建key,value,即如果通过原HashMap的key的引用改变了key的属性,clone出来的HashMap的key也会跟着改变,克隆出来的Map的数组的大小也不一定与原Map相同

  • HashSet的Clone方法其实就是对成员变量map的clone
  • 首先会创建一个空的HashMap对象
  • 然后对该HashMap进行扩容,容量大小取Math.min(当前table大小,HashMap的最大容量,当前的Size*(Math.min(1/loadFactor,4)),克隆出来的HashMap的数组初始大小并不会与当前Map一致,而是考虑合理的初始化loadFactor之后的结果。
  • 最后调用putAllForCreate(this)依次将当前Map的(key,value)放到Map中去,过程中虽然创建了新的Entry但是并没有创建新的key,value,通过原HashMap和通过克隆出来的HashMap改变(key,value)效果是等同的。
    public Object clone() {
        try {
            HashSet<E> newSet = (HashSet<E>) super.clone();
            newSet.map = (HashMap<E, Object>) map.clone();
            return newSet;
        } catch (CloneNotSupportedException e) {
            throw new InternalError();
        }
    }  
    public Object clone() {
        HashMap<K,V> result = null;
        try {
            result = (HashMap<K,V>)super.clone();
        } catch (CloneNotSupportedException e) {
            // assert false;
        }
        if (result.table != EMPTY_TABLE) {
            result.inflateTable(Math.min(
                (int) Math.min(
                    size * Math.min(1 / loadFactor, 4.0f),
                    // we have limits...
                    HashMap.MAXIMUM_CAPACITY),
               table.length));
        }
        result.entrySet = null;
        result.modCount = 0;
        result.size = 0;
        result.init();
        result.putAllForCreate(this);
        return result;
    } 
    private void putAllForCreate(Map<? extends K, ? extends V> m) {
        for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
            putForCreate(e.getKey(), e.getValue());
    }
    private void putForCreate(K key, V value) {
        int hash = null == key ? 0 : hash(key);
        int i = indexFor(hash, table.length);
        /**
         * Look for preexisting entry for key.  This will never happen for
         * clone or deserialize.  It will only happen for construction if the
         * input Map is a sorted map whose ordering is inconsistent w/ equals.
         */
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k)))) {
                e.value = value;
                return;
            }
        }
        createEntry(hash, key, value, i);
    }
    void createEntry(int hash, K key, V value, int bucketIndex) {
        Entry<K,V> e = table[bucketIndex];
        table[bucketIndex] = new Entry<>(hash, key, value, e);
        size++;
    }
        Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        } 

序列化方法

序列化方法就是将Map keySet中的元素依次写出,然后在对端依次读入,重建HashMap

    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException {
        // Write out any hidden serialization magic
        s.defaultWriteObject();
        // Write out HashMap capacity and load factor
        s.writeInt(map.capacity());
        s.writeFloat(map.loadFactor());
        // Write out size
        s.writeInt(map.size());
        // Write out all elements in the proper order.
        for (E e : map.keySet())
            s.writeObject(e);
    }
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        // Read in any hidden serialization magic
        s.defaultReadObject();
        // Read in HashMap capacity and load factor and create backing HashMap
        int capacity = s.readInt();
        float loadFactor = s.readFloat();
        map = (((HashSet)this) instanceof LinkedHashSet ?
               new LinkedHashMap<E,Object>(capacity, loadFactor) :
               new HashMap<E,Object>(capacity, loadFactor));
        // Read in size
        int size = s.readInt();
        // Read in all elements in the proper order.
        for (int i=0; i<size; i++) {
            E e = (E) s.readObject();
            map.put(e, PRESENT);
        }
    }
0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:34365次
    • 积分:743
    • 等级:
    • 排名:千里之外
    • 原创:38篇
    • 转载:1篇
    • 译文:0篇
    • 评论:7条
    最新评论