Collection - [ Java参考文档 ] - 在线原生手册

目录搜索

文字

概述

软件包

类

使用

树

已过时

索引

帮助

Java^TM 2 Platform
Standard Ed. 6

上一个下一个

框架 无框架

接口 java.util.Collection
的使用

使用 Collection 的软件包
java.awt	包含用于创建用户界面和绘制图形图像的所有类。
java.beans.beancontext	提供与 bean 上下文有关的类和接口。
java.security	为安全框架提供类和接口。
java.security.cert	提供用于解析和管理证书、证书撤消列表 (CRL) 和证书路径的类和接口。
java.util	包含 collection 框架、遗留的 collection 类、事件模型、日期和时间设施、国际化和各种实用工具类（字符串标记生成器、随机数生成器和位数组）。
java.util.concurrent	在并发编程中很常用的实用工具类。
java.util.concurrent.locks	为锁和等待条件提供一个框架的接口和类，它不同于内置同步和监视器。
java.util.jar	提供读写 JAR (Java ARchive) 文件格式的类，该格式基于具有可选清单文件的标准 ZIP 文件格式。
javax.management	提供 Java Management Extensions 的核心类。
javax.management.openmbean	提供开放数据类型和 Open MBean 描述符类。
javax.management.relation	提供 Relation Service 的定义。
javax.print.attribute.standard	包 javax.print.attribute.standard 包括特定打印属性的类。
javax.script	脚本 API 由定义 Java ^TM Scripting Engines 的接口和类组成，并为它们在 Java 应用程序中的使用提供框架。
javax.sql.rowset	JDBC `RowSet` 实现的标准接口和基类。

java.awt 中 Collection 的使用

返回 Collection 的 java.awt 中的方法
`Collection<Object>`	`RenderingHints.values()` 返回此 `RenderinHints` 中所包含键的 `Collection` 视图。

java.beans.beancontext 中 Collection 的使用

java.beans.beancontext 中 Collection 的子接口
`interface`	`BeanContext` BeanContext 是 JavaBean 的逻辑层次容器。
`interface`	`BeanContextServices` BeanContextServices 接口为 BeanContext 提供某种机制，将一般的 "services" 向其中的 BeanContextChild 对象公开。

实现 Collection 的 java.beans.beancontext 中的类
`class`	`BeanContextServicesSupport` 此帮助器类提供 java.beans.beancontext.BeanContextServices 接口的实用工具实现。
`class`	`BeanContextSupport` 此帮助器类提供 java.beans.beancontext.BeanContext 接口的实用工具实现。

声明为 Collection 的 java.beans.beancontext 中的字段
`protected Collection`	`BeanContextMembershipEvent.children` 受此事件通知影响的子级的列表。

参数类型为 Collection 的 java.beans.beancontext 中的方法
`boolean`	`BeanContextSupport.addAll(Collection c)` 将 Collection 添加到 Children（不受支持的）实现的集合，这些实现在层次结构锁定和 "children" 受保护字段上必须是同步的
`boolean`	`BeanContextSupport.containsAll(Collection c)` 测试以查看指定 `Collection` 中的所有对象是否是此 `BeanContext` 的子对象。
`protected void`	`BeanContextSupport.deserialize(ObjectInputStream ois, Collection coll)` readObject 使用此方法来反序列化一个 collection。
`boolean`	`BeanContextSupport.removeAll(Collection c)` 移除所有指定 Children（不受支持的）实现，这些实现在层次结构锁定和 "children" 受保护字段上必须是同步的
`boolean`	`BeanContextSupport.retainAll(Collection c)` 仅保留指定子对象（不受支持的）实现，这些实现在层次结构锁定和 "children" 受保护字段上必须是同步的
`protected void`	`BeanContextSupport.serialize(ObjectOutputStream oos, Collection coll)` writeObject 使用此方法来序列化一个 Collection。

参数类型为 Collection 的 java.beans.beancontext 中的构造方法
`BeanContextMembershipEvent(BeanContext bc, Collection changes)` 构造一个 BeanContextMembershipEvent

java.security 中 Collection 的使用

返回 Collection 的 java.security 中的方法
`Collection<Object>`	`Provider.values()` 返回此 provider 中所包含的属性值的一个不可修改的 Collection 视图。

