讨论集合关注的问题：
- 底层数据结构
- 增删改查方式
- 初始容量，扩容方式，扩容时机
- 线程安全与否
- 是否允许空，是否允许重复，是否有序
1. 概述
前篇，我写了关于Map系列的集合(点击跳转)；本篇重新回顾Collection三大类Set、List、Queue中的Set。
Set可以视作是数学中集合的概念，也即集合中不能有重复的元素。Set集合中的各种实现集合，其内部都与Map有关，先对Map有了解更好。常见的Set集合有HashSet、LinkedHashSet和TreeSet，下面通过源码试着分析其内部构造。
2. HashSet
HashSet继承自AbstractSet，实现了Set接口，同时也是可克隆对象和进行序列化的。其内部的数据存储区通过一个transient修饰的HashMap维护，也就是说HashSet中的数据是存放在HashMap中（回忆：HashMap中是通过一个transient的数组来存储不同的Hash值的key，相同的Key链成一个链表）。进行序列化时，不会序列化空的值。它维持它自己的内部排序，所以随机访问没有任何意义。
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<>();
}
HashSet进行构造时，除了可以使用Collection进行构造外，基本都调用了HashMap的构造函数完成。主要的参数是基础容量为16个单位，加载因子是0.75。
HashSet基于HashMap，所以其对数据的访问基本都是用HashMap的方法，包括获取size、加载迭代器等。我们知道存入Set中的数据本身是无序的，维护访问顺序没有意义。
public int size() {
return map.size();
}
public boolean isEmpty() {
return map.isEmpty();
}
public boolean contains(Object o) {
return map.containsKey(o);
}
/**
* Returns an iterator over the elements in this set. The elements
* are returned in no particular order.
*
* @return an Iterator over the elements in this set
* @see ConcurrentModificationException
*/
public Iterator<E> iterator() {
return map.keySet().iterator();
}
添加元素时，HashSet会调用HashMap的add方法，但在操作时做了一点细微的处理。HashSet类中维护了一个final的空对象Object，每次加入集合中的数据，其实是保存在Map中的key中，而map中的Value都是这个对象。所以相同元素插入时，此时会发生value的替换，因为所有entry的value一样，所以和没有插入时一样的。HashSet在添加元素或移除时，同样会run一遍HashMap中那些操作（查找、成链等），只是内容变化不大。
方式：hash(key的hash码处理得到)———（相同与否）———key(相同与否)————替换value或链成表
// Dummy value to associate with an Object in the backing Map
private static final Object PRESENT = new Object();
* @param e element to be added to this set
* @return <tt>true</tt> if this set did not already contain the specified
* element
*/
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
3. LinkedHashSet
LinkedHashSet是HashSet的一个“扩展版本”，HashSet并不管什么顺序，不同的是LinkedHashSet会维护“插入顺序”。HashSet内部使用HashMap对象来存储它的元素，而LinkedHashSet内部使用LinkedHashMap对象来存储和处理它的元素。
扫描二维码关注公众号，回复： 4901439 查看本文章
LinkedHashSet直接继承自HashSet，能够维护基础的有序性。
LinkedHashSet使用LinkedHashMap对象来存储它的元素，插入到LinkedHashSet中的元素实际上是被当作LinkedHashMap的键保存起来的。LinkedHashMap的每一个键值对都是通过内部的静态类Entry。
其内部只有几个简单的构造函数，使用了父类的一个比较特殊的构造函数：
HashSet(int initialCapacity, float loadFactor, boolean dummy) {
map = new LinkedHashMap<>(initialCapacity, loadFactor);
}
-----------------------------------------------------------------------
public LinkedHashSet(int initialCapacity, float loadFactor) {
super(initialCapacity, loadFactor, true);
}
public LinkedHashSet(int initialCapacity) {
super(initialCapacity, .75f, true);
}
public LinkedHashSet() {
super(16, .75f, true);
}
4. TreeSet
TreeSet与TreeMap实现类似。
TreeMap是一个有序的二叉树，TreeSet同样也是一个有序的，它的作用是提供有序的Set集合。TreeSet继承自AbstractSet，实现了Set接口、Cloneable和Serializable、NavigableSet接口。其内部主要是通过一个NavigableMap的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;
}
public TreeSet() {
this(new TreeMap<E,Object>());
}
//构造一个包含指定 collection 元素的新 TreeSet，它按照其元素的自然顺序进行排序。
public TreeSet(Comparator<? super E> comparator) {
this(new TreeMap<>(comparator));
}
//构造一个新的空 TreeSet，它根据指定比较器进行排序。
public TreeSet(Collection<? extends E> c) {
this();
addAll(c);
}
//构造一个与指定有序 set 具有相同映射关系和相同排序的新 TreeSet。
public TreeSet(SortedSet<E> s) {
this(s.comparator());
addAll(s);
}
NavigableSet是 SortedSet的子类，具有了为给定搜索目标报告最接近匹配项的导航方法，这就意味着它支持一系列的导航方法——比如查找与指定目标最匹配项。
TreeSet内部通过维护了一颗树，来保证数据的有序性。
public V put(K key, V value) {
Entry<K,V> t = root;
if (t == null) {
//空树时，判断节点是否为空
compare(key, key); // type (and possibly null) check
root = new Entry<>(key, value, null);
size = 1;
modCount++;
return null;
}
int cmp;
Entry<K,V> parent;
// split comparator and comparable paths
Comparator<? super K> cpr = comparator;
//非空树，根据传入比较器进行节点的插入位置查找
if (cpr != null) {
do {
parent = t;
//节点比根节点小，则找左子树，否则找右子树
cmp = cpr.compare(key, t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
//如果key的比较返回值相等，直接更新值（一般compareto相等时equals方法也相等）
else
return t.setValue(value);
} while (t != null);
}
else {
//如果没有传入比较器，则按照自然排序
if (key == null)
throw new NullPointerException();
@SuppressWarnings("unchecked")
Comparable<? super K> k = (Comparable<? super K>) key;
do {
parent = t;
cmp = k.compareTo(t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
return t.setValue(value);
} while (t != null);
}
//查找的节点为空，直接插入，默认为红节点
Entry<K,V> e = new Entry<>(key, value, parent);
if (cmp < 0)
parent.left = e;
else
parent.right = e;
//插入后进行红黑树调整
fixAfterInsertion(e);
size++;
modCount++;
return null;
}
5. 小结
HashSet/TreeSet和LinkedHashSet，其内部都是基于Map来实现的。TreeSet和LinkedHashSet分别使用了TreeMap和LinkedHashMap来控制访问数据的有序性。
三者都属于Set的范畴，都是没有重复元素的集合。基于HashMap和TreeMap，所以都是非线程安全的。