java.util.concurrent
类 CopyOnWriteArraySet<E>

java.lang.Object
  java.util.AbstractCollection<E>
      java.util.AbstractSet<E>
          java.util.concurrent.CopyOnWriteArraySet<E>

类型参数：

E - 此 collection 中保持的元素类型

所有已实现的接口：

Serializable, Iterable<E>, Collection<E>, Set<E>

public class CopyOnWriteArraySet<E>
extends AbstractSet<E>
implements Serializable

对其所有操作使用 CopyOnWriteArrayList 的 Set。因此，它共享以下相同的基本属性：

• 它最适合于 set 大小通常保持很小、只读操作远多于可变操作以及需要在遍历期间防止线程间冲突的应用程序。
• 它是线程安全的。
• 因为通常需要复制整个基础数组，所以可变操作（添加、设置、移除，等等）的开销巨大。
• 迭代器不支持可变移除操作。
• 使用迭代器进行遍历的速度很快，并且不会与其他线程发生冲突。在构造迭代器时，迭代器依赖于不变的数组快照。

示例用法。 以下代码使用了一个写时复制（copy-on-write）的 set，以维护在状态更新时执行某项操作的一组 Handler 对象。

 class Handler { void handle(); ... }

 class X {
    private final CopyOnWriteArraySet<Handler> handlers = new CopyOnWriteArraySet<Handler>();
    public void addHandler(Handler h) { handlers.add(h); }

    private long internalState;
    private synchronized void changeState() { internalState = ...; }

    public void update() {
       changeState();
       for (Handler handler : handlers)
           handler.handle();
    }
 }
 

此类是 Java Collections Framework 的成员。

从以下版本开始：

1.5

另请参见：

CopyOnWriteArrayList, 序列化表格

构造方法摘要

CopyOnWriteArraySet()
创建一个空 set。

CopyOnWriteArraySet(Collection<? extends E> c)
创建一个包含指定 Collection 中所有元素的 set。

方法摘要

boolean	add(E o) 确保此 collection 包含指定的元素（可选操作）。
boolean	addAll(Collection<? extends E> c) 将指定 collection 中的所有元素添加到此 collection 中（可选操作）。
void	clear() 从此 collection 中移除所有元素（可选操作）。
boolean	contains(Object o) 如果此 collection 包含指定的元素，则返回 true。
boolean	containsAll(Collection<?> c) 如果此 collection 包含指定 collection 中的所有元素，则返回 true。
boolean	isEmpty() 如果此 collection 不包含元素，则返回 true。
Iterator<E>	iterator() 返回在此 collection 中的元素上进行迭代的迭代器。
boolean	remove(Object o) 从此 collection 中移除指定元素的单个实例（如果存在）（可选操作）。
boolean	removeAll(Collection<?> c) 从此 set 中移除包含在指定 collection 中的所有元素（可选操作）。
boolean	retainAll(Collection<?> c) 仅在此 collection 中保留指定 collection 中所包含的元素（可选操作）。
int	size() 返回此 collection 中的元素数。
Object[]	toArray() 返回包含此 collection 中所有元素的数组。
<T> T[]	toArray(T[] a) 返回包含此 collection 中所有元素的数组；返回数组的运行时类型是指定数组的类型。

从类 java.util.AbstractSet 继承的方法

equals, hashCode

从类 java.util.AbstractCollection 继承的方法

toString

从类 java.lang.Object 继承的方法

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

构造方法详细信息

CopyOnWriteArraySet

public CopyOnWriteArraySet()

创建一个空 set。

CopyOnWriteArraySet

public CopyOnWriteArraySet(Collection<? extends E> c)

创建一个包含指定 Collection 中所有元素的 set。

参数：

c - collection

方法详细信息

size

public int size()

从类 AbstractCollection 复制的描述

返回此 collection 中的元素数。如果该 collection 包含多于 Integer.MAX_VALUE 的元素，则返回 Integer.MAX_VALUE。

指定者：

接口 Collection<E> 中的 size

指定者：

接口 Set<E> 中的 size

指定者：

类 AbstractCollection<E> 中的 size

返回：

此 collection 中的元素数。

isEmpty

public boolean isEmpty()

从类 AbstractCollection 复制的描述

如果此 collection 不包含元素，则返回 true。

此实现返回 size() == 0。

指定者：

接口 Collection<E> 中的 isEmpty

指定者：

接口 Set<E> 中的 isEmpty

覆盖：

类 AbstractCollection<E> 中的 isEmpty

返回：

如果此 collection 不包含元素，则返回 true。

contains

public boolean contains(Object o)

从类 AbstractCollection 复制的描述

如果此 collection 包含指定的元素，则返回 true。更正式地说，当且仅当此 collection 至少包含一个满足以下条件的元素 e 时才返回 true：(o==null ? e==null : o.equals(e))。