java.security.cert 中 Collection 的使用

返回 Collection 的 java.security.cert 中的方法
`abstract Collection<? extends Certificate>`	`CertificateFactorySpi.engineGenerateCertificates(InputStream inStream)` 返回从给定输入流 `inStream` 中读取的证书的集合视图（可能为空）。
`abstract Collection<? extends CRL>`	`CertificateFactorySpi.engineGenerateCRLs(InputStream inStream)` 返回从给定输入流 `inStream` 中读取的 CRL 的集合视图（可能为空）。
`abstract Collection<? extends Certificate>`	`CertStoreSpi.engineGetCertificates(CertSelector selector)` 返回与指定选择器匹配的 `Certificate` 的 `Collection`。
`abstract Collection<? extends CRL>`	`CertStoreSpi.engineGetCRLs(CRLSelector selector)` 返回与指定选择器匹配的 `CRL` 的 `Collection`。
`Collection<? extends Certificate>`	`CertificateFactory.generateCertificates(InputStream inStream)` 返回从给定输入流 `inStream` 中读取的证书的集合视图（可能为空）。
`Collection<? extends CRL>`	`CertificateFactory.generateCRLs(InputStream inStream)` 返回从给定输入流 `inStream` 中读取的 CRL 的集合视图（可能为空）。
`Collection<? extends Certificate>`	`CertStore.getCertificates(CertSelector selector)` 返回与指定选择器匹配的 `Certificate` 的 `Collection`。
`Collection<?>`	`CollectionCertStoreParameters.getCollection()` 返回从中获取 `Certificate` 和 `CRL` 的 `Collection`。
`Collection<? extends CRL>`	`CertStore.getCRLs(CRLSelector selector)` 返回与指定选择器匹配的 `CRL` 的 `Collection`。
`Collection<List<?>>`	`X509Certificate.getIssuerAlternativeNames()` 从 `IssuerAltName` 扩展 (OID = 2.5.29.18) 中获取一个发布方替换名称的不可变集合。
`Collection<Object>`	`X509CRLSelector.getIssuerNames()` 返回该 issuerNames 标准的一个副本。
`Collection<X500Principal>`	`X509CRLSelector.getIssuers()` 返回 issuerNames 标准。
`Collection<List<?>>`	`X509CertSelector.getPathToNames()` 返回 pathToNames 标准的一个副本。
`Collection<List<?>>`	`X509CertSelector.getSubjectAlternativeNames()` 返回 subjectAlternativeNames 标准的一个副本。
`Collection<List<?>>`	`X509Certificate.getSubjectAlternativeNames()` 从 `SubjectAltName` 扩展 (OID = 2.5.29.17) 中获取一个主体替换名称的不可变集合。

参数类型为 Collection 的 java.security.cert 中的方法
`abstract void`	`PKIXCertPathChecker.check(Certificate cert, Collection<String> unresolvedCritExts)` 使用其内部状态对指定的证书进行检查，并且将其处理的那些关键扩展从表示未解析的关键扩展的指定 OID 字符串集合中移除。
`void`	`X509CRLSelector.setIssuerNames(Collection<?> names)` 注意：请使用 X509CRLSelector.setIssuers(Collection) 方法，或者使用此方法时仅指定 byte 数组形式的标识名。
`void`	`X509CRLSelector.setIssuers(Collection<X500Principal> issuers)` 设置 issuerNames 标准。
`void`	`X509CertSelector.setPathToNames(Collection<List<?>> names)` 设置 pathToNames 标准。
`void`	`X509CertSelector.setSubjectAlternativeNames(Collection<List<?>> names)` 设置 subjectAlternativeNames 标准。

参数类型为 Collection 的 java.security.cert 中的构造方法
`CollectionCertStoreParameters(Collection<?> collection)` 创建 `CollectionCertStoreParameters` 的一个实例，它允许从指定的 `Collection` 中获取证书和 CRL。

java.util 中 Collection 的使用

java.util 中 Collection 的子接口
`interface`	`Deque<E>` 一个线性 collection，支持在两端插入和移除元素。
`interface`	`List<E>` 有序的 collection（也称为序列）。
`interface`	`NavigableSet<E>` 扩展的 `SortedSet`，具有了为给定搜索目标报告最接近匹配项的导航方法。
`interface`	`Queue<E>` 在处理元素前用于保存元素的 collection。
`interface`	`Set<E>` 一个不包含重复元素的 collection。
`interface`	`SortedSet<E>` 进一步提供关于元素的总体排序的 `Set`。

