接口 java.util.Collection 的使用 (Java 2 Platform SE 5.0) - JavaTM 2 Platform Standard Edition 5.0 API 规范中文版

概述

软件包

类

使用

树

已过时

索引

帮助

Java^TM 2 Platform
Standard Ed. 5.0

上一个下一个

框架 无框架

接口 java.util.Collection
的使用

使用 Collection 的软件包
java.awt	包含用于创建用户界面和绘制图形图像的所有类。
java.beans.beancontext	提供与 bean 上下文有关的类和接口。
java.security	为安全框架提供类和接口。
java.security.cert	提供用于解析和管理证书、证书撤消列表 (CRL) 和证书路径的类和接口。
java.util	包含集合框架、遗留的 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.sql.rowset	JDBC `RowSet` 实现的标准接口和基类。

java.awt 中 Collection 的使用

返回 Collection 的 java.awt 中的方法

Collection<Object> RenderingHints.values()
返回此 RenderingHints 中包含的值的 Collection 视图。

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

java.beans.beancontext 中 Collection 的使用

java.beans.beancontext 中 Collection 的子接口

interface BeanContext
BeanContext 是 JavaBean 的逻辑层次容器。

interface BeanContextServices
BeanContextServices 接口为 BeanContext 提供某种机制，将一般的 "services" 向其中的 BeanContextChild 对象公开。

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 中的类
`class`	`BeanContextServicesSupport` 此帮助器类提供 java.beans.beancontext.BeanContextServices 接口的实用工具实现。
`class`	`BeanContextSupport` 此帮助器类提供 java.beans.beancontext.BeanContext 接口的实用工具实现。

声明为 Collection 的 java.beans.beancontext 中的字段

protected Collection BeanContextMembershipEvent.children
受此事件通知影响的子级的列表。

声明为 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 中的方法
`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

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

java.security 中 Collection 的使用

返回 Collection 的 java.security 中的方法

Collection<Object> Provider.values()
返回此 provider 中所包含的属性值的一个不可修改的 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<?>> X509Certificate.getSubjectAlternativeNames()
          从 SubjectAltName 扩展 (OID = 2.5.29.17) 中获得一个主体替换名称的不可变集合。

Collection<List<?>> X509CertSelector.getSubjectAlternativeNames()
          返回 subjectAlternativeNames 标准的一个副本。

返回 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<?>>`	`X509Certificate.getSubjectAlternativeNames()` 从 `SubjectAltName` 扩展 (OID = 2.5.29.17) 中获得一个主体替换名称的不可变集合。
`Collection<List<?>>`	`X509CertSelector.getSubjectAlternativeNames()` 返回 subjectAlternativeNames 标准的一个副本。

参数类型为 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 中的方法
`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。

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

java.util 中 Collection 的使用

java.util 中 Collection 的子接口

interface List<E>
          有序的 collection（也称为序列）。

interface Queue<E>
          在处理元素前用于保存元素的集合。

interface Set<E>
          一个不包含重复元素的 collection。

interface SortedSet<E>
          保证迭代器按照元素递增顺序遍历的集合，可以按照元素的自然顺序（参见 Comparable）进行排序，或者按照创建有序集合时提供的 Comparator进行排序。

java.util 中 Collection 的子接口
`interface`	`List<E>` 有序的 collection（也称为序列）。
`interface`	`Queue<E>` 在处理元素前用于保存元素的集合。
`interface`	`Set<E>` 一个不包含重复元素的 collection。
`interface`	`SortedSet<E>` 保证迭代器按照元素递增顺序遍历的集合，可以按照元素的自然顺序（参见 Comparable）进行排序，或者按照创建有序集合时提供的 Comparator进行排序。

实现 Collection 的 java.util 中的类

class AbstractCollection<E>
          此类提供了 Collection 接口的骨干实现，从而最大限度地减少了实现此接口所需的工作。

class AbstractList<E>
          此类提供 List 接口的骨干实现，从而最大限度地减少了实现由“随机访问”数据存储（如数组）支持的接口所需的工作。

class AbstractQueue<E>
          此类提供某些 Queue 操作的骨干实现。

class AbstractSequentialList<E>
          此类提供了 List 接口的骨干实现，从而最大限度地减少了实现受“连续访问”数据存储（如链接列表）支持的此接口所需的工作。

class AbstractSet<E>
          此类提供 Set 接口的骨干实现，从而最大限度地减少了实现此接口所需的工作。

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>
          此类实现 Set 接口，该接口由 TreeMap 实例支持。

class Vector<E>
          Vector 类可以实现可增长的对象数组。

实现 Collection 的 java.util 中的类
`class`	`AbstractCollection<E>` 此类提供了 `Collection` 接口的骨干实现，从而最大限度地减少了实现此接口所需的工作。
`class`	`AbstractList<E>` 此类提供 `List` 接口的骨干实现，从而最大限度地减少了实现由“随机访问”数据存储（如数组）支持的接口所需的工作。
`class`	`AbstractQueue<E>` 此类提供某些 `Queue` 操作的骨干实现。
`class`	`AbstractSequentialList<E>` 此类提供了 `List` 接口的骨干实现，从而最大限度地减少了实现受“连续访问”数据存储（如链接列表）支持的此接口所需的工作。
`class`	`AbstractSet<E>` 此类提供 `Set` 接口的骨干实现，从而最大限度地减少了实现此接口所需的工作。
`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>` 此类实现 `Set` 接口，该接口由 `TreeMap` 实例支持。
`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> Map.values()
          返回此映射中包含的值的 collection 视图。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static <T> boolean Collections.addAll(Collection<? super T> c, T... a)
          将所有指定元素添加到指定 collection 中。

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

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

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

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

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

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

