接口的使用
java.util.Collection

使用 Collection 的包

包	描述
com.sun.jdi.event	这个包定义了 JDI 事件和事件处理。
com.sun.management	这个包包含 JDK 对 java.lang.management API 的标准实现的扩展，还定义了平台的一些其他组件的管理接口。
com.sun.net.httpserver	提供简单的高级 Http 服务 API，可用于构建嵌入式 HTTP 服务。
java.awt	包含用于创建用户界面以及绘制图形和图像的所有类。
java.beans.beancontext	提供与 bean 上下文相关的类和接口。
java.lang.module	通过解析和服务绑定支持模块描述符和创建模块配置的类。
java.security	为安全框架提供类和接口。
java.security.cert	提供用于解析和管理证书、证书撤销列表 (CRL) 和证书路径的类和接口。
java.util	包含集合框架、一些国际化支持类、服务加载器、属性、随机数生成、字符串解析和扫描类、base64 编码和解码、位数组和几个杂项实用程序类。
java.util.concurrent	通常在并发编程中有用的实用程序类。
java.util.concurrent.locks	接口和类提供了一个框架，用于锁定和等待不同于内置同步和监视器的条件。
java.util.jar	提供用于读取和写入 JAR (Java ARchive) 文件格式的类，该文件格式基于标准 ZIP 文件格式，带有可选的清单文件。
java.util.stream	支持对元素流进行函数式操作的类，例如对集合的 map-reduce 转换。
javax.management	为 Java 管理扩展提供核心类。
javax.management.openmbean	提供开放数据类型和 Open MBean 描述符类。
javax.management.relation	提供关系服务的定义。
javax.net.ssl	为安全套接字包提供类。
javax.print.attribute.standard	包 javax.print.attribute.standard 包含特定打印属性的类。
javax.script	脚本 API 由定义 Java 脚本引擎的接口和类组成，并为它们在 Java 应用程序中的使用提供框架。
javax.sql.rowset	JDBC RowSet 实现的标准接口和基类。
javax.swing	提供一组“轻量级”（全 Java 语言）组件，尽可能在所有平台上以相同的方式工作。
javax.tools	为可以从程序中调用的工具提供接口，例如编译器。
jdk.jshell	提供用于创建工具的接口，例如 Read-Eval-Print Loop (REPL)，它以交互方式评估 Java 编程语言代码的“片段”。

Collection 在 com.sun.jdi.event 中的用法

com.sun.jdi.event 中 Collection 的子接口

修饰符和类型	接口	描述
interface	EventSet	目标 VirtualMachine 可以在给定时间创建多个 Event 对象。

Collection 在 com.sun.management 中的用法

com.sun.management 中返回 Collection 的方法

修饰符和类型	方法	描述
Collection<?>	GcInfo.values()

Collection 在 com.sun.net.httpserver 中的用法

com.sun.net.httpserver 中返回 Collection 的方法

修饰符和类型	方法	描述
Collection<List<String>>	Headers.values()

Collection 在 java.awt 中的用法

java.awt 中返回 Collection 的方法

修饰符和类型	方法	描述
Collection<Object>	RenderingHints.values()	返回此 RenderingHints 中包含的值的 Collection 视图。

Collection 在 java.beans.beancontext 中的用法

java.beans.beancontext 中 Collection 的子接口

修饰符和类型	接口	描述
interface	BeanContext	BeanContext 充当 JavaBeans 的逻辑分层容器。
interface	BeanContextServices	BeanContextServices 接口为 BeanContext 提供了一种机制，以向其中的 BeanContextChild 对象公开通用“服务”。

java.beans.beancontext 中实现 Collection 的类

修饰符和类型	类	描述
class	BeanContextServicesSupport	这个帮助器类提供了 java.beans.beancontext.BeanContextServices 接口的实用程序实现。
class	BeanContextSupport	这个帮助器类提供了 java.beans.beancontext.BeanContext 接口的实用程序实现。

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

修饰符和类型	Field	描述
protected Collection	BeanContextMembershipEvent.children	受此事件通知影响的子级列表。

java.beans.beancontext 中的方法，参数类型为 Collection

修饰符和类型	方法	描述
boolean	BeanContextSupport.addAll(Collection c)	将集合添加到子集（不支持）实现必须在层次结构锁和“子”保护字段上同步
boolean	BeanContextSupport.containsAll(Collection c)	测试指定 Collection 中的所有对象是否都是此 BeanContext 的子对象。
protected final void	BeanContextSupport.deserialize(ObjectInputStream ois, Collection coll)	readObject 使用它来反序列化一个集合。
boolean	BeanContextSupport.removeAll(Collection c)	删除所有指定的子项（不支持）实现必须在层次结构锁和“子项”保护字段上同步
boolean	BeanContextSupport.retainAll(Collection c)	仅保留指定的子项（不支持）实现必须在层次锁和“子项”保护字段上同步
protected final void	BeanContextSupport.serialize(ObjectOutputStream oos, Collection<?> coll)	由 writeObject 用于序列化 Collection。

java.beans.beancontext 中的构造函数，参数类型为 Collection

