集合框架——Set

Set

特点

Set继承于Collection接口
Set不允许出现重复元素
Set是无序的集合，存入和取出的顺序不一定相同（LinkedHashSet除外）
Set线程不安全

HashSet

介绍

1. HashSet是基于HashMap来实现的，操作很简单，更像是对HashMap做了一次“封装”，而且只使用了HashMap的key来实现各种特性
2. HashSet不能保证元素的排列顺序，顺序有可能发生变化
3. HashSet允许使用 null 元素
4. HashSet是非同步的，线程不安全
5. HashSet的底层结构是哈希表（实际上是一个HashMap实例）。HashSet集合是通过元素中继承自Object超类的hashCode()方法和equal()方法来判断两个对象是否相同的。通过hashCode方法可以避免每次添加都需要equals的繁琐过程。所以我们在自己定义对象的时候，可以覆写对象继承自Object的这两个方法，使他们按照我们的意志来判断两个元素是否是同一元素。
6. HashSet是根据哈希值的范围来提高查找效率，如果对象的属性参与hashCode计算，就要谨慎去修改。因为如果修改了该属性，该对象的哈希值就会改变，以后要删除该对象的时候，该对象在HashSet中的索引与现在的哈希值不匹配，就会找不到该元素，他的声明周期会随着HashSet的结束而结束，造成内存泄露。

判重原理

哈希表边存放的是哈希值。HashSet存储元素的顺序并不是按照存入时的顺序（和List显然不同） 是按照哈希值来存的所以取数据也是按照哈希值取得。

HashSet不存入重复元素的规则.使用hashcode和equals，由于Set集合是不能存入重复元素的集合。那么HashSet也是具备这一特性的。HashSet如何检查重复？HashSet会通过元素的hashcode（）和equals方法进行判断元素师否重复。

当你试图把对象加入HashSet时，HashSet会使用对象的hashCode来判断对象加入的位置。同时也会与其他已经加入的对象的hashCode进行比较，如果没有相等的hashCode，HashSet就会假设对象没有重复出现。
简单一句话，如果对象的hashCode值是不同的，那么HashSet会认为对象是不可能相等的。

因此我们自定义类的时候需要重写hashCode，来确保对象具有相同的hashCode值。如果元素(对象)的hashCode值相同,是不是就无法存入HashSet中了? 当然不是,会继续使用equals 进行比较.如果 equals为true 那么HashSet认为新加入的对象重复了,所以加入失败。如果equals 为false那么HashSet 认为新加入的对象没有重复.新元素可以存入。

图1：hashCode值不相同的情况
图2：hashCode值相同，但equals不相同的情况。
通过hashCode值来确定元素在内存中的位置。一个hashCode位置上可以存放多个元素。

总结：
元素的哈希值是通过元素的hashcode方法 来获取的, HashSet首先判断两个元素的哈希值，如果哈希值一样，接着会比较equals方法 如果 equls结果为true ，HashSet就视为同一个元素。如果equals 为false就不是同一个元素。

如果两个对象通过equals()方法比较返回true，则两个对象的hashCode值也应该相同。

哈希值相同equals为false的元素是怎么存储呢,就是在同样的哈希值下顺延（可以认为哈希值相同的元素放在一个哈希桶中）。也就是哈希一样的存一列。

调用原理：HashSet集合在判断元素是否相同先判断hashCode方法，如果相同才会判断equals。如果不相同，是不会调用equals方法的。

线程安全

1. 使用：Collections.synchronizedSet(Set s);

Set set = Collections.synchronizedSet(Set s);

加锁粒度更小

2. 使用：ConcurrentHashMap

Set<Integer> mySet=ConcurrentHashMap.newKeySet();

底层原理

HashSet的底层通过HashMap实现的。而HashMap在1.7之前使用的是数组+链表实现，在1.8+使用的数组+链表+红黑树实现。其实也可以这样理解，HashSet的底层实现和HashMap使用的是相同的方式，因为Map是无序的，因此HashSet也无法保证顺序。
HashSet的方法，也是借助HashMap的方法来实现的。

源码：

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;  //HashMap变量，用于存放HashSet的值

    private static final Object PRESENT = new Object(); //map中的值

    //构造方法
    public HashSet() {
        map = new HashMap<>();
    }

    //构造方法，将指定的集合转化为HashSet
    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);
    }

    //构造方法，采用default修饰，只能是同一个包下的成员访问。包不相同无法访问
    HashSet(int initialCapacity, float loadFactor, boolean dummy) {
        map = new LinkedHashMap<>(initialCapacity, loadFactor);
    }

    //HashSet的遍历操作
    //通过这个方法可以发现，HashSet调用了HashMap存放，因为HashSet并不是键值对存储，所以它只是把它的值做了Map中的键，在遍历HashSet的集合元素时，实际上是遍历的Map中Key的集合。
    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);
    }

    //添加元素，添加的元素作为了Map中的key,value使用了一个常量表示
    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();
    }

    //克隆方法
    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();
        }
    }

    //写入输出流操作。
    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);
        }
    }
}