static <E> Collection<E> Collections.checkedCollection(Collection<E> c, Class<E> type)
          返回指定 collection 的一个动态类型安全视图。

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

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

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

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

boolean Set.containsAll(Collection<?> c)
          如果此 set 包含指定 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 Collection.removeAll(Collection<?> c)
          移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。

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

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

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

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

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

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

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

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

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

boolean Set.retainAll(Collection<?> c)
          仅保留 set 中那些包含在指定 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 中的构造方法

ArrayList(Collection<? extends E> c)
          构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。

HashSet(Collection<? extends E> c)
          构造一个包含指定 collection 中的元素的新 set。

LinkedHashSet(Collection<? extends E> c)
          构造一个与指定集合中的元素相同的新链接哈希集合。

LinkedList(Collection<? extends E> c)
          构造一个包含指定集合中的元素的列表，这些元素按其集合的迭代器返回的顺序排列。

PriorityQueue(Collection<? extends E> c)
          创建包含指定集合中元素的 PriorityQueue。

TreeSet(Collection<? extends E> c)
          构造一个新 set，包含指定 collection 中的元素，这个新 set 按照元素的自然顺序 排序。

Vector(Collection<? extends E> c)
          构造一个包含指定集合中的元素的向量，这些元素按其集合的迭代器返回元素的顺序排列。

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

java.util.concurrent 中 Collection 的使用

java.util.concurrent 中 Collection 的子接口

interface BlockingQueue<E>
支持两个附加操作的 Queue，这两个操作是：检索元素时等待队列变为非空，以及存储元素时等待空间变得可用。

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

实现 Collection 的 java.util.concurrent 中的类

class ArrayBlockingQueue<E>
          一个由数组支持的有界阻塞队列。

class ConcurrentLinkedQueue<E>
          一个基于链接节点的、无界的、线程安全的队列。

class CopyOnWriteArrayList<E>
          ArrayList 的一个线程安全的变体，其中所有可变操作（添加、设置，等等）都是通过对基础数组进行一次新的复制来实现的。

class CopyOnWriteArraySet<E>
          对其所有操作使用 CopyOnWriteArrayList 的 Set。

class DelayQueue<E extends Delayed>
          Delayed 元素的一个无界阻塞队列，只有在延迟期满时才能从中提取元素。

class LinkedBlockingQueue<E>
          一个基于已链接节点的、范围任意的 blocking queue。

class PriorityBlockingQueue<E>
          一个无界的阻塞队列，它使用与类 PriorityQueue 相同的顺序规则，并且提供了阻塞检索的操作。

class SynchronousQueue<E>
          一种阻塞队列，其中每个 put 必须等待一个 take，反之亦然。

实现 Collection 的 java.util.concurrent 中的类
`class`	`ArrayBlockingQueue<E>` 一个由数组支持的有界阻塞队列。
`class`	`ConcurrentLinkedQueue<E>` 一个基于链接节点的、无界的、线程安全的队列。
`class`	`CopyOnWriteArrayList<E>` `ArrayList` 的一个线程安全的变体，其中所有可变操作（添加、设置，等等）都是通过对基础数组进行一次新的复制来实现的。
`class`	`CopyOnWriteArraySet<E>` 对其所有操作使用 `CopyOnWriteArrayList` 的 `Set`。
`class`	`DelayQueue<E extends Delayed>` `Delayed` 元素的一个无界阻塞队列，只有在延迟期满时才能从中提取元素。
`class`	`LinkedBlockingQueue<E>` 一个基于已链接节点的、范围任意的 blocking queue。
`class`	`PriorityBlockingQueue<E>` 一个无界的阻塞队列，它使用与类 `PriorityQueue` 相同的顺序规则，并且提供了阻塞检索的操作。
`class`	`SynchronousQueue<E>` 一种阻塞队列，其中每个 `put` 必须等待一个 `take`，反之亦然。

返回 Collection 的 java.util.concurrent 中的方法

protected Collection<Thread> Semaphore.getQueuedThreads()
返回一个 collection，包含可能等待获取的线程。

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

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

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

boolean CopyOnWriteArraySet.addAll(Collection<? extends E> c)


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

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

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

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