实现 Collection 的 java.util 中的类
`class`	`AbstractCollection<E>` 此类提供 `Collection` 接口的骨干实现，以最大限度地减少了实现此接口所需的工作。
`class`	`AbstractList<E>` 此类提供 `List` 接口的骨干实现，以最大限度地减少实现“随机访问”数据存储（如数组）支持的该接口所需的工作。
`class`	`AbstractQueue<E>` 此类提供某些 `Queue` 操作的骨干实现。
`class`	`AbstractSequentialList<E>` 此类提供了 `List` 接口的骨干实现，从而最大限度地减少了实现受“连续访问”数据存储（如链接列表）支持的此接口所需的工作。
`class`	`AbstractSet<E>` 此类提供 `Set` 接口的骨干实现，从而最大限度地减少了实现此接口所需的工作。
`class`	`ArrayDeque<E>` `Deque` 接口的大小可变数组的实现。
`class`	`ArrayList<E>` `List` 接口的大小可变数组的实现。
`class`	`EnumSet<E extends Enum<E>>` 与枚举类型一起使用的专用 `Set` 实现。
`class`	`HashSet<E>` 此类实现 `Set` 接口，由哈希表（实际上是一个 `HashMap` 实例）支持。
`class`	`LinkedHashSet<E>` 具有可预知迭代顺序的 `Set` 接口的哈希表和链接列表实现。
`class`	`LinkedList<E>` `List` 接口的链接列表实现。
`class`	`PriorityQueue<E>` 一个基于优先级堆的无界优先级队列。
`class`	`Stack<E>` `Stack` 类表示后进先出（LIFO）的对象堆栈。
`class`	`TreeSet<E>` 基于 `TreeMap` 的 `NavigableSet` 实现。
`class`	`Vector<E>` `Vector` 类可以实现可增长的对象数组。

返回 Collection 的 java.util 中的方法

static


<E> Collection<E>

Collections.checkedCollection(Collection<E> c,
                  Class<E> type)

返回指定 collection 的一个动态类型安全视图。

static


<T> Collection<T>

Collections.synchronizedCollection(Collection<T> c)
返回指定 collection 支持的同步（线程安全的）collection。

static


<T> Collection<T>

Collections.unmodifiableCollection(Collection<? extends T> c)
返回指定 collection 的不可修改视图。

Collection<V> EnumMap.values()
返回此映射中所包含值的 Collection 视图。

Collection<V> IdentityHashMap.values()
返回映射所包含值的 Collection 视图。

Collection<V> TreeMap.values()
返回此映射包含的值的 Collection 视图。

Collection<V> SortedMap.values()
返回在此映射中所包含值的 Collection 视图。

Collection<V> WeakHashMap.values()
返回此映射所包含的值的 Collection 视图。

Collection<V> HashMap.values()
返回此映射所包含的值的 Collection 视图。

Collection<V> AbstractMap.values()
返回此映射中包含的值的 Collection 视图。

Collection<V> Hashtable.values()
返回此映射中包含的键的 Collection 视图。

Collection<V> Map.values()
返回此映射中包含的值的 Collection 视图。

参数类型为 Collection 的 java.util 中的方法

boolean AbstractQueue.addAll(Collection<? extends E> c)
将指定 collection 中的所有元素都添加到此队列中。

boolean TreeSet.addAll(Collection<? extends E> c)
将指定 collection 中的所有元素添加到此 set 中。

boolean LinkedList.addAll(Collection<? extends E> c)
添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序。

boolean ArrayList.addAll(Collection<? extends E> c)
按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾部。

boolean Set.addAll(Collection<? extends E> c)
如果 set 中没有指定 collection 中的所有元素，则将其添加到此 set 中（可选操作）。

boolean Vector.addAll(Collection<? extends E> c)
将指定 Collection 中的所有元素添加到此向量的末尾，按照指定 collection 的迭代器所返回的顺序添加这些元素。

boolean AbstractCollection.addAll(Collection<? extends E> c)
将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。

