Set

Set继承了Collection接口，它本身也是一个接口，代表一种不能拥有重复元素的容器类型，更确切的说，集合不包含一对元素e1和e2 ，使得e1.equals(e2) 。

通过Set的一些实现，我们可以发现，Set是基于Map进行实现的，所以Set取值时不保证数据和存入的时候顺序一致，并且不允许空值，不允许重复值。下面我们来看一下Set都给我们提供了哪些方法。

方法

首先，Set提供一些关于本身属性的接口：

  1. /**
  2.  * 返回 set 中的元素个数
  3.  * @return  set中元素个数
  4.  */
  5. int size();
  7. /**
  8.  * 如果set中不包含任何元素，返回true
  9.  * @return  如果set中不包含任何元素，返回true
  10.  */
  11. boolean isEmpty();

当然，也提供了去该集合中查询元素是否存在的接口：

  2. /**
  3.  * 如果set包含指定的元素，则返回 true
  4.  * @param o 指定的元素
  5.  * @return  如果 set 包含指定的元素，则返回 true。
  6.  */
  7. boolean contains(Object o);
  9. /**
  10.  * 如果此 set 包含指定 collection 的所有元素，则返回 true。
  11.  * 如果指定的 collection 也是一个 set，那么当该 collection 是此 set 的 子集 时返回 true。
  12.  * @param c 检查是否包含在此 set 中的 collection
  13.  * @return 如果此 set 包含指定 collection 中的所有元素，则返回 true
  14.  */
  15. boolean containsAll(Collection<?> c);

对于元素进行结构性操作的接口也有几个，这里需要注意的是，在添加元素的时候，如果该元素在集合中已经存在，会导致添加失败并返回一个false。

  1. /**
  2.  * 如果 set 中尚未存在指定的元素，则添加此元素
  3.  * @param e 被添加的元素
  4.  * @return  如果set中存在该元素，添加失败并返回false
  5.  */
  6. boolean add(E e);
  8. /**
  9.  * 如果 set 中没有指定 collection 中的所有元素，则将其添加到此 set 中
  10.  * 如果指定的 collection 也是一个 set，则 addAll 操作会实际修改此 set，
  11.  * 这样其值是两个 set 的一个 并集。如果操作正在进行的同时修改了指定的 collection，则此操作的行为是不确定的。
  12.  * @param c
  13.  * @return
  14.  */
  15. boolean addAll(Collection<? extends E> c);
  17. /**
  18.  * 如果 set 中存在指定的元素，则将其移除（可选操作）。
  19.  * @param o 被删除的元素
  20.  * @return  如果此 set 包含指定的对象，则返回true
  21.  */
  22. boolean remove(Object o);
  24. /**
  25.  * 仅保留 set 中那些包含在指定 collection 中的元素，换句话说，只取两者交集，其余的不管
  26.  * @param c 与set进行判断的集合
  27.  * @return  如果此 set 由于调用而发生更改，则返回 true
  28.  */
  29. boolean retainAll(Collection<?> c);
  32. /**
  33.  * 移除 set 中那些包含在指定 collection 中的元素，也就是说，取交集之外的所有元素
  34.  * @param c 与set进行判断的集合
  35.  * @return  如果此 set 由于调用而发生更改，则返回 true
  36.  */
  37. boolean removeAll(Collection<?> c);
  40. /**
  41.  * 移除此 set 中的所有元素，此调用返回后该 set 将是空的。
  42.  */
  43. void clear();

Set中提供了一个默认的获取可切割迭代器的一个实例，是通过Spliterators方法进行获取

  2. /**
  3.  * 可切割的迭代器，返回的是该set集合的可切割迭代器的一个实例
  4.  * @return
  5.  */
  6. @Override
  7. default Spliterator<E> spliterator() {
  8.     return Spliterators.spliterator(this, Spliterator.DISTINCT);
  9. }

Set的方法到这里就告一段落了，可以看出其中的方法与Collection相比并没有特别大的区别，下面我们来看看作为抽象实现类AbstractSet中给我们提供了哪些基础的实现。

AbstractSet