boolean CopyOnWriteArraySet.containsAll(Collection<?> c)


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

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


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


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


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


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

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


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


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


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


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


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

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


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

<T> List<Future<T>> AbstractExecutorService.invokeAll(Collection<Callable<T>> tasks)


<T> List<Future<T>> ExecutorService.invokeAll(Collection<Callable<T>> tasks, long timeout, TimeUnit unit)
          执行给定的任务，当所有任务完成或超时期满时（无论哪个首先发生），返回保持任务状态和结果的 Future 列表。

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


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

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


<T> T ExecutorService.invokeAny(Collection<Callable<T>> tasks, long timeout, TimeUnit unit)
          执行给定的任务，如果在给定的超时期满前某个任务已成功完成（也就是未抛出异常），则返回其结果。

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


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

boolean CopyOnWriteArraySet.removeAll(Collection<?> c)


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

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

boolean CopyOnWriteArraySet.retainAll(Collection<?> c)


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

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

ArrayBlockingQueue(int capacity, boolean fair, Collection<? extends E> c)
          创建一个具有给定的（固定）容量和指定访问策略的 ArrayBlockingQueue，它最初包含给定 collection 的元素，并以 collection 迭代器的遍历顺序添加元素。

ConcurrentLinkedQueue(Collection<? extends E> c)
          创建一个最初包含给定 collection 的元素的 ConcurrentLinkedQueue，按照此 collection 迭代器的遍历顺序来添加元素。

CopyOnWriteArrayList(Collection<? extends E> c)
          按照 Collection 的迭代器返回元素的顺序，创建一个包含指定 Collection 的元素的列表。

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

DelayQueue(Collection<? extends E> c)
          创建一个最初包含 Delayed 实例的给定 collection 中的元素的 DelayQueue。

LinkedBlockingQueue(Collection<? extends E> c)
          创建一个容量是 Integer.MAX_VALUE 的 LinkedBlockingQueue，最初包含给定集合的元素，元素按该集合迭代器的遍历顺序添加。

PriorityBlockingQueue(Collection<? extends E> c)
          创建一个包含指定集合中元素的 PriorityBlockingQueue。

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

返回 Collection 的 java.util.concurrent.locks 中的方法

Collection<Thread> AbstractQueuedSynchronizer.getExclusiveQueuedThreads()
          返回包含可能正以独占模式等待获取的线程 collection。

protected Collection<Thread> ReentrantReadWriteLock.getQueuedReaderThreads()
          返回一个 collection，它包含可能正在等待获取读取锁定的线程。

protected Collection<Thread> ReentrantLock.getQueuedThreads()
          返回一个 collection，它包含可能正等待获取此锁定的线程。

Collection<Thread> AbstractQueuedSynchronizer.getQueuedThreads()
          返回包含可能正在等待获取的线程 collection。

protected Collection<Thread> ReentrantReadWriteLock.getQueuedThreads()
          返回一个 collection，它包含可能正在等待获取读取或写入锁定的线程。

protected Collection<Thread> ReentrantReadWriteLock.getQueuedWriterThreads()
          返回一个 collection，它包含可能正在等待获取写入锁定的线程。

Collection<Thread> AbstractQueuedSynchronizer.getSharedQueuedThreads()
          返回包含可能正以共享模式等待获取的线程 collection。

protected Collection<Thread> AbstractQueuedSynchronizer.ConditionObject.getWaitingThreads()
          返回包含那些可能正在等待此条件的线程 collection。

Collection<Thread> AbstractQueuedSynchronizer.getWaitingThreads(AbstractQueuedSynchronizer.ConditionObject condition)
          返回一个 collection，其中包含可能正在等待与此同步器有关的给定条件的那些线程。

protected Collection<Thread> ReentrantLock.getWaitingThreads(Condition condition)
          返回一个 collection，它包含可能正在等待与此锁定相关给定条件的那些线程。

protected Collection<Thread> ReentrantReadWriteLock.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 属性值的列表。

javax.management.openmbean 中 Collection 的使用

返回 Collection 的 javax.management.openmbean 中的方法

Collection TabularDataSupport.values()
          返回包含在此 TabularDataSupport 实例中的行的 collection 视图。

Collection TabularData.values()
          返回此 TabularData 实例中包含的 CompositeData 值（即各行）的 collection 视图。

Collection CompositeDataSupport.values()
          返回此 CompositeData 实例中包含的项值的不可修改的 Collection 视图。

Collection CompositeData.values()
          返回此 CompositeData 实例中所包含项值的不可修改的 Collection 视图。

javax.management.relation 中 Collection 的使用

实现 Collection 的 javax.management.relation 中的类

class RoleList
RoleList 表示角色（Role 对象）的列表。

class RoleUnresolvedList
RoleUnresolvedList 表示 RoleUnresolved 对象的列表，这些对象代表在试图访问（对角色进行读取或写入）时遇到问题而无法从关系检索到的角色。

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.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 对象。

概述