boolean List.addAll(Collection<? extends E> c)
添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序（可选操作）。

boolean Collection.addAll(Collection<? extends E> c)
将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。

static


<T> boolean

Collections.addAll(Collection<? super T> c,
       T... elements)

将所有指定元素添加到指定 collection 中。

boolean LinkedList.addAll(int index, Collection<? extends E> c)
将指定 collection 中的所有元素从指定位置开始插入此列表。

boolean AbstractSequentialList.addAll(int index, Collection<? extends E> c)
在此列表中指定的位置上插入指定 collection 中的所有元素（可选操作）。

boolean ArrayList.addAll(int index, Collection<? extends E> c)
从指定的位置开始，将指定 collection 中的所有元素插入到此列表中。

boolean Vector.addAll(int index, Collection<? extends E> c)
在指定位置将指定 Collection 中的所有元素插入到此向量中。

boolean AbstractList.addAll(int index, Collection<? extends E> c)
将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。

boolean List.addAll(int index, Collection<? extends E> c)
将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。

static


<E> Collection<E>

Collections.checkedCollection(Collection<E> c,
                  Class<E> type)

返回指定 collection 的一个动态类型安全视图。

boolean Set.containsAll(Collection<?> c)
如果此 set 包含指定 collection 的所有元素，则返回 true。

boolean Vector.containsAll(Collection<?> c)
如果此向量包含指定 Collection 中的所有元素，则返回 true。

boolean AbstractCollection.containsAll(Collection<?> c)
如果此 collection 包含指定 collection 中的所有元素，则返回 true。

boolean List.containsAll(Collection<?> c)
如果列表包含指定 collection 的所有元素，则返回 true。

boolean Collection.containsAll(Collection<?> c)
如果此 collection 包含指定 collection 中的所有元素，则返回 true。

static


<E extends Enum<E>> 

EnumSet<E>

EnumSet.copyOf(Collection<E> c)
创建一个从指定 collection 初始化的枚举 set。

static boolean Collections.disjoint(Collection<?> c1, Collection<?> c2)
如果两个指定 collection 中没有相同的元素，则返回 true。

static


<T> Enumeration<T>

Collections.enumeration(Collection<T> c)
返回一个指定 collection 上的枚举。

static int Collections.frequency(Collection<?> c, Object o)
返回指定 collection 中等于指定对象的元素数。

static


<T extends Object & Comparable<? super T>> 


T

Collections.max(Collection<? extends T> coll)
根据元素的自然顺序，返回给定 collection 的最大元素。

static


<T> T

Collections.max(Collection<? extends T> coll,
    Comparator<? super T> comp)

根据指定比较器产生的顺序，返回给定 collection 的最大元素。

static


<T extends Object & Comparable<? super T>> 


T

Collections.min(Collection<? extends T> coll)
根据元素的自然顺序 返回给定 collection 的最小元素。

static


<T> T

Collections.min(Collection<? extends T> coll,
    Comparator<? super T> comp)

根据指定比较器产生的顺序，返回给定 collection 的最小元素。

boolean AbstractSet.removeAll(Collection<?> c)
从此 set 中移除包含在指定 collection 中的所有元素（可选操作）。

boolean Set.removeAll(Collection<?> c)
移除 set 中那些包含在指定 collection 中的元素（可选操作）。

boolean Vector.removeAll(Collection<?> c)
从此向量中移除包含在指定 Collection 中的所有元素。

boolean AbstractCollection.removeAll(Collection<?> c)
移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。

boolean List.removeAll(Collection<?> c)
从列表中移除指定 collection 中包含的其所有元素（可选操作）。

boolean Collection.removeAll(Collection<?> c)
移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。

boolean Set.retainAll(Collection<?> c)
仅保留 set 中那些包含在指定 collection 中的元素（可选操作）。

boolean Vector.retainAll(Collection<?> c)
在此向量中仅保留包含在指定 Collection 中的元素。

boolean AbstractCollection.retainAll(Collection<?> c)
仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。

boolean List.retainAll(Collection<?> c)
仅在列表中保留指定 collection 中所包含的元素（可选操作）。

boolean Collection.retainAll(Collection<?> c)
仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。

static


<T> Collection<T>

