Java容器Set接口

　　Set接口的实现，可以方便地将指定的类型以集合类型保存在一个变量中。Set是一个不包含重复元素的Collection，更确切地讲，Set 不包含满足 e1.equals(e2) 的元素对，并且最多包含一个 null 元素。Set接口的底层存储实现都是依赖Map的实现，也可以说Set中元素的管理就是对Map中key的管理。下面简单描述一下各种Set接口的实现类，主要包括HashSet，LinkedHashSet，TreeSet

1、HashSet

　　HashSet底层是有HashMap实现的，存储的是[key-Object常量]这样的键值对，同样包括initialCapacity和loadFactor两个参数，这两个参数的意义和HashMap一样，都是比较重要的。另外，HashSet集合里边的元素是无序的。

public class HashSet<E>
    extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable
{
    static final long serialVersionUID = -5024744406713321676L;

    private transient HashMap<E,Object> map;

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

    /**
     * Constructs a new, empty set; the backing <tt>HashMap</tt> instance has
     * default initial capacity (16) and load factor (0.75).
     */
    public HashSet() {
    map = new HashMap<E,Object>();
    }

    /**
     * Constructs a new set containing the elements in the specified
     * collection.  The <tt>HashMap</tt> is created with default load factor
     * (0.75) and an initial capacity sufficient to contain the elements in
     * the specified collection.
     *
     * @param c the collection whose elements are to be placed into this set
     * @throws NullPointerException if the specified collection is null
     */
    public HashSet(Collection<? extends E> c) {
    map = new HashMap<E,Object>(Math.max((int) (c.size()/.75f) + , ));
    addAll(c);
    }

    /**
     * Constructs a new, empty set; the backing <tt>HashMap</tt> instance has
     * the specified initial capacity and the specified load factor.
     *
     * @param      initialCapacity   the initial capacity of the hash map
     * @param      loadFactor        the load factor of the hash map
     * @throws     IllegalArgumentException if the initial capacity is less
     *             than zero, or if the load factor is nonpositive
     */
    public HashSet(int initialCapacity, float loadFactor) {
    map = new HashMap<E,Object>(initialCapacity, loadFactor);
    }

2、LinkedHashSet

　　LinkedHashSet继承了HashSet，但它底层存储使用的是LinkedHashMap，所以其中的元素是按照插入有序的。看LinkedHashSet类只是定义了四个构造方法，也没看到和链表相关的内容，为什么说LinkedHashSet内部使用链表维护元素的插入顺序（插入的顺序）呢？点进去看下这个三个参数的构造方法HashSet(int initialCapacity, float loadFactor, boolean dummy)，就会发现使用的实现类是LinkedHashMap了：

public class LinkedHashSet<E>
    extends HashSet<E>
    implements Set<E>, Cloneable, java.io.Serializable {

    private static final long serialVersionUID = -2851667679971038690L;

    /**
     * Constructs a new, empty linked hash set with the specified initial
     * capacity and load factor.
     *
     * @param      initialCapacity the initial capacity of the linked hash set
     * @param      loadFactor      the load factor of the linked hash set
     * @throws     IllegalArgumentException  if the initial capacity is less
     *               than zero, or if the load factor is nonpositive
     */
    public LinkedHashSet(int initialCapacity, float loadFactor) {
        super(initialCapacity, loadFactor, true);
    }

    /**
     * Constructs a new, empty linked hash set with the specified initial
     * capacity and the default load factor (0.75).
     *
     * @param   initialCapacity   the initial capacity of the LinkedHashSet
     * @throws  IllegalArgumentException if the initial capacity is less
     *              than zero
     */
    public LinkedHashSet(int initialCapacity) {
        super(initialCapacity, .75f, true);
    }

    /**
     * Constructs a new, empty linked hash set with the default initial
     * capacity (16) and load factor (0.75).
     */
    public LinkedHashSet() {
        super(16, .75f, true);
    }

    /**
     * Constructs a new, empty linked hash set.  (This package private
     * constructor is only used by LinkedHashSet.) The backing
     * HashMap instance is a LinkedHashMap with the specified initial
     * capacity and the specified load factor.
     *
     * @param      initialCapacity   the initial capacity of the hash map
     * @param      loadFactor        the load factor of the hash map
     * @param      dummy             ignored (distinguishes this
     *             constructor from other int, float constructor.)
     * @throws     IllegalArgumentException if the initial capacity is less
     *             than zero, or if the load factor is nonpositive
     */
    HashSet(int initialCapacity, float loadFactor, boolean dummy) {
    map = new LinkedHashMap<E,Object>(initialCapacity, loadFactor);
    }

3、TreeSet

　　TreeSet底层存储使用的是TreeMap，使用它可以从Set中提取有序的序列，元素必须实现Comparable接口否则按默认字典排序。

public class TreeSet<E> extends AbstractSet<E>
    implements NavigableSet<E>, Cloneable, java.io.Serializable
{
    /**
     * The backing map.
     */
    private transient NavigableMap<E,Object> m;

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

    /**
     * Constructs a set backed by the specified navigable map.
     */
    TreeSet(NavigableMap<E,Object> m) {
        this.m = m;
    }

    /**
     * Constructs a new, empty tree set, sorted according to the
     * natural ordering of its elements.  All elements inserted into
     * the set must implement the {@link Comparable} interface.
     * Furthermore, all such elements must be <i>mutually
     * comparable</i>: {@code e1.compareTo(e2)} must not throw a
     * {@code ClassCastException} for any elements {@code e1} and
     * {@code e2} in the set.  If the user attempts to add an element
     * to the set that violates this constraint (for example, the user
     * attempts to add a string element to a set whose elements are
     * integers), the {@code add} call will throw a
     * {@code ClassCastException}.
     */
    public TreeSet() {
    this(new TreeMap<E,Object>());
    }

总结一下：

　　HashSet是为快速查找而设计的Set，存入HashSet的元素必须定义hashCode()；LinkedHashSet具有HashSet的查询速度，且内部使用链表维护元素的顺序（插入顺序），在使用迭代器遍历Set时，结果会按插入的次序显示，元素必须定义hashCode()方法；TreeSet保存次序的Set，底层为树结构，使用它可以从Set中提取有序的序列，元素必须实现Comparable接口。

　　另外，这里提一下hashcode和equals在Set中的比较重要的意义。当对以哈希为底层的集合操作的时候，会先以hashcode去找对应的链表，然后再遍历对应的链表通过equals对比key，最后找到对应的value。还是和上次说的一样，当hashcode方法设计的不好的时候，会导致元素分布不均匀，然后调用大量的equals对比key，最后影响到程序的执行效率。

    public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key.hashCode());
        int i = indexFor(hash, table.length);
        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;
            }
        }

        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }

　　最后提一下面试比较常问到的问题：当两个对象的hashcode相等的时候它们的equals不一定返回true；但当两个对象的equals返回true的时候它们的hashcode一定相同。