通过源码我们可以看到，AbstractSet中提供了三个方法的重写，分别是equals，hashCode ，removeAll这三个方法，首先我们来看一下equals和hashCode是如何重写的。

  1. /**
  2.  * 比较指定对象与此 set 的相等性。如果给定对象也是一个 set，
  3.  * 两个 set 的大小相等，并且给定 set 的每个成员都包含在此 set 中，则返回 true。
  4.  * 这确保 equals 方法在 Set 接口的不同实现间正常工作。
  5.  * @param o 被比较的元素
  6.  * @return  如果相等返回true
  7.  */
  8. @Override
  9. public boolean equals(Object o) {
  10.     if (o == this) {
  11.         return true;
  12.     }
  13.     if (!(o instanceof Set)) {
  14.         return false;
  15.     }
  16.     Collection<?> c = (Collection<?>) o;
  17.     if (c.size() != size()) {
  18.         return false;
  19.     }
  20.     try {
  21.         return containsAll(c);
  22.     } catch (ClassCastException unused)   {
  23.         return false;
  24.     } catch (NullPointerException unused) {
  25.         return false;
  26.     }
  27. }
  30. /**
  31.  * 返回此 set 的哈希码值。set 的哈希码被定义为该 set 中元素的哈希码的总和，其中 null 元素的哈希码被定义为 0。
  32.  * 这确保了 s1.equals(s2) 意味着对于任何两个 set s1 和 s2，都有 s1.hashCode()==s2.hashCode()。
  33.  * @return
  34.  */
  35. @Override
  36. public int hashCode() {
  37.     int h = 0;
  38.     Iterator<E> i = iterator();
  39.     while (i.hasNext()) {
  40.         E obj = i.next();
  41.         if (obj != null) {
  42.             h += obj.hashCode();
  43.         }
  44.     }
  45.     return h;
  46. }

可以看出，equals方法保证了调用该方法的两个对象必须是实现了Set接口的，而且具有一些的容错性，即Set的不同子类之间也可以使用equals方法来判断两个对象是否相等，而hashCode方法的计算方式则是利用了迭代器，将每一项不为null的元素的哈希值相加而得到的，这样就可以保证了对于任意的两个对象，他们的哈希值都是相等的，这和equals方法相匹配，符合了Object中对于equals和hashCode方法的要求。

下面还有一个removeAll方法，我们一起来看看

  1. /**
  2.  * 从此 set 中移除包含在指定 collection 中的所有元素
  3.  * 如果指定 collection 也是一个 set，则此操作有效地修改此 set，从而其值成为两个 set 的 不对称差集。
  4.  *
  5.  * @param c 包含将从此 set 中移除的元素的 collection
  6.  * @return 如果此 set 由于调用而发生更改，则返回 true
  7.  */
  8. @Override
  9. public boolean removeAll(Collection<?> c) {
  10.     Objects.requireNonNull(c);
  11.     boolean modified = false;
  12.     //通过在此 set 和指定 collection 上调用 size 方法，此实现可以确定哪一个更小。
  13.     if (size() > c.size()) {
  14.         // 如果此 set 中的元素更少，则该实现将在此 set 上进行迭代，依次检查迭代器返回的每个元素，查看它是否包含在指定的 collection 中。
  15.         for (Iterator<?> i = c.iterator(); i.hasNext(); ) {
  16.             //如果包含它，则使用迭代器的 remove 方法从此 set 中将其移除。
  17.             modified |= remove(i.next());
  18.         }
  19.     } else {
  20.         //如果指定 collection 中的元素更少，则该实现将在指定的 collection 上进行迭代，并使用此 set 的 remove 方法，从此 set 中移除迭代器返回的每个元素。
  21.         for (Iterator<?> i = iterator(); i.hasNext(); ) {
  22.             if (c.contains(i.next())) {
  23.                 i.remove();
  24.                 modified = true;
  25.             }
  26.         }
  27.     }
  28.     return modified;
  29. }

可以看出，这个方法是使用了迭代器进行完成的，这里有些不太理解，为什么仅仅实现了这一个方法。或者说，为什么要在这里实现这个方法。希望知道的朋友可以告诉我~（微信号：cm_950825）。

原创文章，文笔有限，才疏学浅，文中若有不正之处，万望告知。

公众号

Java基础系列（四十六）：Set & AbstractSet - 图1