接口 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 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 对象。