概述  软件包  类   使用  树  已过时  索引  帮助 
JavaTM 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 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 对象。
 

概述  软件包  类   使用  树  已过时  索引  帮助 
JavaTM Platform
Standard Ed. 6
 上一个   下一个 框架    无框架    
提交错误或意见
有关更多的 API 参考资料和开发人员文档，请参阅 Java SE 开发人员文档。该文档包含更详细的、面向开发人员的描述，以及总体概述、术语定义、使用技巧和工作代码示例。

版权所有 2007 Sun Microsystems, Inc. 保留所有权利。 请遵守许可证条款。另请参阅文档重新分发政策。