此实现迭代该 collection 中的元素，并依次检查每个元素以确定其是否与指定的元素相等。

指定者：

接口 Collection<E> 中的 contains

指定者：

接口 Set<E> 中的 contains

覆盖：

类 AbstractCollection<E> 中的 contains

参数：

o - 要检查的对象，以确定其是否包含在此 collection 中。

返回：

如果此 collection 包含指定的元素，则返回 true。

toArray

public Object[] toArray()

从类 AbstractCollection 复制的描述

返回包含此 collection 中所有元素的数组。如果此 collection 保证其迭代器按顺序返回其元素，那么此方法也必须按相同的顺序返回这些元素。返回的数组将是“安全的”，因为此 collection 并不维护对返回数组的任何引用。（换句话说，即使 collection 受到数组的支持，此方法也必须分配一个新的数组）。因此，调用方可以随意修改返回的数组。

此实现会分配返回的数组，并迭代 collection 中的元素，将每个对象引用存储在数组的下一个连续元素中，并从元素 0 开始。

指定者：

接口 Collection<E> 中的 toArray

指定者：

接口 Set<E> 中的 toArray

覆盖：

类 AbstractCollection<E> 中的 toArray

返回：

包含此 collection 中所有元素的数组。

toArray

public <T> T[] toArray(T[] a)

从类 AbstractCollection 复制的描述

返回包含此 collection 中所有元素的数组；返回数组的运行时类型是指定数组的类型。如果指定的数组能容纳该 collection，则在此数组中返回 collection 的元素。否则，将根据指定数组的运行时类型和此 collection 的大小分配一个新数组。

如果指定的数组能容纳 collection，并且有剩余的空间（即数组的元素比 collection 多），那么会将紧挨着 collection 尾部的元素设置为 null（这对确定 collection 的长度很有用，但只有 在调用方知道 collection 不包含任何 null 元素时才可行）。

如果此 collection 保证其迭代器按顺序返回其元素，那么此方法也必须按相同的顺序返回这些元素。

此实现会检查该数组是否足够大，以包含该 collection 中的元素；如果不能包含，则将分配一个具有适当大小和类型的新数组（使用反射）。然后，在该 collection 上进行迭代，将每个对象引用存储在数组的下一个连续元素中，并从元素 0 开始。如果该数组比该 collection 大，则在该 collection 尾部后面的第一个位置存储 null。

指定者：

接口 Collection<E> 中的 toArray

指定者：

接口 Set<E> 中的 toArray

覆盖：

类 AbstractCollection<E> 中的 toArray

参数：

a - 存储此 collection 的元素的数组（如果其足够大）；否则，将为此分配一个具有相同运行时类型的新数组。

返回：

包含此 collection 的元素的数组。

clear

public void clear()

从类 AbstractCollection 复制的描述

从此 collection 中移除所有元素（可选操作）。此调用返回后，该 collection 将为空（除非它抛出异常）。

此实现在此 collection 上进行迭代，并使用 Iterator.remove 操作移除每个元素。为了提高效率，多数实现可能会选择重写此方法。

注意，如果此 collection 的 iterator 方法所返回的迭代器无法实现 remove 方法，并且此 collection 非空，那么此实现将抛出 UnsupportedOperationException。

指定者：

接口 Collection<E> 中的 clear

指定者：

接口 Set<E> 中的 clear

覆盖：

类 AbstractCollection<E> 中的 clear

iterator

public Iterator<E> iterator()

从类 AbstractCollection 复制的描述

返回在此 collection 中的元素上进行迭代的迭代器。

指定者：

接口 Iterable<E> 中的 iterator

指定者：

接口 Collection<E> 中的 iterator

指定者：

接口 Set<E> 中的 iterator

指定者：

类 AbstractCollection<E> 中的 iterator

返回：

在此 collection 中的元素上进行迭代的迭代器。

remove

public boolean remove(Object o)

从类 AbstractCollection 复制的描述

从此 collection 中移除指定元素的单个实例（如果存在）（可选操作）。更正式地说，如果该 collection 包含一个或多个满足 (o==null ? e==null : o.equals(e)) 的元素 e，则移除 e。如果该 collection 包含指定的元素（或等价元素，如果该 collection 随调用的结果发生变化），则返回 true。

此实现在该 collection 上进行迭代，查找指定的元素。如果找到该元素，那么它会使用迭代器的 remove 方法从该 collection 中移除该元素。

注意，如果此 collection 的 iterator 方法所返回的迭代器无法实现 remove 方法，并且此 collection 包含指定的对象，那么此实现会抛出 UnsupportedOperationException。

指定者：

接口 Collection<E> 中的 remove

指定者：

接口 Set<E> 中的 remove

覆盖：

类 AbstractCollection<E> 中的 remove

参数：

o - 要从此 collection 中移除的元素（如果存在）。

返回：

如果该 collection 包含指定的元素,则返回 true。

add

