接口 java.util.Collection
的使用

使用 Collection 的软件包

java.util	包含集合框架、遗留的 collection 类、事件模型、日期和时间设施、国际化和各种实用工具类（字符串标记生成器、随机数生成器和位数组）。
java.util.concurrent	在并发编程中很常用的实用工具类。
java.util.concurrent.locks	为锁定和等待条件提供一个框架的接口和类，它不同于内置同步和监视器。
java.util.jar	提供读写 JAR (Java ARchive) 文件格式的类，该格式基于具有可选清单文件的标准 ZIP 文件格式。

java.util 中 Collection 的使用

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 中的方法

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)
构造一个包含指定集合中的元素的向量，这些元素按其集合的迭代器返回元素的顺序排列。

java.util.concurrent 中 Collection 的使用

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 中的方法

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 视图。