【Java源码】HashSet、LinkedHashSet

一、HashSet
——》属性
1、HashSet内部其实使用一个HashMap来存储元素

private transient HashMap<E,Object> map;

2、PRESENT对象，因为HastSet只需要保存key，而HashMap处理Key之外还有value，所以HastSet中讲一个static final对象保存在map中

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

——》构造方法
1、第一种是使用HashMap存储元素

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


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


public HashSet(int initialCapacity, float loadFactor) {
map = new HashMap<E,Object>(initialCapacity, loadFactor);
    }

2、第二种是使用LinkedHashMap存储元素，这样做其实为后面的LinkedHashMap提供了方便

HashSet(int initialCapacity, float loadFactor, boolean dummy) {
map = new LinkedHashMap<E,Object>(initialCapacity, loadFactor);
    }

由于HashSet中的方法基本上是对HashMap的包装使用，所以就不多介绍了。


二、LinkedHashMap
LinkedHashMap是HashMap的子类，在HashMap的基础上，将Entry的单链表形式改为双链表，增加了前后指针

private static class Entry<K,V> extends HashMap.Entry<K,V> {
        // These fields comprise the doubly linked list used for iteration.
        Entry<K,V> before, after;//继承HashMap.Entry，并增加前后指针


Entry(int hash, K key, V value, HashMap.Entry<K,V> next) {
            super(hash, key, value, next);
        }


        /**
         * Removes this entry from the linked list.
         */
        private void remove() {
            before.after = after;
            after.before = before;
        }


        /**
         * Inserts this entry before the specified existing entry in the list.
         */
        private void addBefore(Entry<K,V> existingEntry) {
            after  = existingEntry;
            before = existingEntry.before;
            before.after = this;
            after.before = this;
        }

三、LinkedHashSet
它继承了HashSet，只是将它的构造方法全部包装HashSet对LinkedHashMap的使用，其它地方没变化

public LinkedHashSet(int initialCapacity, float loadFactor) {
        super(initialCapacity, loadFactor, true);
    }


    public LinkedHashSet(int initialCapacity) {
        super(initialCapacity, .75f, true);
    }


 
    public LinkedHashSet() {
        super(16, .75f, true);
    }


   
    public LinkedHashSet(Collection<? extends E> c) {
        super(Math.max(2*c.size(), 11), .75f, true);
        addAll(c);
    }