修饰符	构造方法	描述
	BeanContextMembershipEvent(BeanContext bc, Collection changes)	构造一个 BeanContextMembershipEvent

Collection 在 java.lang.module 中的用法

java.lang.module 中的方法，参数类型为 Collection

修饰符和类型	方法	描述
Configuration	Configuration.resolve(ModuleFinder before, ModuleFinder after, Collection<String> roots)	解析根模块的集合，以此配置作为其父级，以创建新配置。
static Configuration	Configuration.resolve(ModuleFinder before, List<Configuration> parents, ModuleFinder after, Collection<String> roots)	解析一组根模块以创建配置。
Configuration	Configuration.resolveAndBind(ModuleFinder before, ModuleFinder after, Collection<String> roots)	使用服务绑定解析根模块的集合，并将此配置作为其父级，以创建新配置。
static Configuration	Configuration.resolveAndBind(ModuleFinder before, List<Configuration> parents, ModuleFinder after, Collection<String> roots)	使用服务绑定解析根模块的集合以创建配置。

Collection 在 java.security 中的用法

java.security 中返回 Collection 的方法

修饰符和类型	方法	描述
Collection<Object>	Provider.values()	返回此 Provider 中包含的属性值的不可修改的 Collection 视图。

Collection 在 java.security.cert 中的用法

java.security.cert 中返回 Collection 的方法

修饰符和类型	方法	描述
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)	返回与指定选择器匹配的 Collection 个，共 Certificate 个。
abstract Collection<? extends CRL>	CertStoreSpi.engineGetCRLs(CRLSelector selector)	返回与指定选择器匹配的 Collection 个 CRL 个。
final Collection<? extends Certificate>	CertificateFactory.generateCertificates(InputStream inStream)	返回从给定输入流 inStream 读取的证书的（可能为空）集合视图。
final Collection<? extends CRL>	CertificateFactory.generateCRLs(InputStream inStream)	返回从给定输入流 inStream 读取的 CRL 的（可能为空）集合视图。
final Collection<? extends Certificate>	CertStore.getCertificates(CertSelector selector)	返回与指定选择器匹配的 Collection 个，共 Certificate 个。
Collection<?>	CollectionCertStoreParameters.getCollection()	返回从中检索到 Certificate 和 CRL 的 Collection。
final Collection<? extends CRL>	CertStore.getCRLs(CRLSelector selector)	返回与指定选择器匹配的 Collection 个 CRL 个。
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 标准的副本。

java.security.cert 中的方法，参数类型为 Collection

修饰符和类型	方法	描述
abstract void	PKIXCertPathChecker.check(Certificate cert, Collection<String> unresolvedCritExts)	使用其内部状态对指定证书执行检查，并从表示未解析的关键扩展的指定 OID 字符串集合中删除它处理的任何关键扩展。
void	X509CRLSelector.setIssuerNames(Collection<?> names)	Note: 使用 X509CRLSelector.setIssuers(Collection) 代替或仅在使用此方法时指定专有名称的字节数组形式。
void	X509CRLSelector.setIssuers(Collection<X500Principal> issuers)	设置 issuerNames 标准。
void	X509CertSelector.setPathToNames(Collection<List<?>> names)	设置 pathToNames 标准。
void	X509CertSelector.setSubjectAlternativeNames(Collection<List<?>> names)	设置 subjectAlternativeNames 标准。

java.security.cert 中的构造函数，参数类型为 Collection

修饰符	构造方法	描述
	CollectionCertStoreParameters(Collection<?> collection)	创建 CollectionCertStoreParameters 的实例，它将允许从指定的 Collection 检索证书和 CRL。

Collection 在 java.util 中的用法

java.util 中 Collection 的子接口

修饰符和类型	接口	描述
interface	Deque<E>	支持两端元素插入和移除的线性集合。
interface	List<E>	有序集合（也称为顺序).
interface	NavigableSet<E>	SortedSet 扩展了导航方法，报告了给定搜索目标的最接近匹配项。
interface	Queue<E>	设计用于在处理之前保存元素的集合。
interface	Set<E>	不包含重复元素的集合。
interface	SortedSet<E>	一个 Set 进一步提供了一个总订购在它的元素上。

java.util 中实现 Collection 的类

修饰符和类型	类	描述
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 和 Deque 接口的双向链表实现。
class	PriorityQueue<E>	基于优先级堆的无限优先级队列。
class	Stack<E>	Stack 类表示对象的后进先出 (LIFO) 堆栈。
class	TreeSet<E>	基于 TreeMap 的 NavigableSet 实现。
class	Vector<E>	Vector 类实现了一个可增长的对象数组。

java.util 中返回 Collection 的方法

