这 3 个 Set 集合的实现有点简单，那来做个总结吧

Set 接口是 Java Collections Framework 中的一员，它的特点是：不能包含重复的元素，允许且最多只有一个 null 元素。Java 中有三个常用的 Set 实现类：

• HashSet: 将元素存储在哈希表中，性能最佳，但不能保证元素的迭代顺序
• LinkedHashSet: 维护一个链表贯穿所有元素，按插入顺序对元素进行迭代
• TreeSet: 将元素存储在一个红黑树中，按元素大小排序的序列迭代

JDK 在实现时，这 3 个 Set 集合的核心功能其实分别委托给了: HashMap, LinkedHashMap 和 TreeMap，关于这 3 个 Map 的源码分析可查看本站发布的其他文章。

接下来对这 3 个 Set 集合的源码简单分析，并解决一些面试可能会遇到的问题。

HashSet

如果去除注释，HashSet 源码也就 200 行左右，除了序列化和克隆的方法，代码如下：

public class HashSet<E> extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable {
  // 实际存储元素的对象
  private transient HashMap<E,Object> map;
  
  // 存储在 HashMap 中所有 key 的共享的 value 值
  private static final Object PRESENT = new Object();
  // 空构造函数
  public HashSet() {
      map = new HashMap<>(); // 0.75f 加载因子
  }
  // 使用已有集合填充并初始化
  public HashSet(Collection<? extends E> c) {
      map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
      addAll(c);
  }
  // 指定关联 HashMap 的初始容量和加载因子
  public HashSet(int initialCapacity, float loadFactor) {
      map = new HashMap<>(initialCapacity, loadFactor);
  }
  // 只指定初始容量
  public HashSet(int initialCapacity) {
      map = new HashMap<>(initialCapacity);
  }
  // 包访问权限的构造方法，仅用于 LinkedHashSet 初始化
  // 使用 LinkedHashMap 作为底层存储
  HashSet(int initialCapacity, float loadFactor, boolean dummy) {
      map = new LinkedHashMap<>(initialCapacity, loadFactor);
  }
  // HashSet 中的元素就相当于 HashMap 中的 key 
  public Iterator<E> iterator() {
      return map.keySet().iterator();
  }
  
  // 以下这些方法，都是对 Set 接口中定义的方法的实现
  public int size() {
      return map.size();
  }

  public boolean isEmpty() {
      return map.isEmpty();
  }
  
  public boolean contains(Object o) {
      return map.containsKey(o);
  }
  // 所有键值对的 value 值都是 PRESENT 这个 Object 对象
  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();
  }
  // JDK 8 提供的一种并行遍历机制 - 可分割迭代器
  public Spliterator<E> spliterator() {
      return new HashMap.KeySpliterator<E,Object>(map, 0, -1, 0, 0);
  }
}

可以看到，底层使用 HashMap 用于实际存放数据，而 PRESENT 就是所有写入 map 的 value 值。实现比较简单，核心功能都委托给了 HashMap。

不管是 Set 还是 Map，存储的都是对象，在 Java 中，判断两个对象是否相等，都是通过 equals 和 hashCode 两个方法：

• 两个对象通过 equals 判断相等，那么它们肯定返回相同的 hashCode
• 反之，不要求必须拥有相同的 hashCode

所以，HashSet 存储的对象，都要正确覆盖实现 equals 和 hashCode 两个方法。

其实，HashSet 中的元素其实就是 HashMap 的 key，在插入时：

1. 首先计算元素的 hashCode 值，找到底层数组存储位置
2. 然后和该位置上的所有元素使用 equals 方法进行比较
3. 如果都不相等，则插入；否则不插入，本质上这里做了一次 value 的更新，但 key 不变化。

关于迭代器，就是利用的 HashMap 中的 KeyIterator。

LinkedHashSet

LinkedHashSet 的代码就更简单了，它继承自 HashSet，代码如下：

public class LinkedHashSet<E> extends HashSet<E>
  implements Set<E>, Cloneable, java.io.Serializable {
  // 调用父类特定的构造方法，初始一个 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);
  }

  @Override
  public Spliterator<E> spliterator() {
    return Spliterators.spliterator(this, Spliterator.DISTINCT | Spliterator.ORDERED);
  }
}