Collections.synchronizedCollection(Collection<T> c)
返回指定 collection 支持的同步（线程安全的）collection。

static


<T> Collection<T>

Collections.unmodifiableCollection(Collection<? extends T> c)
返回指定 collection 的不可修改视图。

参数类型为 Collection 的 java.util 中的构造方法
`ArrayDeque(Collection<? extends E> c)` 构造一个包含指定 collection 的元素的双端队列，这些元素按 collection 的迭代器返回的顺序排列。
`ArrayList(Collection<? extends E> c)` 构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。
`HashSet(Collection<? extends E> c)` 构造一个包含指定 collection 中的元素的新 set。
`LinkedHashSet(Collection<? extends E> c)` 构造一个与指定 collection 中的元素相同的新链接哈希 set。
`LinkedList(Collection<? extends E> c)` 构造一个包含指定 collection 中的元素的列表，这些元素按其 collection 的迭代器返回的顺序排列。
`PriorityQueue(Collection<? extends E> c)` 创建包含指定 collection 中元素的 `PriorityQueue`。
`TreeSet(Collection<? extends E> c)` 构造一个包含指定 collection 元素的新 TreeSet，它按照其元素的自然顺序进行排序。
`Vector(Collection<? extends E> c)` 构造一个包含指定 collection 中的元素的向量，这些元素按其 collection 的迭代器返回元素的顺序排列。

java.util.concurrent 中 Collection 的使用

java.util.concurrent 中 Collection 的子接口
`interface`	`BlockingDeque<E>` 支持两个附加操作的 `Queue`，这两个操作是：获取元素时等待双端队列变为非空；存储元素时等待双端队列中的空间变得可用。
`interface`	`BlockingQueue<E>` 支持两个附加操作的 `Queue`，这两个操作是：获取元素时等待队列变为非空，以及存储元素时等待空间变得可用。

实现 Collection 的 java.util.concurrent 中的类
`class`	`ArrayBlockingQueue<E>` 一个由数组支持的有界阻塞队列。
`class`	`ConcurrentLinkedQueue<E>` 一个基于链接节点的无界线程安全队列。
`class`	`ConcurrentSkipListSet<E>` 一个基于 `ConcurrentSkipListMap` 的可缩放并发 `NavigableSet` 实现。
`class`	`CopyOnWriteArrayList<E>` `ArrayList` 的一个线程安全的变体，其中所有可变操作（`add`、`set` 等等）都是通过对底层数组进行一次新的复制来实现的。
`class`	`CopyOnWriteArraySet<E>` 对其所有操作使用内部 `CopyOnWriteArrayList` 的 `Set`。
`class`	`DelayQueue<E extends Delayed>` `Delayed` 元素的一个无界阻塞队列，只有在延迟期满时才能从中提取元素。
`class`	`LinkedBlockingDeque<E>` 一个基于已链接节点的、任选范围的阻塞双端队列。
`class`	`LinkedBlockingQueue<E>` 一个基于已链接节点的、范围任意的 blocking queue。
`class`	`PriorityBlockingQueue<E>` 一个无界阻塞队列，它使用与类 `PriorityQueue` 相同的顺序规则，并且提供了阻塞获取操作。
`class`	`SynchronousQueue<E>` 一种阻塞队列，其中每个插入操作必须等待另一个线程的对应移除操作，反之亦然。

返回 Collection 的 java.util.concurrent 中的方法
`protected Collection<Thread>`	`Semaphore.getQueuedThreads()` 返回一个 collection，包含可能等待获取的线程。
`Collection<V>`	`ConcurrentSkipListMap.values()` 返回此映射中所包含值的 `Collection` 视图。
`Collection<V>`	`ConcurrentHashMap.values()` 返回此映射中包含的值的 `Collection` 视图。

参数类型为 Collection 的 java.util.concurrent 中的方法

boolean CopyOnWriteArrayList.addAll(Collection<? extends E> c)
按照指定 collection 的迭代器返回元素的顺序，将指定 collection 中的所有元素添加此列表的尾部。

boolean CopyOnWriteArraySet.addAll(Collection<? extends E> c)
如果此 set 中没有指定 collection 中的所有元素，则将它们都添加到此 set 中。

boolean CopyOnWriteArrayList.addAll(int index, Collection<? extends E> c)
从指定位置开始，将指定 collection 的所有元素插入此列表。