修饰符和类型	方法	描述
static <E> Collection<E>	Collections.checkedCollection(Collection<E> c, Class<E> type)	返回指定集合的动态类型安全视图。
static <T> Collection<T>	Collections.synchronizedCollection(Collection<T> c)	返回由指定集合支持的同步（线程安全）集合。
static <T> Collection<T>	Collections.unmodifiableCollection(Collection<? extends T> c)	返回指定集合的 不可修改的视图。
Collection<V>	AbstractMap.values()	返回此map中包含的值的 Collection 视图。
Collection<V>	EnumMap.values()	返回此map中包含的值的 Collection 视图。
Collection<V>	HashMap.values()	返回此map中包含的值的 Collection 视图。
Collection<V>	Hashtable.values()	返回此map中包含的值的 Collection 视图。
Collection<V>	IdentityHashMap.values()	返回此map中包含的值的 Collection 视图。
Collection<V>	LinkedHashMap.values()	返回此map中包含的值的 Collection 视图。
Collection<V>	Map.values()	返回此map中包含的值的 Collection 视图。
Collection<V>	SortedMap.values()	返回此map中包含的值的 Collection 视图。
Collection<V>	TreeMap.values()	返回此map中包含的值的 Collection 视图。
Collection<V>	WeakHashMap.values()	返回此map中包含的值的 Collection 视图。

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

修饰符和类型	方法	描述
boolean	AbstractCollection.addAll(Collection<? extends E> c)	将指定集合中的所有元素添加到此集合（可选操作）。
boolean	AbstractList.addAll(int index, Collection<? extends E> c)	将指定集合中的所有元素插入此list的指定位置（可选操作）。
boolean	AbstractQueue.addAll(Collection<? extends E> c)	将指定集合中的所有元素添加到此队列。
boolean	AbstractSequentialList.addAll(int index, Collection<? extends E> c)	将指定集合中的所有元素插入此list的指定位置（可选操作）。
boolean	ArrayDeque.addAll(Collection<? extends E> c)	将指定集合中的所有元素添加到此双端队列的末尾，就像对每个元素调用 ArrayDeque.addLast(E) 一样，按照集合的迭代器返回它们的顺序。
boolean	ArrayList.addAll(int index, Collection<? extends E> c)	将指定集合中的所有元素插入此list，从指定位置开始。
boolean	ArrayList.addAll(Collection<? extends E> c)	将指定集合中的所有元素追加到此list的末尾，按照它们由指定集合的迭代器返回的顺序。
boolean	Collection.addAll(Collection<? extends E> c)	将指定集合中的所有元素添加到此集合（可选操作）。
static <T> boolean	Collections.addAll(Collection<? super T> c, T... elements)	将所有指定元素添加到指定集合。
boolean	Deque.addAll(Collection<? extends E> c)	将指定集合中的所有元素添加到此双端队列的末尾，就像对每个元素调用 Deque.addLast(E) 一样，按照集合的迭代器返回它们的顺序。
boolean	LinkedList.addAll(int index, Collection<? extends E> c)	将指定集合中的所有元素插入此list，从指定位置开始。
boolean	LinkedList.addAll(Collection<? extends E> c)	按照指定集合的迭代器返回的顺序，将指定集合中的所有元素追加到此list的末尾。
boolean	List.addAll(int index, Collection<? extends E> c)	将指定集合中的所有元素插入此list的指定位置（可选操作）。
boolean	List.addAll(Collection<? extends E> c)	将指定集合中的所有元素附加到此list的末尾，按照它们由指定集合的迭代器返回的顺序（可选操作）。
boolean	Set.addAll(Collection<? extends E> c)	将指定集合中的所有元素添加到此集合（如果它们不存在）（可选操作）。
boolean	TreeSet.addAll(Collection<? extends E> c)	将指定集合中的所有元素添加到此集合。
boolean	Vector.addAll(int index, Collection<? extends E> c)	将指定 Collection 中的所有元素插入此 Vector 的指定位置。
boolean	Vector.addAll(Collection<? extends E> c)	将指定 Collection 中的所有元素附加到此 Vector 的末尾，按照它们由指定 Collection 的 Iterator 返回的顺序。
static <E> Collection<E>	Collections.checkedCollection(Collection<E> c, Class<E> type)	返回指定集合的动态类型安全视图。
boolean	AbstractCollection.containsAll(Collection<?> c)	如果此集合包含指定集合中的所有元素，则返回 true。
boolean	Collection.containsAll(Collection<?> c)	如果此集合包含指定集合中的所有元素，则返回 true。
boolean	List.containsAll(Collection<?> c)	如果此list包含指定集合的所有元素，则返回 true。
boolean	Set.containsAll(Collection<?> c)	如果此集合包含指定集合的所有元素，则返回 true。
boolean	Vector.containsAll(Collection<?> c)	如果此 Vector 包含指定 Collection 中的所有元素，则返回 true。
static <E extends Enum<E>> EnumSet<E>	EnumSet.copyOf(Collection<E> c)	创建从指定集合初始化的枚举集。
static <E> List<E>	List.copyOf(Collection<? extends E> coll)	按迭代顺序返回包含给定 Collection 元素的 不可修改的列表。
static <E> Set<E>	Set.copyOf(Collection<? extends E> coll)	返回包含给定 Collection 元素的 不可修改的集合。
static boolean	Collections.disjoint(Collection<?> c1, Collection<?> c2)	如果两个指定的集合没有共同的元素，则返回 true。
static <T> Enumeration<T>	Collections.enumeration(Collection<T> c)	返回指定集合的枚举。
static List<Locale>	Locale.filter(List<Locale.LanguageRange> priorityList, Collection<Locale> locales)	使用 RFC 4647 中定义的过滤机制返回匹配的 Locale 实例列表。
static List<Locale>	Locale.filter(List<Locale.LanguageRange> priorityList, Collection<Locale> locales, Locale.FilteringMode mode)	使用 RFC 4647 中定义的过滤机制返回匹配的 Locale 实例列表。
static List<String>	Locale.filterTags(List<Locale.LanguageRange> priorityList, Collection<String> tags)	使用 RFC 4647 中定义的基本过滤机制返回匹配语言标签的列表。
static List<String>	Locale.filterTags(List<Locale.LanguageRange> priorityList, Collection<String> tags, Locale.FilteringMode mode)	使用 RFC 4647 中定义的基本过滤机制返回匹配语言标签的列表。
static int	Collections.frequency(Collection<?> c, Object o)	返回指定集合中等于指定对象的元素数。
static Locale	Locale.lookup(List<Locale.LanguageRange> priorityList, Collection<Locale> locales)	使用 RFC 4647 中定义的查找机制返回最匹配语言标记的 Locale 实例。
static String	Locale.lookupTag(List<Locale.LanguageRange> priorityList, Collection<String> tags)	使用 RFC 4647 中定义的查找机制返回最匹配的语言标记。
static <T extends Object & Comparable<? super T>> T	Collections.max(Collection<? extends T> coll)	返回给定集合的最大元素，根据自然排序它的元素。
static <T> T	Collections.max(Collection<? extends T> coll, Comparator<? super T> comp)	根据指定比较器引起的顺序，返回给定集合的最大元素。
static <T extends Object & Comparable<? super T>> T	Collections.min(Collection<? extends T> coll)	返回给定集合的最小元素，根据自然排序它的元素。
static <T> T	Collections.min(Collection<? extends T> coll, Comparator<? super T> comp)	根据指定比较器引发的顺序，返回给定集合的最小元素。
boolean	AbstractCollection.removeAll(Collection<?> c)	删除此集合的所有也包含在指定集合中的元素（可选操作）。
boolean	AbstractSet.removeAll(Collection<?> c)	从此集合中删除指定集合中包含的所有元素（可选操作）。
boolean	ArrayDeque.removeAll(Collection<?> c)
boolean	ArrayList.removeAll(Collection<?> c)	从此list中移除指定集合中包含的所有元素。
boolean	Collection.removeAll(Collection<?> c)	删除此集合的所有也包含在指定集合中的元素（可选操作）。
boolean	List.removeAll(Collection<?> c)	从此list中删除指定集合中包含的所有元素（可选操作）。
boolean	PriorityQueue.removeAll(Collection<?> c)
boolean	Set.removeAll(Collection<?> c)	从此集合中删除指定集合中包含的所有元素（可选操作）。
boolean	Vector.removeAll(Collection<?> c)	从此 Vector 中移除指定 Collection 中包含的所有元素。
boolean	AbstractCollection.retainAll(Collection<?> c)	仅保留此集合中包含在指定集合中的元素（可选操作）。
boolean	ArrayDeque.retainAll(Collection<?> c)
boolean	ArrayList.retainAll(Collection<?> c)	仅保留此list中包含在指定集合中的元素。
boolean	Collection.retainAll(Collection<?> c)	仅保留此集合中包含在指定集合中的元素（可选操作）。
boolean	List.retainAll(Collection<?> c)	仅保留此list中包含在指定集合中的元素（可选操作）。
boolean	PriorityQueue.retainAll(Collection<?> c)
boolean	Set.retainAll(Collection<?> c)	仅保留此集合中包含在指定集合中的元素（可选操作）。
boolean	Vector.retainAll(Collection<?> c)	仅保留此 Vector 中包含在指定 Collection 中的元素。
static <T> Spliterator<T>	Spliterators.spliterator(Collection<? extends T> c, int characteristics)	使用给定集合的 iterator() 作为元素源创建一个 Spliterator，并将其 size() 报告为其初始大小。
static <T> Collection<T>	Collections.synchronizedCollection(Collection<T> c)	返回由指定集合支持的同步（线程安全）集合。
static <T> Collection<T>	Collections.unmodifiableCollection(Collection<? extends T> c)	返回指定集合的 不可修改的视图。

