模块 java.base
包 java.util

类 HashSet<E>

java.lang.Object
java.util.AbstractCollection <E>
java.util.AbstractSet <E>
java.util.HashSet<E>
类型参数：
E - 此集合维护的元素类型
所有已实现的接口：
Serializable , Cloneable , Iterable<E> , Collection<E> , Set<E>
已知子类：
JobStateReasons , LinkedHashSet
public class HashSet<E> extends AbstractSet <E> implements Set <E>, Cloneable , Serializable
此类实现了 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。它不保证集合的迭代顺序；特别是，它不保证顺序会随着时间的推移保持不变。此类允许 null 元素。

此类为基本操作（add、remove、contains 和 size）提供恒定时间性能，假设散列函数将元素适当地分散在桶中。迭代这个集合需要的时间与 HashSet 实例的大小（元素数量）加上后备 HashMap 实例的“容量”（桶的数量）之和成正比。因此，如果迭代性能很重要，则不要将初始容量设置得太高（或负载因子太低）。

请注意，此实现不是同步的。 如果多个线程同时访问一个散列集，并且至少有一个线程修改了该集，则它必须外部同步。这通常是通过同步一些自然封装集合的对象来实现的。如果不存在这样的对象，则应使用 Collections.synchronizedSet 方法“包装”该集合。这最好在创建时完成，以防止意外的不同步访问集合：

  Set s = Collections.synchronizedSet(new HashSet(...));

此类的 iterator 方法返回的迭代器是快速失败：如果在创建迭代器后的任何时间以任何方式修改集合，除了通过迭代器自己的 remove 方法，迭代器抛出一个 ConcurrentModificationException 。因此，面对并发修改，迭代器会快速干净地失败，而不是冒着在未来不确定的时间出现任意的、不确定的行为的风险。

请注意，无法保证迭代器的快速失败行为，因为一般来说，在存在非同步并发修改的情况下不可能做出任何硬性保证。快速失败迭代器会尽最大努力抛出 ConcurrentModificationException。因此，编写依赖于此异常的正确性的程序是错误的：迭代器的快速失败行为应该只用于检测错误。

此类是 Java 集合框架 的成员。

