Set接口及其实现类的底层应用

一、Set

Set 接口是 Collection 的子接口，set 接口没有提供额外的方法

Set 集合不允许包含相同的元素，如果试把两个相同的元素加入同一个 Set 集合中，则添加操作失败。

Set 判断两个对象是否相同不是使用 == 运算符，而是根据 equals() 方法进行判断

Set 存储是无序的、不可存储重复的数据。

其中，Set接口拥有两个自己的实现类，分别是：HashSet和TreeSet。

二、HashSet

作为Set接口的主要实现类；线程不安全的；可以存储null值

HashSet的底层：数组+链表

构造方法

//无参构造方法，完成map的创建
public HashSet() {
    map = new HashMap<>();
}
//指定集合转化为HashSet, 完成map的创建
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);
}
//指定初始化大小和负载因子，dummy 无实际意义
HashSet(int initialCapacity, float loadFactor, boolean dummy) {
    map = new LinkedHashMap<>(initialCapacity, loadFactor);
}

通过构造函数可以发现，HashSet底层是采用HashMap实现的。

add( )方法

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

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

我们向HashSet中添加元素a，首先调用元素a所在类的hashCode()方法，计算元素a的哈希值，此时哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为：索引位置），判断数组此位置上是否已经有元素：

如果此位置上没有其他元素，则元素a添加成功

如果此位置上有其他元素b（或一链表形式存在的多个元素），则比较元素a与元素b的hash值：
如果hash值不相同，则元素a添加成功
如果hash值相同，进而需要调用元素a所在类的equals()方法：
equals()返回true，则元素a添加失败
equals()返回false，则元素a添加成功

static final int hash(Object key) {
        int h;
        // key.hashCode()：返回散列值也就是hashcode
        // ^ ：按位异或
        // >>>:无符号右移，忽略符号位，空位都以0补齐
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

public boolean equals(Object obj) {
        return (this == obj);
}

remove( )方法

/** 
 * 如果指定元素存在于此set中，则将其移除。 
 * 更确切地讲，如果此set包含一个满足(o==null ? e==null : o.equals(e))的元素e， 
 * 则将其移除。如果此set已包含该元素，则返回true 
 * （或者：如果此set因调用而发生更改，则返回true）。（一旦调用返回，则此set不再包含该元素）。 
 * 
 * 底层实际调用HashMap的remove方法删除指定Entry。 
 * @param o 如果存在于此set中则需要将其移除的对象。 
 * @return 如果set包含指定元素，则返回true。 
 */  
public boolean remove(Object o) {  
    return map.remove(o)==PRESENT;  
}  

public boolean remove(Object o) {
	if (o == null) {
		for (int index = 0; index < size; index++)

		if (elementData[index] == null) {
			fastRemove(index);

			return true;
		}
	} else {
		for (int index = 0; index < size; index++)
			if (o.equals(elementData[index])) {
				fastRemove(index);

				return true;
	
		}
	}

	return false;
}

三、LinkedHashSet

LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录数据的前一个数据和后一个数据

优点：对于频繁的遍历操作，LinkedHashSet效率高于HashSet

	public void test1(){

        Set set = new HashSet();
        set.add(456);
        set.add(123);
        set.add(123);
        set.add("AA");
        set.add("CC");
        set.add(false);

        Iterator iterator = set.iterator();
        while(iterator.hasNext())
        {
            System.out.println(iterator.next());
        }

        System.out.println("******************");
        LinkedHashSet linkedHashSet = new LinkedHashSet();
        linkedHashSet.add("aa");
        linkedHashSet.add("bb");
        linkedHashSet.add("cc");
        linkedHashSet.add("aa");
        linkedHashSet.add("dd");

        Iterator iterator1 = linkedHashSet.iterator();
        while(iterator1.hasNext())
        {
            System.out.println(iterator1.next());
        }
    }
    

运行结果：

四、TreeSet

TreeSet中存放的元素是有序的（不是插入时的顺序，是有按关键字大小排序的），且元素不能重复。
而如何实现有序存储，就需要有一个比较器，其实说起来，TreeSet更受关注的是不重复且有序，这个有序就需要有一个compare的过程，因此会需要参数实现Comparable接口。

排序方式完全取决于使用的构造方法。
使用元素的自然顺序对元素进行排序（自然排序）
根据创建 set 时提供的 Comparator 进行排序（比较器排序）
TreeSet保证元素的排序和唯一性的
底层数据结构是红黑树(自平衡二叉树)

    /**
     * Constructs a new, empty tree set, sorted according to the specified
     * comparator.  All elements inserted into the set must be <i>mutually
     * comparable</i> by the specified comparator: {@code comparator.compare(e1,
     * 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, the
     * {@code add} call will throw a {@code ClassCastException}.
     *
     * @param comparator the comparator that will be used to order this set.
     *        If {@code null}, the {@linkplain Comparable natural
     *        ordering} of the elements will be used.
     */
    public TreeSet(Comparator<? super E> comparator) {
        this(new TreeMap<>(comparator));
    }