java.util 中的构造函数，参数类型为 Collection

修饰符	构造方法	描述
	ArrayDeque(Collection<? extends E> c)	构造一个包含指定集合元素的双端队列，按照集合迭代器返回元素的顺序。
	ArrayList(Collection<? extends E> c)	构造一个包含指定集合元素的列表，按照集合迭代器返回元素的顺序。
	HashSet(Collection<? extends E> c)	构造一个包含指定集合中的元素的新集合。
	LinkedHashSet(Collection<? extends E> c)	使用与指定集合相同的元素构造一个新的链接哈希集。
	LinkedList(Collection<? extends E> c)	构造一个包含指定集合元素的列表，按照集合迭代器返回元素的顺序。
	PriorityQueue(Collection<? extends E> c)	创建一个包含指定集合中的元素的PriorityQueue。
	TreeSet(Collection<? extends E> c)	构造一个新的树集，包含指定集合中的元素，按照自然排序它的元素。
	Vector(Collection<? extends E> c)	构造一个包含指定集合元素的向量，按照集合迭代器返回元素的顺序。

Collection 在 java.util.concurrent 中的用法

java.util.concurrent 中 Collection 的子接口

修饰符和类型	接口	描述
interface	BlockingDeque<E>	Deque 还支持阻塞操作，在检索元素时等待双端队列变为非空，并在存储元素时等待双端队列中的空间可用。
interface	BlockingQueue<E>	Queue 还支持在检索元素时等待队列变为非空的操作，并在存储元素时等待队列中的空间可用。
interface	TransferQueue<E>	BlockingQueue ，生产者可以在其中等待消费者接收元素。