总结：

1、HashSet不能重复存储equals相同的数据 。原因就是equals相同，数据的散列码也就相同（hashCode必须和equals兼容）。大量相同的数据将存放在同一个散列单元所指向的链表中，造成严重的散列冲突，对查找效率是灾难性的。
2、HashSet的存储是无序的 ，没有前后关系，他并不是线性结构的集合。
3、hashCode必须和equals必须兼容

LinkedHashSet

介绍

1. LinkedHashSet是Set集合的一个实现，具有set集合不重复的特点
2. LinkedHashSet是一个非线程安全的集合
3. LinkedHashSet 底层是依靠 LinkedHashMap 来实现数据存取的，而LinkedHashMap 继承于 HashMap，在内部自己维护了一条双向链表用于保存元素的插入顺序，因此使得 LinkedHashSet 也具有了存取有序，元素唯一的特点
4. LinkedHashSet可以得到super一个父类初始化为一个容器为16大小，加载因子为0.75的Map容器
5. LinkedHashSet迭代访问Set中的全部元素时，性能比HashSet好，插入时比HashSet慢
6. LinkedHashMap 拥有与 HashMap 相同的底层哈希表结构，即数组 + 单链表 + 红黑树，也拥有相同的扩容机制。

TreeSet

介绍

①　TreeSet是SortedSet接口的唯一实现类，TreeSet可以确保集合元素处于排序状态。TreeSet支持两种排序方式，自然排序 和定制排序，其中自然排序为默认的排序方式。向TreeSet中加入的应该是同一个类的对象。
②　TreeSet是非同步的，线程不安全的。
③　TreeSet判断两个对象不相等的方式是两个对象通过equals方法返回false，或者通过CompareTo方法比较没有返回0
④　元素不重复, 并且可以按照某种顺序排序（需要指定排序方法）
⑤　TreeSet的add方法会将对象转为Comparable, 然后调用compareTo方法,所以存储在TreeSet中的对象必须实现Comparable接口, 重写compareTo方法
⑥　TreeSet支持两种排序方法：自然排序和定制排序。TreeSet默认采用自然排序。
⑦　如果想把自定义类的对象存入TreeSet进行排序, 那么必须实现Comparable接口，重写compareTo()方法，在方法内定义比较算法, 根据大小关系, 返回正数负数或零。
在使用TreeSet存储对象的时候, add()方法内部就会自动调用compareTo()方法进行比较, 根据比较结果使用二叉树形式进行存储

自然排序

自然排序使用要排序元素的CompareTo（Object obj）方法来比较元素之间大小关系，然后将元素按照升序排列。

Java提供了一个Comparable接口，该接口里定义了一个compareTo(Object obj)方法，该方法返回一个整数值，实现了该接口的对象就可以比较大小。

obj1.compareTo(obj2)方法如果返回0，则说明被比较的两个对象相等，如果返回一个正数，则表明obj1大于obj2，如果是 负数，则表明obj1小于obj2。

如果我们将两个对象的equals方法总是返回true，则这两个对象的compareTo方法返回应该返回0

定制排序

自然排序是根据集合元素的大小，以升序排列，如果要定制排序，应该使用Comparator接口，实现 int compare(To1,To2)方法

TreeSet保证元素唯一并实现排序的原理

TreeSet：根据构造方法的不用，选择使用自然排序或者比较器排序。
按照实际的需求，可以对元素进行排序。并且保证唯一。怎么保证的呢?

排序：底层结构是二叉树。按照树节点进行存储和取出。
两种实现：
A:自然排序(元素具备比较性)
TreeSet的无参构造，要求对象所属的类实现Comparable接口。
B:比较器排序(集合具备比较性)
TreeSet的带参构造，要求构造方法接收一个实现了Comparator接口的对象。

唯一：根据返回值是否为0。

注意：
如果同时有两种方案，以谁为主呢?以比较器为主。 以比较器排序为主

方式一：对存进集合的对象所属的类实现Comparable接口,进行自然排序
方式二：TreeSet的带参构造，要求构造方法接收一个实现了Comparator接口的对象。

附语

看到array，就要想到角标。
看到link，就要想到first，last。
看到hash，就要想到hashCode,equals.
看到tree，就要想到两个接口。Comparable，Comparator。

HashSet的性能总是比TreeSet好（特别是最常用的添加、查询元素等操作），因为TreeSet需要额外的红黑树算法来维护集合元素的次序。只有当需要一个保持排序的Set时，才应该使用TreeSet，否则都应该使用HashSet。

对于普通的插入、删除操作，LinkedHashSet比HashSet要略微慢一点，这是由维护链表所带来的额外开销造成的；不过，因为有了链表，遍历LinkedHashSet会更快。