自从：
1.2
参见：

  • 构造方法详细信息

    • HashSet

      public HashSet()
      构造一个新的空集；后备 HashMap 实例具有默认初始容量 (16) 和负载因子 (0.75)。

    • HashSet

      public HashSet(Collection <? extends E > c)
      构造一个包含指定集合中的元素的新集合。 HashMap 是使用默认加载因子 (0.75) 和足以包含指定集合中的元素的初始容量创建的。
      参数：
      c - 其元素要放入此集合中的集合
      抛出：
      NullPointerException - 如果指定的集合为空

    • HashSet

      public HashSet(int initialCapacity, float loadFactor)
      构造一个新的空集；后备 HashMap 实例具有指定的初始容量和指定的负载因子。
      API 注意：
      要创建初始容量可容纳预期元素数量的 HashSet，请使用 newHashSet 。
      参数：
      initialCapacity - hash map的初始容量
      loadFactor - hash map的负载因子
      抛出：
      IllegalArgumentException - 如果初始容量小于零，或者负载因子为非正数

    • HashSet

      public HashSet(int initialCapacity)
      构造一个新的空集；后备 HashMap 实例具有指定的初始容量和默认负载系数 (0.75)。
      API 注意：
      要创建初始容量可容纳预期元素数量的 HashSet，请使用 newHashSet 。
      参数：
      initialCapacity - 哈希表的初始容量
      抛出：
      IllegalArgumentException - 如果初始容量小于零

  • 方法详情

    • iterator

      public Iterator <E > iterator()
      返回此集合中元素的迭代器。返回的元素没有特定的顺序。
      指定者：
      iterator 在接口 Collection<E> 中
      指定者：
      iterator 在接口 Iterable<E> 中
      指定者：
      iterator 在接口 Set<E> 中
      指定者：
      iterator 在类 AbstractCollection<E> 中
      返回：
      这个集合中元素的迭代器
      参见：

    • size

      public int size()
      返回此集合中的元素数（其基数）。
      指定者：
      size 在接口 Collection<E> 中
      指定者：
      size 在接口 Set<E> 中
      返回：
      该集合中元素的数量（其基数）

    • isEmpty

      public boolean isEmpty()
      如果此集合不包含任何元素，则返回 true。
      指定者：
      isEmpty 在接口 Collection<E> 中
      指定者：
      isEmpty 在接口 Set<E> 中
      重写：
      isEmpty 在类 AbstractCollection<E> 中
      返回：
      true 如果这个集合不包含任何元素

    • contains

      public boolean contains(Object  o)
      如果此集合包含指定元素，则返回 true。更正式地说，返回 true 当且仅当此集合包含元素 e 使得 Objects.equals(o, e) 。
      指定者：
      contains 在接口 Collection<E> 中
      指定者：
      contains 在接口 Set<E> 中
      重写：
      contains 在类 AbstractCollection<E> 中
      参数：
      o - 要测试其在该集合中是否存在的元素
      返回：
      true 如果此集合包含指定元素

    • add

      public boolean add(E  e)
      如果指定的元素不存在，则将其添加到此集合中。更正式地说，如果此集合不包含满足 Objects.equals(e, e2) 的元素 e2，则将指定元素 e 添加到此集合。如果此集合已包含该元素，则调用保持集合不变并返回 false 。
      指定者：
      add 在接口 Collection<E> 中
      指定者：
      add 在接口 Set<E> 中
      重写：
      add 在类 AbstractCollection<E> 中
      参数：
      e - 要添加到此集合的元素
      返回：
      true 如果此集合尚未包含指定元素

    • remove

      public boolean remove(Object  o)
      如果存在，则从此集合中移除指定元素。更正式地说，删除元素 e 这样 Objects.equals(o, e) 如果此集合包含这样的元素。如果此集合包含该元素，则返回 true（或者等效地，如果此集合因调用而更改）。 （一旦调用返回，此集合将不包含该元素。）
      指定者：
      remove 在接口 Collection<E> 中
      指定者：
      remove 在接口 Set<E> 中
      重写：
      remove 在类 AbstractCollection<E> 中
      参数：
      o - 要从此集合中删除的对象（如果存在）
      返回：
      true 如果集合包含指定的元素

    • clear

      public void clear()
      从此集合中删除所有元素。此调用返回后该集合将为空。
      指定者：
      clear 在接口 Collection<E> 中
      指定者：
      clear 在接口 Set<E> 中
      重写：
      clear 在类 AbstractCollection<E> 中

    • clone

      public Object  clone()
      返回此 HashSet 实例的浅表副本：元素本身未被克隆。
      重写：
      clone 在类 Object 中
      返回：
      这个集合的浅拷贝
      参见：

    • spliterator

      public Spliterator <E > spliterator()
      在此集合中的元素上创建 late-binding 和 fail-fast Spliterator 。

      Spliterator 报告 Spliterator.SIZED 和 Spliterator.DISTINCT 。覆盖实施应记录附加特征值的报告。

      指定者：
      spliterator 在接口 Collection<E> 中
      指定者：
      spliterator 在接口 Iterable<E> 中
      指定者：
      spliterator 在接口 Set<E> 中
      返回：
      a Spliterator 覆盖此集合中的元素
      自从：
      1.8

    • toArray

      public Object [] toArray()
      从类复制的描述：AbstractCollection
      返回包含此集合中所有元素的数组。如果此集合对其迭代器返回其元素的顺序作出任何保证，则此方法必须以相同的顺序返回元素。返回数组的 运行时组件类型 是 Object 。

      返回的数组将是“安全的”，因为此集合不维护对它的引用。 （换句话说，即使此集合由数组支持，此方法也必须分配一个新数组）。调用者因此可以自由修改返回的数组。

      指定者：
      toArray 在接口 Collection<E> 中
      指定者：
      toArray 在接口 Set<E> 中
      重写：
      toArray 在类 AbstractCollection<E> 中
      返回：
      一个数组，其 运行时组件类型 为 Object，包含此集合中的所有元素

    • toArray

      public <T> T[] toArray(T[] a)
      从类复制的描述：AbstractCollection
      返回包含此集合中所有元素的数组；返回数组的运行时类型是指定数组的类型。如果集合适合指定的数组，则在其中返回。否则，将使用指定数组的运行时类型和此集合的大小分配一个新数组。

      如果此集合适合指定的数组并有剩余空间（即，数组的元素多于此集合），则紧接集合末尾的数组中的元素设置为 null 。 （这对于确定此集合的长度很有用仅有的如果调用者知道此集合不包含任何 null 元素。）

      如果此集合对其迭代器返回其元素的顺序作出任何保证，则此方法必须以相同的顺序返回元素。

      指定者：
      toArray 在接口 Collection<E> 中
      指定者：
      toArray 在接口 Set<E> 中
      重写：
      toArray 在类 AbstractCollection<E> 中
      类型参数：
      T - 包含集合的数组的组件类型
      参数：
      a - 这个集合的元素要存储到的数组，如果它足够大的话；否则，为此分配一个相同运行时类型的新数组。
      返回：
      包含此集合中所有元素的数组

    • newHashSet

      public static <T> HashSet <T> newHashSet(int numElements)
      创建适合预期元素数量的新的空 HashSet。返回的集合使用默认的加载因子 0.75，它的初始容量通常足够大，因此可以在不调整集合大小的情况下添加预期数量的元素。
      类型参数：
      T - 新集合维护的元素类型
      参数：
      numElements - 预期的元素数量
      返回：
      新创建的集合
      抛出：
      IllegalArgumentException - 如果 numElements 为负
      自从：
      19