java.util.concurrent 中实现 Collection 的类

修饰符和类型	类	描述
class	ArrayBlockingQueue<E>	由数组支持的有界 阻塞队列。
static final class	ConcurrentHashMap.KeySetView<K,V>	将 ConcurrentHashMap 视为键的 Set 视图，其中可以通过映射到公共值来选择性地启用添加。
class	ConcurrentLinkedDeque<E>	基于链接节点的无界并发双端队列。
class	ConcurrentLinkedQueue<E>	基于链接节点的无限线程安全队列。
class	ConcurrentSkipListSet<E>	基于 ConcurrentSkipListMap 的可扩展并发 NavigableSet 实现。
class	CopyOnWriteArrayList<E>	ArrayList 的线程安全变体，其中所有可变操作（add、set 等）都是通过制作底层数组的新副本来实现的。
class	CopyOnWriteArraySet<E>	一个 Set 使用内部 CopyOnWriteArrayList 进行所有操作。
class	DelayQueue<E extends Delayed>	一个无限的 阻塞队列 个 Delayed 个元素，其中一个元素只有在其延迟到期时才能被获取。
class	LinkedBlockingDeque<E>	基于链接节点的可选边界 阻塞双端队列。
class	LinkedBlockingQueue<E>	基于链接节点的可选边界 阻塞队列。
class	LinkedTransferQueue<E>	基于链接节点的无界 TransferQueue 。
class	PriorityBlockingQueue<E>	一个无界的 阻塞队列，它使用与类 PriorityQueue 相同的排序规则并提供阻塞检索操作。
class	SynchronousQueue<E>	A 阻塞队列 其中每个插入操作必须等待另一个线程的相应删除操作，反之亦然。

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

修饰符和类型	方法	描述
protected Collection<Thread>	Semaphore.getQueuedThreads()	返回一个集合，其中包含可能正在等待获取的线程。
static <T extends ForkJoinTask<?>> Collection<T>	ForkJoinTask.invokeAll(Collection<T> tasks)	分叉指定集合中的所有任务，当 isDone 为每个任务保留或遇到（未经检查的）异常时返回，在这种情况下会重新抛出异常。
Collection<V>	ConcurrentHashMap.values()	返回此map中包含的值的 Collection 视图。
Collection<V>	ConcurrentSkipListMap.values()	返回此map中包含的值的 Collection 视图。

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