public boolean add(E o)

从类 AbstractCollection 复制的描述

确保此 collection 包含指定的元素（可选操作）。如果此 collection 随调用的结果而发生改变，则返回 true。（如果此 collection 不允许有重复元素，并且已经包含了指定的元素，则返回 false。）支持此操作的 collection 可能限制哪些元素能添加到此 collection 中来。需要特别指出的是，某些 collection 拒绝添加 null 元素，其他一些 collection 则对可以添加的元素类型强加限制。Collection 类应该在其文档中清楚地指定添加元素方面的所有限制。

此实现始终抛出 UnsupportedOperationException。

指定者：

接口 Collection<E> 中的 add

指定者：

接口 Set<E> 中的 add

覆盖：

类 AbstractCollection<E> 中的 add

参数：

o - 确保存在于此 collection 中的元素。

返回：

如果此 collection 随调用的结果而发生改变，则返回 true。

containsAll

public boolean containsAll(Collection<?> c)

从类 AbstractCollection 复制的描述

如果此 collection 包含指定 collection 中的所有元素，则返回 true。

此实现在指定的 collection 上进行迭代，依次检查该迭代器返回的每个元素，查看其是否包含在此 collection 中。如果包含所有元素，则返回 true；否则将返回 false。

指定者：

接口 Collection<E> 中的 containsAll

指定者：

接口 Set<E> 中的 containsAll

覆盖：

类 AbstractCollection<E> 中的 containsAll

参数：

c - 将检查其是否包含在此 collection 中的 collection。

返回：

如果此 collection 包含指定 collection 中的所有元素，则返回 true。

另请参见：

AbstractCollection.contains(Object)

addAll

public boolean addAll(Collection<? extends E> c)

从类 AbstractCollection 复制的描述

将指定 collection 中的所有元素添加到此 collection 中（可选操作）。如果在该操作进行过程中修改了指定的 collection，那么此操作的行为是不明确的。（这意味着，如果指定的 collection 是此 collection，并且此 collection 非空，则此调用的行为是不明确的。）

此实现在指定的 collection 上进行迭代，并依次将迭代器返回的每个对象添加到此 collection 中。

注意，除非重写 add，否则此实现将抛出 UnsupportedOperationException（假定指定的 collection 非空）。

指定者：

接口 Collection<E> 中的 addAll

指定者：

接口 Set<E> 中的 addAll

覆盖：

类 AbstractCollection<E> 中的 addAll

参数：

c - 将其元素添加到此 collection 的 collection。

返回：

如果此 collection 随调用的结果而发生改变，则返回 true。

另请参见：

AbstractCollection.add(Object)

removeAll

public boolean removeAll(Collection<?> c)

从类 AbstractSet 复制的描述

从此 set 中移除包含在指定 collection 中的所有元素（可选操作）。

通过在此 set 和指定 collection 上调用 size 方法，此实现可以确定哪一个更小。如果此 set 中的元素更少，则该实现将在此 set 上进行迭代，依次检查迭代器返回的每个元素，查看它是否包含在指定的 collection 中。如果包含它，则使用迭代器的 remove 方法从此 set 中将其移除。如果指定 collection 中的元素更少，则该实现将在指定的 collection 上进行迭代，并使用此 set 的 remove 方法，从此 set 中移除迭代器返回的每个元素。

注意，如果 iterator 方法返回的迭代器没有实现 remove 方法，则此实现抛出 UnsupportedOperationException。

指定者：

接口 Collection<E> 中的 removeAll

指定者：

接口 Set<E> 中的 removeAll

覆盖：

类 AbstractSet<E> 中的 removeAll

参数：

c - 将从此 set 中移除的元素。

返回：

如果此 set 随调用的结果而发生改变，则返回 true。

另请参见：

AbstractCollection.remove(Object), AbstractCollection.contains(Object)

retainAll

public boolean retainAll(Collection<?> c)

从类 AbstractCollection 复制的描述

仅在此 collection 中保留指定 collection 中所包含的元素（可选操作）。换句话说，移除此 collection 中未包含在指定 collection 中的所有元素。

此实现在此 collection 上进行迭代，依次检查该迭代器返回的每个元素，以查看其是否包含在指定的 collection 中。如果不是，则使用迭代器的 remove 方法将其从此 collection 中移除。

注意，如果 iterator 方法返回的迭代器无法实现 remove 方法，并且此 collection 包含一个或多个在指定 collection 中不存在的元素，那么此实现将抛出 UnsupportedOperationException。

指定者：

接口 Collection<E> 中的 retainAll

指定者：

接口 Set<E> 中的 retainAll

覆盖：

类 AbstractCollection<E> 中的 retainAll

参数：

c - 将保留在此 collection 的元素。

返回：

如果此 collection 随调用的结果而发生改变，则返回 true。

另请参见：

AbstractCollection.remove(Object), AbstractCollection.contains(Object)