int CopyOnWriteArrayList.addAllAbsent(Collection<? extends E> c)
按照指定 collection 的迭代器返回元素的顺序，将指定 collection 中尚未包含在此列表中的所有元素添加列表的尾部。

boolean CopyOnWriteArrayList.containsAll(Collection<?> c)
如果此列表包含指定 collection 的所有元素，则返回 true。

boolean CopyOnWriteArraySet.containsAll(Collection<?> c)
如果此 set 包含指定 collection 的所有元素，则返回 true。

boolean SynchronousQueue.containsAll(Collection<?> c)
除非给定 collection 为空，否则返回 false。

int ArrayBlockingQueue.drainTo(Collection<? super E> c)

int BlockingQueue.drainTo(Collection<? super E> c)
移除此队列中所有可用的元素，并将它们添加到给定 collection 中。

int DelayQueue.drainTo(Collection<? super E> c)

int LinkedBlockingDeque.drainTo(Collection<? super E> c)

int LinkedBlockingQueue.drainTo(Collection<? super E> c)

int PriorityBlockingQueue.drainTo(Collection<? super E> c)

int SynchronousQueue.drainTo(Collection<? super E> c)

int ArrayBlockingQueue.drainTo(Collection<? super E> c, int maxElements)

int BlockingQueue.drainTo(Collection<? super E> c, int maxElements)
最多从此队列中移除给定数量的可用元素，并将这些元素添加到给定 collection 中。

int DelayQueue.drainTo(Collection<? super E> c, int maxElements)

int LinkedBlockingDeque.drainTo(Collection<? super E> c, int maxElements)

int LinkedBlockingQueue.drainTo(Collection<? super E> c, int maxElements)

int PriorityBlockingQueue.drainTo(Collection<? super E> c, int maxElements)

int SynchronousQueue.drainTo(Collection<? super E> c, int maxElements)




<T> List<Future<T>>

AbstractExecutorService.invokeAll(Collection<? extends Callable<T>> tasks)




<T> List<Future<T>>

ExecutorService.invokeAll(Collection<? extends Callable<T>> tasks)
执行给定的任务，当所有任务完成时，返回保持任务状态和结果的 Future 列表。




<T> List<Future<T>>

AbstractExecutorService.invokeAll(Collection<? extends Callable<T>> tasks,
          long timeout,
          TimeUnit unit)




<T> List<Future<T>>

ExecutorService.invokeAll(Collection<? extends Callable<T>> tasks,
          long timeout,
          TimeUnit unit)

执行给定的任务，当所有任务完成或超时期满时（无论哪个首先发生），返回保持任务状态和结果的 Future 列表。




<T> T

AbstractExecutorService.invokeAny(Collection<? extends Callable<T>> tasks)




<T> T

ExecutorService.invokeAny(Collection<? extends Callable<T>> tasks)
执行给定的任务，如果某个任务已成功完成（也就是未抛出异常），则返回其结果。




<T> T

AbstractExecutorService.invokeAny(Collection<? extends Callable<T>> tasks,
          long timeout,
          TimeUnit unit)




<T> T

ExecutorService.invokeAny(Collection<? extends Callable<T>> tasks,
          long timeout,
          TimeUnit unit)

执行给定的任务，如果在给定的超时期满前某个任务已成功完成（也就是未抛出异常），则返回其结果。

boolean ConcurrentSkipListSet.removeAll(Collection<?> c)
从此 set 中移除包含在指定 collection 中的所有元素。

boolean CopyOnWriteArrayList.removeAll(Collection<?> c)
从此列表移除所有包含在指定 collection 中的元素。

boolean CopyOnWriteArraySet.removeAll(Collection<?> c)
移除此 set 中包含在指定 collection 中的所有元素。

boolean SynchronousQueue.removeAll(Collection<?> c)
始终返回 false。

boolean CopyOnWriteArrayList.retainAll(Collection<?> c)
只保留此列表中包含在指定 collection 中的元素。

boolean CopyOnWriteArraySet.retainAll(Collection<?> c)
仅保留此 set 中那些包含在指定 collection 中的元素。

boolean SynchronousQueue.retainAll(Collection<?> c)
始终返回 false。