修饰符和类型	方法	描述
boolean	ConcurrentHashMap.KeySetView.addAll(Collection<? extends K> c)	将指定集合中的所有元素添加到此集合中，就像对每个元素调用 ConcurrentHashMap.KeySetView.add(K) 一样。
boolean	ConcurrentLinkedDeque.addAll(Collection<? extends E> c)	将指定集合中的所有元素附加到此双端队列的末尾，按照它们由指定集合的迭代器返回的顺序。
boolean	ConcurrentLinkedQueue.addAll(Collection<? extends E> c)	将指定集合中的所有元素追加到此队列的末尾，按照它们由指定集合的迭代器返回的顺序。
boolean	CopyOnWriteArrayList.addAll(int index, Collection<? extends E> c)	将指定集合中的所有元素插入此list，从指定位置开始。
boolean	CopyOnWriteArrayList.addAll(Collection<? extends E> c)	按照指定集合的迭代器返回的顺序，将指定集合中的所有元素追加到此list的末尾。
boolean	CopyOnWriteArraySet.addAll(Collection<? extends E> c)	如果指定集合中的所有元素不存在，则将它们添加到此集合中。
boolean	LinkedBlockingDeque.addAll(Collection<? extends E> c)	将指定集合中的所有元素附加到此双端队列的末尾，按照它们由指定集合的迭代器返回的顺序。
int	CopyOnWriteArrayList.addAllAbsent(Collection<? extends E> c)	将指定集合中尚未包含在此list中的所有元素追加到此list的末尾，按照它们由指定集合的迭代器返回的顺序。
boolean	CopyOnWriteArrayList.containsAll(Collection<?> c)	如果此list包含指定集合的所有元素，则返回 true。
boolean	CopyOnWriteArraySet.containsAll(Collection<?> c)	如果此集合包含指定集合的所有元素，则返回 true。
boolean	SynchronousQueue.containsAll(Collection<?> c)	除非给定集合为空，否则返回 false。
protected int	ForkJoinPool.drainTasksTo(Collection<? super ForkJoinTask<?>> c)	从调度队列中删除所有可用的未执行的已提交和分叉的任务，并将它们添加到给定的集合中，而不改变它们的执行状态。
int	ArrayBlockingQueue.drainTo(Collection<? super E> c)
int	ArrayBlockingQueue.drainTo(Collection<? super E> c, int maxElements)
int	BlockingQueue.drainTo(Collection<? super E> c)	从此队列中删除所有可用元素并将它们添加到给定集合中。
int	BlockingQueue.drainTo(Collection<? super E> c, int maxElements)	从此队列中最多移除给定数量的可用元素，并将它们添加到给定的集合中。
int	DelayQueue.drainTo(Collection<? super E> c)
int	DelayQueue.drainTo(Collection<? super E> c, int maxElements)
int	LinkedBlockingDeque.drainTo(Collection<? super E> c)
int	LinkedBlockingDeque.drainTo(Collection<? super E> c, int maxElements)
int	LinkedBlockingQueue.drainTo(Collection<? super E> c)
int	LinkedBlockingQueue.drainTo(Collection<? super E> c, int maxElements)
int	LinkedTransferQueue.drainTo(Collection<? super E> c)
int	LinkedTransferQueue.drainTo(Collection<? super E> c, int maxElements)
int	PriorityBlockingQueue.drainTo(Collection<? super E> c)
int	PriorityBlockingQueue.drainTo(Collection<? super E> c, int maxElements)
int	SynchronousQueue.drainTo(Collection<? super E> c)
int	SynchronousQueue.drainTo(Collection<? super E> c, int maxElements)
<T> List<Future<T>>	AbstractExecutorService.invokeAll(Collection<? extends Callable<T>> tasks)
<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)	执行给定的任务，在所有任务完成时返回一个 Futures 列表，其中包含它们的状态和结果。
<T> List<Future<T>>	ExecutorService.invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)	执行给定的任务，返回一个 Futures 列表，当所有任务完成或超时到期时（以先发生者为准），保存它们的状态和结果。
<T> List<Future<T>>	ForkJoinPool.invokeAll(Collection<? extends Callable<T>> tasks)
static <T extends ForkJoinTask<?>> Collection<T>	ForkJoinTask.invokeAll(Collection<T> tasks)	分叉指定集合中的所有任务，当 isDone 为每个任务保留或遇到（未经检查的）异常时返回，在这种情况下会重新抛出异常。
<T> T	AbstractExecutorService.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)	执行给定的任务，返回成功完成的任务的结果（即，没有抛出异常），如果有的话。
<T> T	ExecutorService.invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)	执行给定的任务，返回已成功完成的任务的结果（即，没有抛出异常），如果在给定的超时结束之前有任何执行的话。
boolean	ArrayBlockingQueue.removeAll(Collection<?> c)
boolean	ConcurrentLinkedDeque.removeAll(Collection<?> c)
boolean	ConcurrentLinkedQueue.removeAll(Collection<?> c)
boolean	ConcurrentSkipListSet.removeAll(Collection<?> c)	从此集合中移除指定集合中包含的所有元素。
boolean	CopyOnWriteArrayList.removeAll(Collection<?> c)	从此list中移除指定集合中包含的所有元素。
boolean	CopyOnWriteArraySet.removeAll(Collection<?> c)	从此集合中移除指定集合中包含的所有元素。
boolean	LinkedBlockingDeque.removeAll(Collection<?> c)
boolean	LinkedBlockingQueue.removeAll(Collection<?> c)
boolean	LinkedTransferQueue.removeAll(Collection<?> c)
boolean	PriorityBlockingQueue.removeAll(Collection<?> c)
boolean	SynchronousQueue.removeAll(Collection<?> c)	总是返回 false 。
boolean	ArrayBlockingQueue.retainAll(Collection<?> c)
boolean	ConcurrentLinkedDeque.retainAll(Collection<?> c)
boolean	ConcurrentLinkedQueue.retainAll(Collection<?> c)
boolean	CopyOnWriteArrayList.retainAll(Collection<?> c)	仅保留此list中包含在指定集合中的元素。
boolean	CopyOnWriteArraySet.retainAll(Collection<?> c)	仅保留此集合中包含在指定集合中的元素。
boolean	LinkedBlockingDeque.retainAll(Collection<?> c)
boolean	LinkedBlockingQueue.retainAll(Collection<?> c)
boolean	LinkedTransferQueue.retainAll(Collection<?> c)
boolean	PriorityBlockingQueue.retainAll(Collection<?> c)
boolean	SynchronousQueue.retainAll(Collection<?> c)	总是返回 false 。

java.util.concurrent 中的构造函数，参数类型为 Collection