全部代码就这些，值得注意的是构造方法中的 super 调用的是 HashSet 中的一个默认包访问权限的构造方法，核心功能都委托给了 LinkedHashMap。

像 HashSet 那样，它能在常量时间内完成集合的基本操作 add, contains 和 remove。性能略低于 HashSet，因为要额外维护一个链表。但有一个例外，在遍历时，LinkedHashSet 花费的时间与元素个数成比例，而 HashSet 花费时间较多，因为它与集合容量成比例。

TreeSet

TreeSet 是一个有序的 Set 集合，元素大小比较方式可以是自然顺序，也可以指定一个 Comparator 比较器。

它是对 TreeMap 的封装，提供了在有序集合上的遍历 API 比如，lower、floor、ceiling 和 higher 分别返回小于、小于等于、大于等于、大于给定元素的元素。能在 log(n) 时间内完成集合的基本操作 add, contains 和 remove。

有一点可以了解下，Set 接口定义的是使用 equals 方法比较元素是否相等，而 TreeSet 使用则是 compareTo 或者 compare 方法进行比较，这满足集合的行为，只不过没有遵守 Set 接口的规范。

TreeSet 源码也比较简单，毕竟只是对 TreeMap 封装了一下，这里不再贴出。

常用集合面试问题总结

之前分析了一部分常用集合的源码，这些集合都各有各的特点，它们的区别也经常出现在面试中，本文最后就对常见的面试题进行下总结。

ArrayList 与 LinkedList 有什么区别？

• 存储结构不同，ArrayList 底层使用数组；LinkedList 使用双向链表
• 性能上，ArrayList 能够随机访问，但增加和删除效率较慢，涉及到内存拷贝；LinkedList 只能顺序或逆序访问，占用内存稍大，但插入删除效率高
• LinkedList 还能当做栈和队列来使用
• 两者均与允许存储 null 也允许存储重复元素
• 两者都是线程不安全的，都可以使用 Collections.synchronizedList(List list) 方法生成一个线程安全的 List

ArrayList 与 Vector 有什么区别？

• ArrayList 非线程安全，Vector 线程安全
• 扩容时，ArrayList 增加 1.5 倍的容量 ; Vector 增加 2倍的容量

JDK 8 对 HashMap 做了哪些优化？

• 底层结构改为单链表 + 数组 + 红黑树的存储结构，在有大量哈希冲突时，将查询时间复杂度从 O(n) 降为 O(log(n))
• 优化哈希函数，将 1.7 中的4次位运算 + 5次异或运算，降低到1次位运算 + 1次异或运算
• 优化扩容机制，1.7 中会重新哈希计算新的位置，而 1.8 则是根据2的次幂扩展机制，不重新计算位置，只根据原散列值计算偏移量，要么位置不变，要么偏移旧数组容量的偏移量

HashMap 和 HashTable 的区别

• HashMap 线程不安全 ; HashTable 线程安全
• HashMap 允许 key 和 Vale 为 null ; HashTable 不允许 key、value 为 null
• HashMap 默认容量为 2^4 且容量一定是 2^n ; HashTable 默认容量是11（素数）, 不一定是 2^n
• HashTable 直接使用模运算计算哈希桶下标 ; HashMap 使用 & 位运算 进行优化

HashMap 和 LinkedHashMap 的区别

• LinkedHashMap 继承自 HashMap 它们有相同的存储结构和扩容机制
• LinkedHashMap 内部需要额外维护一个链表
• LinkedHashMap 按插入顺序对元素进行迭代 ; 而 HashMap 迭代顺序不可预测
• LinkedHashMap 可按按访问顺序遍历元素，用于构建 LRU 缓存

什么是 fast-fail，原理是什么？

fast-fail，即快速失败，在遍历集合的过程中，如果发现集合结构发生了变化，会抛出 ConcurrentModificationException 运行时异常。

注意，在不同步修改的情况下，它不能保证会发生，它只是尽力检测并发修改的错误。

原理是通过一个 modCount 字段来实现的，这个字段记录了列表结构的修改次数，当调用 iterator() 返回迭代器时，会缓存 modCount 当前的值，如果这个值发生了不期望的变化，那么就会在 next, remove 操作中抛出异常。

小结

本文以及之前介绍的集合都是常规的，常用的，非线程安全的集合实现，接下来将会介绍 Java 并发包下的线程安全的集合，以及一些有特殊用途的集合实现。