参数类型为 Collection 的 java.util.concurrent 中的构造方法
`ArrayBlockingQueue(int capacity, boolean fair, Collection<? extends E> c)` 创建一个具有给定的（固定）容量和指定访问策略的 `ArrayBlockingQueue`，它最初包含给定 collection 的元素，并以 collection 迭代器的遍历顺序添加元素。
`ConcurrentLinkedQueue(Collection<? extends E> c)` 创建一个最初包含给定 collection 元素的 `ConcurrentLinkedQueue`，按照此 collection 迭代器的遍历顺序来添加元素。
`ConcurrentSkipListSet(Collection<? extends E> c)` 构造一个包含指定 collection 中元素的新 set，这个新 set 按照元素的自然顺序对其进行排序。
`CopyOnWriteArrayList(Collection<? extends E> c)` 创建一个按 collection 的迭代器返回元素的顺序包含指定 collection 元素的列表。
`CopyOnWriteArraySet(Collection<? extends E> c)` 创建一个包含指定 collection 所有元素的 set。
`DelayQueue(Collection<? extends E> c)` 创建一个最初包含 `Delayed` 实例的给定 collection 元素的 `DelayQueue`。
`LinkedBlockingDeque(Collection<? extends E> c)` 创建一个容量为 `Integer.MAX_VALUE` 的 `LinkedBlockingDeque`，最初包含给定 collection 的元素，以该 collection 迭代器的遍历顺序添加。
`LinkedBlockingQueue(Collection<? extends E> c)` 创建一个容量是 `Integer.MAX_VALUE` 的 `LinkedBlockingQueue`，最初包含给定 collection 的元素，元素按该 collection 迭代器的遍历顺序添加。
`PriorityBlockingQueue(Collection<? extends E> c)` 创建一个包含指定 collection 元素的 `PriorityBlockingQueue`。

java.util.concurrent.locks 中 Collection 的使用

返回 Collection 的 java.util.concurrent.locks 中的方法
`Collection<Thread>`	`AbstractQueuedLongSynchronizer.getExclusiveQueuedThreads()` 返回一个 collection，该 collection 包含正以独占模式等待获取的线程。
`Collection<Thread>`	`AbstractQueuedSynchronizer.getExclusiveQueuedThreads()` 返回包含可能正以独占模式等待获取的线程 collection。
`protected Collection<Thread>`	`ReentrantReadWriteLock.getQueuedReaderThreads()` 返回一个 collection，它包含可能正在等待获取读取锁的线程。
`Collection<Thread>`	`AbstractQueuedLongSynchronizer.getQueuedThreads()` 返回一个 collection，该 collection 包含正在等待获取的线程。
`protected Collection<Thread>`	`ReentrantReadWriteLock.getQueuedThreads()` 返回一个 collection，它包含可能正在等待获取读取或写入锁的线程。
`Collection<Thread>`	`AbstractQueuedSynchronizer.getQueuedThreads()` 返回包含可能正在等待获取的线程 collection。
`protected Collection<Thread>`	`ReentrantLock.getQueuedThreads()` 返回一个 collection，它包含可能正等待获取此锁的线程。
`protected Collection<Thread>`	`ReentrantReadWriteLock.getQueuedWriterThreads()` 返回一个 collection，它包含可能正在等待获取写入锁的线程。
`Collection<Thread>`	`AbstractQueuedLongSynchronizer.getSharedQueuedThreads()` 返回一个 collection，该 collection 包含正以共享模式等待获取的线程。
`Collection<Thread>`	`AbstractQueuedSynchronizer.getSharedQueuedThreads()` 返回包含可能正以共享模式等待获取的线程 collection。
`protected Collection<Thread>`	`AbstractQueuedLongSynchronizer.ConditionObject.getWaitingThreads()` 返回一个 collection，该 collection 包含那些正在此条件等待的线程。
`protected Collection<Thread>`	`AbstractQueuedSynchronizer.ConditionObject.getWaitingThreads()` 返回包含那些可能正在等待此条件的线程 collection。
`Collection<Thread>`	`AbstractQueuedLongSynchronizer.getWaitingThreads(AbstractQueuedLongSynchronizer.ConditionObject condition)` 返回一个 collection，该 collection 包含那些正在与此同步器关联的给定条件上等待的线程。
`Collection<Thread>`	`AbstractQueuedSynchronizer.getWaitingThreads(AbstractQueuedSynchronizer.ConditionObject condition)` 返回一个 collection，其中包含可能正在等待与此同步器有关的给定条件的那些线程。
`protected Collection<Thread>`	`ReentrantReadWriteLock.getWaitingThreads(Condition condition)` 返回一个 collection，它包含可能正在等待与写入锁相关的给定条件的那些线程。
`protected Collection<Thread>`	`ReentrantLock.getWaitingThreads(Condition condition)` 返回一个 collection，它包含可能正在等待与此锁相关给定条件的那些线程。