修饰符	构造方法	描述
	ArrayBlockingQueue(int capacity, boolean fair, Collection<? extends E> c)	创建具有给定（固定）容量、指定访问策略并最初包含给定集合元素的ArrayBlockingQueue，按集合迭代器的遍历顺序添加。
	ConcurrentLinkedDeque(Collection<? extends E> c)	构造一个最初包含给定集合元素的双端队列，按集合迭代器的遍历顺序添加。
	ConcurrentLinkedQueue(Collection<? extends E> c)	创建一个 ConcurrentLinkedQueue 最初包含给定集合的元素，按集合迭代器的遍历顺序添加。
	ConcurrentSkipListSet(Collection<? extends E> c)	构造一个新集合，其中包含指定集合中的元素，并根据元素的 自然排序 对其元素进行排序。
	CopyOnWriteArrayList(Collection<? extends E> c)	创建一个包含指定集合元素的列表，按照集合迭代器返回元素的顺序。
	CopyOnWriteArraySet(Collection<? extends E> c)	创建一个包含指定集合的所有元素的集合。
	DelayQueue(Collection<? extends E> c)	创建一个 DelayQueue 最初包含给定 Delayed 实例集合的元素。
	LinkedBlockingDeque(Collection<? extends E> c)	创建一个容量为 Integer.MAX_VALUE 的 LinkedBlockingDeque，最初包含给定集合的元素，按集合迭代器的遍历顺序添加。
	LinkedBlockingQueue(Collection<? extends E> c)	创建一个容量为 Integer.MAX_VALUE 的 LinkedBlockingQueue，最初包含给定集合的元素，按集合迭代器的遍历顺序添加。
	LinkedTransferQueue(Collection<? extends E> c)	创建一个 LinkedTransferQueue 最初包含给定集合的元素，按集合迭代器的遍历顺序添加。
	PriorityBlockingQueue(Collection<? extends E> c)	创建一个包含指定集合中的元素的PriorityBlockingQueue。

Collection 在 java.util.concurrent.locks 中的用法

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

修饰符和类型	方法	描述
final Collection<Thread>	AbstractQueuedLongSynchronizer.getExclusiveQueuedThreads()	返回一个集合，其中包含可能正在等待以独占模式获取的线程。
final Collection<Thread>	AbstractQueuedSynchronizer.getExclusiveQueuedThreads()	返回一个集合，其中包含可能正在等待以独占模式获取的线程。
protected Collection<Thread>	ReentrantReadWriteLock.getQueuedReaderThreads()	返回一个集合，其中包含可能正在等待获取读锁的线程。
final Collection<Thread>	AbstractQueuedLongSynchronizer.getQueuedThreads()	返回一个集合，其中包含可能正在等待获取的线程。
final Collection<Thread>	AbstractQueuedSynchronizer.getQueuedThreads()	返回一个集合，其中包含可能正在等待获取的线程。
protected Collection<Thread>	ReentrantLock.getQueuedThreads()	返回一个集合，其中包含可能正在等待获取此锁的线程。
protected Collection<Thread>	ReentrantReadWriteLock.getQueuedThreads()	返回一个集合，其中包含可能正在等待获取读锁或写锁的线程。
protected Collection<Thread>	ReentrantReadWriteLock.getQueuedWriterThreads()	返回一个集合，其中包含可能正在等待获取写锁的线程。
final Collection<Thread>	AbstractQueuedLongSynchronizer.getSharedQueuedThreads()	返回一个集合，其中包含可能正在等待以共享模式获取的线程。
final Collection<Thread>	AbstractQueuedSynchronizer.getSharedQueuedThreads()	返回一个集合，其中包含可能正在等待以共享模式获取的线程。
protected final Collection<Thread>	AbstractQueuedLongSynchronizer.ConditionObject.getWaitingThreads()	返回一个集合，其中包含可能正在等待此条件的那些线程。
final Collection<Thread>	AbstractQueuedLongSynchronizer.getWaitingThreads(AbstractQueuedLongSynchronizer.ConditionObject condition)	返回一个集合，其中包含可能正在等待与此同步器关联的给定条件的那些线程。
protected final Collection<Thread>	AbstractQueuedSynchronizer.ConditionObject.getWaitingThreads()	返回一个集合，其中包含可能正在等待此条件的那些线程。
final Collection<Thread>	AbstractQueuedSynchronizer.getWaitingThreads(AbstractQueuedSynchronizer.ConditionObject condition)	返回一个集合，其中包含可能正在等待与此同步器关联的给定条件的那些线程。
protected Collection<Thread>	ReentrantLock.getWaitingThreads(Condition condition)	返回一个集合，其中包含可能正在等待与此锁关联的给定条件的那些线程。
protected Collection<Thread>	ReentrantReadWriteLock.getWaitingThreads(Condition condition)	返回一个集合，其中包含那些可能正在等待与写锁关联的给定条件的线程。

Collection 在 java.util.jar 中的用法

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

修饰符和类型	方法	描述
Collection<Object>	Attributes.values()	返回此 Map 中包含的属性值的 Collection 视图。

Collection 在 java.util.stream 中的用法

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

修饰符和类型	方法	描述
static <T, C extends Collection<T>> Collector<T,?,C>	Collectors.toCollection(Supplier<C> collectionFactory)	返回一个 Collector，它将输入元素累积到一个新的 Collection 中，按遇到的顺序排列。

Collection 在 javax.management 中的用法

javax.management 中实现 Collection 的类

修饰符和类型	类	描述
class	AttributeList	表示 MBean 属性的值列表。

javax.management 中的方法，参数类型为 Collection

修饰符和类型	方法	描述
boolean	AttributeList.addAll(int index, Collection<?> c)	将指定集合中的所有元素插入此list，从指定位置开始。
boolean	AttributeList.addAll(Collection<?> c)	将指定集合中的所有元素追加到此list的末尾，按照它们由指定集合的迭代器返回的顺序。

Collection 在 javax.management.openmbean 中的用法

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

修饰符和类型	方法	描述
Collection<?>	CompositeData.values()	返回此 CompositeData 实例中包含的项目值的不可修改的集合视图。
Collection<?>	CompositeDataSupport.values()	返回此 CompositeData 实例中包含的项目值的不可修改的集合视图。
Collection<?>	TabularData.values()	返回此 TabularData 实例中包含的 CompositeData 值（即行）的集合视图。
Collection<Object>	TabularDataSupport.values()	返回此 TabularDataSupport 实例中包含的行的集合视图。

Collection 在 javax.management.relation 中的用法

javax.management.relation 中实现 Collection 的类

修饰符和类型	类	描述
class	RoleList	RoleList 表示角色列表（角色对象）。
class	RoleUnresolvedList	RoleUnresolvedList 表示 RoleUnresolved 对象的列表，表示由于在尝试访问（读取或写入）角色时遇到的问题而未从关系中检索到的角色。

Collection 在 javax.net.ssl 中的用法

javax.net.ssl 中返回 Collection 的方法

修饰符和类型	方法	描述
final Collection<SNIMatcher>	SSLParameters.getSNIMatchers()	返回包含服务名称指示 (SNI) 参数的所有 SNIMatcher 的 Collection ，如果未设置则返回 null。

javax.net.ssl 中的方法，参数类型为 Collection

修饰符和类型	方法	描述
final void	SSLParameters.setSNIMatchers(Collection<SNIMatcher> matchers)	设置服务名称指示 (SNI) 参数的 SNIMatcher s。

Collection 在 javax.print.attribute.standard 中的用法

javax.print.attribute.standard 中实现 Collection 的类

修饰符和类型	类	描述
final class	JobStateReasons	JobStateReasons 类是打印属性类，一组枚举值，它提供有关作业当前状态的附加信息，即增加作业的JobState 属性值的信息。

javax.print.attribute.standard 中的构造函数，参数类型为 Collection

修饰符	构造方法	描述
	JobStateReasons(Collection<JobStateReason> collection)	构造一个新的作业状态原因属性，其中包含与给定集合相同的 JobStateReason 对象。

Collection 在 javax.script 中的用法

javax.script 中返回 Collection 的方法

修饰符和类型	方法	描述
Collection<Object>	SimpleBindings.values()	返回此map中包含的值的 Collection 视图。

Collection 在 javax.sql.rowset 中的用法

javax.sql.rowset 中返回 Collection 的方法

修饰符和类型	方法	描述
Collection<?>	JoinRowSet.getRowSets()	返回一个 Collection 对象，其中包含已添加到此 JoinRowSet 对象的 RowSet 对象。
Collection<?>	CachedRowSet.toCollection()	将此 CachedRowSet 对象转换为包含此 CachedRowSet 对象的所有数据的 Collection 对象。
Collection<?>	CachedRowSet.toCollection(int column)	将此 CachedRowSet 对象中的指定列转换为 Collection 对象。
Collection<?>	CachedRowSet.toCollection(String column)	将此 CachedRowSet 对象中的指定列转换为 Collection 对象。

Collection 在 javax.swing 中的用法

javax.swing 中的方法，参数类型为 Collection

修饰符和类型	方法	描述
void	DefaultComboBoxModel.addAll(int index, Collection<? extends E> c)	从指定索引开始添加集合中存在的所有元素。
void	DefaultComboBoxModel.addAll(Collection<? extends E> c)	添加集合中存在的所有元素。
void	DefaultListModel.addAll(int index, Collection<? extends E> c)	从指定索引开始添加集合中存在的所有元素。
void	DefaultListModel.addAll(Collection<? extends E> c)	将集合中存在的所有元素添加到列表中。

Collection 在 javax.tools 中的用法

javax.tools 中的方法，参数类型为 Collection

修饰符和类型	方法	描述
default Iterable<? extends JavaFileObject>	StandardJavaFileManager.getJavaFileObjectsFromPaths(Collection<? extends Path> paths)	返回表示给定路径的文件对象。
default void	StandardJavaFileManager.setLocationForModule(JavaFileManager.Location location, String moduleName, Collection<? extends Path> paths)	将给定的搜索路径与给定的模块和位置相关联，该模块和位置必须是面向模块的或输出位置。
default void	StandardJavaFileManager.setLocationFromPaths(JavaFileManager.Location location, Collection<? extends Path> paths)	将给定的搜索路径与给定的位置相关联。

Collection 在 jdk.jshell 中的用法

jdk.jshell 中返回 Collection 的方法

修饰符和类型	方法	描述
abstract Collection<Snippet>	SourceCodeAnalysis.dependents(Snippet snippet)	返回 Snippet 的集合，如果给定的 Snippet 已更新，则可能需要更新。