java.util.jar 中 Collection 的使用

返回 Collection 的 java.util.jar 中的方法
`Collection<Object>`	`Attributes.values()` 返回此 Map 所包含的属性值的 Collection 视图。

javax.management 中 Collection 的使用

实现 Collection 的 javax.management 中的类
`class`	`AttributeList` 表示 MBean 属性值的列表。

参数类型为 Collection 的 javax.management 中的方法
`boolean`	`AttributeList.addAll(Collection<?> c)`
`boolean`	`AttributeList.addAll(int index, Collection<?> c)`

javax.management.openmbean 中 Collection 的使用

返回 Collection 的 javax.management.openmbean 中的方法
`Collection<?>`	`CompositeData.values()` 返回此 `CompositeData` 实例中所包含项值的不可修改的 Collection 视图。
`Collection<?>`	`CompositeDataSupport.values()` 返回此 `CompositeData` 实例中包含的项值的不可修改的 Collection 视图。
`Collection<?>`	`TabularData.values()` 返回此 `TabularData` 实例中包含的 `CompositeData` 值（即各行）的 collection 视图。
`Collection<Object>`	`TabularDataSupport.values()` 返回包含在此 `TabularDataSupport` 实例中的行的 collection 视图。

javax.management.relation 中 Collection 的使用

实现 Collection 的 javax.management.relation 中的类
`class`	`RoleList` RoleList 表示角色（Role 对象）的列表。
`class`	`RoleUnresolvedList` RoleUnresolvedList 表示 RoleUnresolved 对象的列表，这些对象代表在试图访问角色（进行读取或写入）时遇到问题而无法从关系检索到的角色。

参数类型为 Collection 的 javax.management.relation 中的方法
`boolean`	`RoleList.addAll(Collection<?> c)`
`boolean`	`RoleUnresolvedList.addAll(Collection<?> c)`
`boolean`	`RoleList.addAll(int index, Collection<?> c)`
`boolean`	`RoleUnresolvedList.addAll(int index, Collection<?> c)`

javax.print.attribute.standard 中 Collection 的使用

实现 Collection 的 javax.print.attribute.standard 中的类
`class`	`JobStateReasons` JobStateReasons 类是打印属性类，它是一个枚举值集合，提供了有关作业当前状态的额外信息，即扩充作业的 `JobState` 属性值的信息。

参数类型为 Collection 的 javax.print.attribute.standard 中的构造方法
`JobStateReasons(Collection<JobStateReason> collection)` 构造新的作业状态原因属性，它包含与给定集合相同的 `JobStateReason` 对象。

javax.script 中 Collection 的使用

返回 Collection 的 javax.script 中的方法
`Collection<Object>`	`SimpleBindings.values()` 返回此映射中包含的值的 `Collection` 视图。

javax.sql.rowset 中 Collection 的使用

返回 Collection 的 javax.sql.rowset 中的方法
`Collection<?>`	`JoinRowSet.getRowSets()` 返回一个 `Collection` 对象，包含已经添加到此 `JoinRowSet` 对象的 `RowSet` 对象。
`Collection<?>`	`CachedRowSet.toCollection()` 将此 `CachedRowSet` 对象转换成一个 `Collection` 对象，它包含此 `CachedRowSet` 对象的所有数据。
`Collection<?>`	`CachedRowSet.toCollection(int column)` 将此 `CachedRowSet` 对象中的指定列转换成一个 `Collection` 对象。
`Collection<?>`	`CachedRowSet.toCollection(String column)` 将此 `CachedRowSet` 对象中的指定列转换成一个 `Collection` 对象。

概述