## Uses of Interface
java.util.Collection

- Packages that use Collection
  Package | Description
  --- | ---
  java.util |
  java.util.concurrent | Utility classes commonly useful in concurrent programming.
  java.util.concurrent.locks | Interfaces and classes providing a framework for locking and waiting for conditions that is distinct from built-in synchronization and monitors.
  java.util.stream | Classes to support functional-style operations on streams of elements, such as map-reduce transformations on collections.
  org.openide.util | Client API part of the Lookup interfaces.
  org.openide.util.lookup | Support classes for the Registration and `Lookup` extension mechanism.

- - ### Uses of Collection in java.util

    Subinterfaces of Collection in java.util
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `Deque<E>` A linear collection that supports element insertion and removal at both ends.
    `interface` | `List<E>` An ordered collection (also known as a sequence).
    `interface` | `NavigableSet<E>` A `SortedSet` extended with navigation methods reporting closest matches for given search targets.
    `interface` | `Queue<E>` A collection designed for holding elements prior to processing.
    `interface` | `Set<E>` A collection that contains no duplicate elements.
    `interface` | `SortedSet<E>` A `Set` that further provides a total ordering on its elements.

    Classes in java.util that implement Collection
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractCollection<E>` This class provides a skeletal implementation of the `Collection` interface, to minimize the effort required to implement this interface.
    `class` | `AbstractList<E>` This class provides a skeletal implementation of the `List` interface to minimize the effort required to implement this interface backed by a "random access" data store (such as an array).
    `class` | `AbstractQueue<E>` This class provides skeletal implementations of some `Queue` operations.
    `class` | `AbstractSequentialList<E>` This class provides a skeletal implementation of the `List` interface to minimize the effort required to implement this interface backed by a "sequential access" data store (such as a linked list).
    `class` | `AbstractSet<E>` This class provides a skeletal implementation of the `Set` interface to minimize the effort required to implement this interface.
    `class` | `ArrayDeque<E>` Resizable-array implementation of the `Deque` interface.
    `class` | `ArrayList<E>` Resizable-array implementation of the `List` interface.
    `class` | `EnumSet<E extends Enum<E>>` A specialized `Set` implementation for use with enum types.
    `class` | `HashSet<E>` This class implements the `Set` interface, backed by a hash table (actually a `HashMap` instance).
    `class` | `LinkedHashSet<E>` Hash table and linked list implementation of the `Set` interface, with predictable iteration order.
    `class` | `LinkedList<E>` Doubly-linked list implementation of the `List` and `Deque` interfaces.
    `class` | `PriorityQueue<E>` An unbounded priority queue based on a priority heap.
    `class` | `Stack<E>` The `Stack` class represents a last-in-first-out (LIFO) stack of objects.
    `class` | `TreeSet<E>` A `NavigableSet` implementation based on a `TreeMap`.
    `class` | `Vector<E>` The `Vector` class implements a growable array of objects.

    Methods in java.util that return Collection
    Modifier and Type | Method and Description
    --- | ---
    `static <E> Collection<E>` | Collections.`checkedCollection(Collection<E> c, Class<E> type)` Returns a dynamically typesafe view of the specified collection.
    `static <T> Collection<T>` | Collections.`synchronizedCollection(Collection<T> c)` Returns a synchronized (thread-safe) collection backed by the specified collection.
    `static <T> Collection<T>` | Collections.`unmodifiableCollection(Collection<? extends T> c)` Returns an unmodifiable view of the specified collection.
    `Collection<V>` | WeakHashMap.`values()` Returns a `Collection` view of the values contained in this map.
    `Collection<V>` | TreeMap.`values()` Returns a `Collection` view of the values contained in this map.
    `Collection<V>` | SortedMap.`values()` Returns a `Collection` view of the values contained in this map.
    `Collection<V>` | Map.`values()` Returns a `Collection` view of the values contained in this map.
    `Collection<V>` | IdentityHashMap.`values()` Returns a `Collection` view of the values contained in this map.
    `Collection<V>` | Hashtable.`values()` Returns a `Collection` view of the values contained in this map.
    `Collection<V>` | HashMap.`values()` Returns a `Collection` view of the values contained in this map.
    `Collection<V>` | EnumMap.`values()` Returns a `Collection` view of the values contained in this map.
    `Collection<V>` | AbstractMap.`values()` Returns a `Collection` view of the values contained in this map.

    Methods in java.util with parameters of type Collection
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | Vector.`addAll(Collection<? extends E> c)` Appends all of the elements in the specified Collection to the end of this Vector, in the order that they are returned by the specified Collection's Iterator.
    `boolean` | TreeSet.`addAll(Collection<? extends E> c)` Adds all of the elements in the specified collection to this set.
    `boolean` | Set.`addAll(Collection<? extends E> c)` Adds all of the elements in the specified collection to this set if they're not already present (optional operation).
    `boolean` | List.`addAll(Collection<? extends E> c)` Appends all of the elements in the specified collection to the end of this list, in the order that they are returned by the specified collection's iterator (optional operation).
    `boolean` | LinkedList.`addAll(Collection<? extends E> c)` Appends all of the elements in the specified collection to the end of this list, in the order that they are returned by the specified collection's iterator.
    `boolean` | Collection.`addAll(Collection<? extends E> c)` Adds all of the elements in the specified collection to this collection (optional operation).
    `boolean` | ArrayList.`addAll(Collection<? extends E> c)` Appends all of the elements in the specified collection to the end of this list, in the order that they are returned by the specified collection's Iterator.
    `boolean` | AbstractQueue.`addAll(Collection<? extends E> c)` Adds all of the elements in the specified collection to this queue.
    `boolean` | AbstractCollection.`addAll(Collection<? extends E> c)` Adds all of the elements in the specified collection to this collection (optional operation).
    `static <T> boolean` | Collections.`addAll(Collection<? super T> c, T... elements)` Adds all of the specified elements to the specified collection.
    `boolean` | Vector.`addAll(int index, Collection<? extends E> c)` Inserts all of the elements in the specified Collection into this Vector at the specified position.
    `boolean` | List.`addAll(int index, Collection<? extends E> c)` Inserts all of the elements in the specified collection into this list at the specified position (optional operation).
    `boolean` | LinkedList.`addAll(int index, Collection<? extends E> c)` Inserts all of the elements in the specified collection into this list, starting at the specified position.
    `boolean` | ArrayList.`addAll(int index, Collection<? extends E> c)` Inserts all of the elements in the specified collection into this list, starting at the specified position.
    `boolean` | AbstractSequentialList.`addAll(int index, Collection<? extends E> c)` Inserts all of the elements in the specified collection into this list at the specified position (optional operation).
    `boolean` | AbstractList.`addAll(int index, Collection<? extends E> c)` Inserts all of the elements in the specified collection into this list at the specified position (optional operation).
    `static <E> Collection<E>` | Collections.`checkedCollection(Collection<E> c, Class<E> type)` Returns a dynamically typesafe view of the specified collection.
    `boolean` | Vector.`containsAll(Collection<?> c)` Returns true if this Vector contains all of the elements in the specified Collection.
    `boolean` | Set.`containsAll(Collection<?> c)` Returns `true` if this set contains all of the elements of the specified collection.
    `boolean` | List.`containsAll(Collection<?> c)` Returns `true` if this list contains all of the elements of the specified collection.
    `boolean` | Collection.`containsAll(Collection<?> c)` Returns `true` if this collection contains all of the elements in the specified collection.
    `boolean` | AbstractCollection.`containsAll(Collection<?> c)` Returns `true` if this collection contains all of the elements in the specified collection.
    `static <E extends Enum<E>> EnumSet<E>` | EnumSet.`copyOf(Collection<E> c)` Creates an enum set initialized from the specified collection.
    `static boolean` | Collections.`disjoint(Collection<?> c1, Collection<?> c2)` Returns `true` if the two specified collections have no elements in common.
    `static boolean` | Collections.`disjoint(Collection<?> c1, Collection<?> c2)` Returns `true` if the two specified collections have no elements in common.
    `static <T> Enumeration<T>` | Collections.`enumeration(Collection<T> c)` Returns an enumeration over the specified collection.
    `static int` | Collections.`frequency(Collection<?> c, Object o)` Returns the number of elements in the specified collection equal to the specified object.
    `static <T extends Object & Comparable<? super T>> T` | Collections.`max(Collection<? extends T> coll)` Returns the maximum element of the given collection, according to the natural ordering of its elements.
    `static <T> T` | Collections.`max(Collection<? extends T> coll, Comparator<? super T> comp)` Returns the maximum element of the given collection, according to the order induced by the specified comparator.
    `static <T extends Object & Comparable<? super T>> T` | Collections.`min(Collection<? extends T> coll)` Returns the minimum element of the given collection, according to the natural ordering of its elements.
    `static <T> T` | Collections.`min(Collection<? extends T> coll, Comparator<? super T> comp)` Returns the minimum element of the given collection, according to the order induced by the specified comparator.
    `boolean` | Vector.`removeAll(Collection<?> c)` Removes from this Vector all of its elements that are contained in the specified Collection.
    `boolean` | Set.`removeAll(Collection<?> c)` Removes from this set all of its elements that are contained in the specified collection (optional operation).
    `boolean` | List.`removeAll(Collection<?> c)` Removes from this list all of its elements that are contained in the specified collection (optional operation).
    `boolean` | Collection.`removeAll(Collection<?> c)` Removes all of this collection's elements that are also contained in the specified collection (optional operation).
    `boolean` | ArrayList.`removeAll(Collection<?> c)` Removes from this list all of its elements that are contained in the specified collection.
    `boolean` | AbstractSet.`removeAll(Collection<?> c)` Removes from this set all of its elements that are contained in the specified collection (optional operation).
    `boolean` | AbstractCollection.`removeAll(Collection<?> c)` Removes all of this collection's elements that are also contained in the specified collection (optional operation).
    `boolean` | Vector.`retainAll(Collection<?> c)` Retains only the elements in this Vector that are contained in the specified Collection.
    `boolean` | Set.`retainAll(Collection<?> c)` Retains only the elements in this set that are contained in the specified collection (optional operation).
    `boolean` | List.`retainAll(Collection<?> c)` Retains only the elements in this list that are contained in the specified collection (optional operation).
    `boolean` | Collection.`retainAll(Collection<?> c)` Retains only the elements in this collection that are contained in the specified collection (optional operation).
    `boolean` | ArrayList.`retainAll(Collection<?> c)` Retains only the elements in this list that are contained in the specified collection.
    `boolean` | AbstractCollection.`retainAll(Collection<?> c)` Retains only the elements in this collection that are contained in the specified collection (optional operation).
    `static <T> Spliterator<T>` | Spliterators.`spliterator(Collection<? extends T> c, int characteristics)` Creates a `Spliterator` using the given collection's `iterator()` as the source of elements, and reporting its `size()` as its initial size.
    `static <T> Collection<T>` | Collections.`synchronizedCollection(Collection<T> c)` Returns a synchronized (thread-safe) collection backed by the specified collection.
    `static <T> Collection<T>` | Collections.`unmodifiableCollection(Collection<? extends T> c)` Returns an unmodifiable view of the specified collection.

    Constructors in java.util with parameters of type Collection
    Constructor and Description
    `ArrayDeque(Collection<? extends E> c)` Constructs a deque containing the elements of the specified collection, in the order they are returned by the collection's iterator.
    `ArrayList(Collection<? extends E> c)` Constructs a list containing the elements of the specified collection, in the order they are returned by the collection's iterator.
    `HashSet(Collection<? extends E> c)` Constructs a new set containing the elements in the specified collection.
    `LinkedHashSet(Collection<? extends E> c)` Constructs a new linked hash set with the same elements as the specified collection.
    `LinkedList(Collection<? extends E> c)` Constructs a list containing the elements of the specified collection, in the order they are returned by the collection's iterator.
    `PriorityQueue(Collection<? extends E> c)` Creates a `PriorityQueue` containing the elements in the specified collection.
    `TreeSet(Collection<? extends E> c)` Constructs a new tree set containing the elements in the specified collection, sorted according to the natural ordering of its elements.
    `Vector(Collection<? extends E> c)` Constructs a vector containing the elements of the specified collection, in the order they are returned by the collection's iterator.

  - ### Uses of Collection in java.util.concurrent

    Subinterfaces of Collection in java.util.concurrent
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `BlockingDeque<E>` A `Deque` that additionally supports blocking operations that wait for the deque to become non-empty when retrieving an element, and wait for space to become available in the deque when storing an element.
    `interface` | `BlockingQueue<E>` A `Queue` that additionally supports operations that wait for the queue to become non-empty when retrieving an element, and wait for space to become available in the queue when storing an element.
    `interface` | `TransferQueue<E>` A `BlockingQueue` in which producers may wait for consumers to receive elements.

    Classes in java.util.concurrent that implement Collection
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ArrayBlockingQueue<E>` A bounded blocking queue backed by an array.
    `class` | `ConcurrentLinkedDeque<E>` An unbounded concurrent deque based on linked nodes.
    `class` | `ConcurrentLinkedQueue<E>` An unbounded thread-safe queue based on linked nodes.
    `class` | `ConcurrentSkipListSet<E>` A scalable concurrent `NavigableSet` implementation based on a `ConcurrentSkipListMap`.
    `class` | `CopyOnWriteArrayList<E>` A thread-safe variant of `ArrayList` in which all mutative operations (`add`, `set`, and so on) are implemented by making a fresh copy of the underlying array.
    `class` | `CopyOnWriteArraySet<E>` A `Set` that uses an internal `CopyOnWriteArrayList` for all of its operations.
    `class` | `DelayQueue<E extends Delayed>` An unbounded blocking queue of `Delayed` elements, in which an element can only be taken when its delay has expired.
    `class` | `LinkedBlockingDeque<E>` An optionally-bounded blocking deque based on linked nodes.
    `class` | `LinkedBlockingQueue<E>` An optionally-bounded blocking queue based on linked nodes.
    `class` | `LinkedTransferQueue<E>` An unbounded `TransferQueue` based on linked nodes.
    `class` | `PriorityBlockingQueue<E>` An unbounded blocking queue that uses the same ordering rules as class `PriorityQueue` and supplies blocking retrieval operations.
    `class` | `SynchronousQueue<E>` A blocking queue in which each insert operation must wait for a corresponding remove operation by another thread, and vice versa.

    Methods in java.util.concurrent that return Collection
    Modifier and Type | Method and Description
    --- | ---
    `protected Collection<Thread>` | Semaphore.`getQueuedThreads()` Returns a collection containing threads that may be waiting to acquire.
    `static <T extends ForkJoinTask<?>> Collection<T>` | ForkJoinTask.`invokeAll(Collection<T> tasks)` Forks all tasks in the specified collection, returning when `isDone` holds for each task or an (unchecked) exception is encountered, in which case the exception is rethrown.
    `Collection<V>` | ConcurrentSkipListMap.`values()` Returns a `Collection` view of the values contained in this map.
    `Collection<V>` | ConcurrentHashMap.`values()`

    Methods in java.util.concurrent with parameters of type Collection
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | CopyOnWriteArraySet.`addAll(Collection<? extends E> c)` Adds all of the elements in the specified collection to this set if they're not already present.
    `boolean` | CopyOnWriteArrayList.`addAll(Collection<? extends E> c)` Appends all of the elements in the specified collection to the end of this list, in the order that they are returned by the specified collection's iterator.
    `boolean` | ConcurrentLinkedQueue.`addAll(Collection<? extends E> c)` Appends all of the elements in the specified collection to the end of this queue, in the order that they are returned by the specified collection's iterator.
    `boolean` | ConcurrentLinkedDeque.`addAll(Collection<? extends E> c)` Appends all of the elements in the specified collection to the end of this deque, in the order that they are returned by the specified collection's iterator.
    `boolean` | CopyOnWriteArrayList.`addAll(int index, Collection<? extends E> c)` Inserts all of the elements in the specified collection into this list, starting at the specified position.
    `int` | CopyOnWriteArrayList.`addAllAbsent(Collection<? extends E> c)` Appends all of the elements in the specified collection that are not already contained in this list, to the end of this list, in the order that they are returned by the specified collection's iterator.
    `boolean` | SynchronousQueue.`containsAll(Collection<?> c)` Returns `false` unless the given collection is empty.
    `boolean` | CopyOnWriteArraySet.`containsAll(Collection<?> c)` Returns `true` if this set contains all of the elements of the specified collection.
    `boolean` | CopyOnWriteArrayList.`containsAll(Collection<?> c)` Returns `true` if this list contains all of the elements of the specified collection.
    `protected int` | ForkJoinPool.`drainTasksTo(Collection<? super ForkJoinTask<?>> c)` Removes all available unexecuted submitted and forked tasks from scheduling queues and adds them to the given collection, without altering their execution status.
    `int` | SynchronousQueue.`drainTo(Collection<? super E> c)`
    `int` | PriorityBlockingQueue.`drainTo(Collection<? super E> c)`
    `int` | LinkedTransferQueue.`drainTo(Collection<? super E> c)`
    `int` | LinkedBlockingQueue.`drainTo(Collection<? super E> c)`
    `int` | LinkedBlockingDeque.`drainTo(Collection<? super E> c)`
    `int` | DelayQueue.`drainTo(Collection<? super E> c)`
    `int` | BlockingQueue.`drainTo(Collection<? super E> c)` Removes all available elements from this queue and adds them to the given 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` | LinkedTransferQueue.`drainTo(Collection<? super E> c, int maxElements)`
    `int` | LinkedBlockingQueue.`drainTo(Collection<? super E> c, int maxElements)`
    `int` | LinkedBlockingDeque.`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)` Removes at most the given number of available elements from this queue and adds them to the given collection.
    `int` | ArrayBlockingQueue.`drainTo(Collection<? super E> c, int maxElements)`
    `<T> List<Future<T>>` | ForkJoinPool.`invokeAll(Collection<? extends Callable<T>> tasks)`
    `<T> List<Future<T>>` | ExecutorService.`invokeAll(Collection<? extends Callable<T>> tasks)` Executes the given tasks, returning a list of Futures holding their status and results when all complete.
    `<T> List<Future<T>>` | AbstractExecutorService.`invokeAll(Collection<? extends Callable<T>> tasks)`
    `<T> List<Future<T>>` | ExecutorService.`invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)` Executes the given tasks, returning a list of Futures holding their status and results when all complete or the timeout expires, whichever happens first.
    `<T> List<Future<T>>` | AbstractExecutorService.`invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)`
    `static <T extends ForkJoinTask<?>> Collection<T>` | ForkJoinTask.`invokeAll(Collection<T> tasks)` Forks all tasks in the specified collection, returning when `isDone` holds for each task or an (unchecked) exception is encountered, in which case the exception is rethrown.
    `<T> T` | ExecutorService.`invokeAny(Collection<? extends Callable<T>> tasks)` Executes the given tasks, returning the result of one that has completed successfully (i.e., without throwing an exception), if any do.
    `<T> T` | AbstractExecutorService.`invokeAny(Collection<? extends Callable<T>> tasks)`
    `<T> T` | ExecutorService.`invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)` Executes the given tasks, returning the result of one that has completed successfully (i.e., without throwing an exception), if any do before the given timeout elapses.
    `<T> T` | AbstractExecutorService.`invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)`
    `boolean` | SynchronousQueue.`removeAll(Collection<?> c)` Always returns `false`.
    `boolean` | CopyOnWriteArraySet.`removeAll(Collection<?> c)` Removes from this set all of its elements that are contained in the specified collection.
    `boolean` | CopyOnWriteArrayList.`removeAll(Collection<?> c)` Removes from this list all of its elements that are contained in the specified collection.
    `boolean` | ConcurrentSkipListSet.`removeAll(Collection<?> c)` Removes from this set all of its elements that are contained in the specified collection.
    `boolean` | SynchronousQueue.`retainAll(Collection<?> c)` Always returns `false`.
    `boolean` | CopyOnWriteArraySet.`retainAll(Collection<?> c)` Retains only the elements in this set that are contained in the specified collection.
    `boolean` | CopyOnWriteArrayList.`retainAll(Collection<?> c)` Retains only the elements in this list that are contained in the specified collection.

    Constructors in java.util.concurrent with parameters of type Collection
    Constructor and Description
    `ArrayBlockingQueue(int capacity, boolean fair, Collection<? extends E> c)` Creates an `ArrayBlockingQueue` with the given (fixed) capacity, the specified access policy and initially containing the elements of the given collection, added in traversal order of the collection's iterator.
    `ConcurrentLinkedDeque(Collection<? extends E> c)` Constructs a deque initially containing the elements of the given collection, added in traversal order of the collection's iterator.
    `ConcurrentLinkedQueue(Collection<? extends E> c)` Creates a `ConcurrentLinkedQueue` initially containing the elements of the given collection, added in traversal order of the collection's iterator.
    `ConcurrentSkipListSet(Collection<? extends E> c)` Constructs a new set containing the elements in the specified collection, that orders its elements according to their natural ordering.
    `CopyOnWriteArrayList(Collection<? extends E> c)` Creates a list containing the elements of the specified collection, in the order they are returned by the collection's iterator.
    `CopyOnWriteArraySet(Collection<? extends E> c)` Creates a set containing all of the elements of the specified collection.
    `DelayQueue(Collection<? extends E> c)` Creates a `DelayQueue` initially containing the elements of the given collection of `Delayed` instances.
    `LinkedBlockingDeque(Collection<? extends E> c)` Creates a `LinkedBlockingDeque` with a capacity of `Integer.MAX_VALUE`, initially containing the elements of the given collection, added in traversal order of the collection's iterator.
    `LinkedBlockingQueue(Collection<? extends E> c)` Creates a `LinkedBlockingQueue` with a capacity of `Integer.MAX_VALUE`, initially containing the elements of the given collection, added in traversal order of the collection's iterator.
    `LinkedTransferQueue(Collection<? extends E> c)` Creates a `LinkedTransferQueue` initially containing the elements of the given collection, added in traversal order of the collection's iterator.
    `PriorityBlockingQueue(Collection<? extends E> c)` Creates a `PriorityBlockingQueue` containing the elements in the specified collection.

  - ### Uses of Collection in java.util.concurrent.locks

    Methods in java.util.concurrent.locks that return Collection
    Modifier and Type | Method and Description
    --- | ---
    `Collection<Thread>` | AbstractQueuedSynchronizer.`getExclusiveQueuedThreads()` Returns a collection containing threads that may be waiting to acquire in exclusive mode.
    `Collection<Thread>` | AbstractQueuedLongSynchronizer.`getExclusiveQueuedThreads()` Returns a collection containing threads that may be waiting to acquire in exclusive mode.
    `protected Collection<Thread>` | ReentrantReadWriteLock.`getQueuedReaderThreads()` Returns a collection containing threads that may be waiting to acquire the read lock.
    `protected Collection<Thread>` | ReentrantReadWriteLock.`getQueuedThreads()` Returns a collection containing threads that may be waiting to acquire either the read or write lock.
    `protected Collection<Thread>` | ReentrantLock.`getQueuedThreads()` Returns a collection containing threads that may be waiting to acquire this lock.
    `Collection<Thread>` | AbstractQueuedSynchronizer.`getQueuedThreads()` Returns a collection containing threads that may be waiting to acquire.
    `Collection<Thread>` | AbstractQueuedLongSynchronizer.`getQueuedThreads()` Returns a collection containing threads that may be waiting to acquire.
    `protected Collection<Thread>` | ReentrantReadWriteLock.`getQueuedWriterThreads()` Returns a collection containing threads that may be waiting to acquire the write lock.
    `Collection<Thread>` | AbstractQueuedSynchronizer.`getSharedQueuedThreads()` Returns a collection containing threads that may be waiting to acquire in shared mode.
    `Collection<Thread>` | AbstractQueuedLongSynchronizer.`getSharedQueuedThreads()` Returns a collection containing threads that may be waiting to acquire in shared mode.
    `protected Collection<Thread>` | AbstractQueuedSynchronizer.ConditionObject.`getWaitingThreads()` Returns a collection containing those threads that may be waiting on this Condition.
    `protected Collection<Thread>` | AbstractQueuedLongSynchronizer.ConditionObject.`getWaitingThreads()` Returns a collection containing those threads that may be waiting on this Condition.
    `Collection<Thread>` | AbstractQueuedLongSynchronizer.`getWaitingThreads(AbstractQueuedLongSynchronizer.ConditionObject condition)` Returns a collection containing those threads that may be waiting on the given condition associated with this synchronizer.
    `Collection<Thread>` | AbstractQueuedSynchronizer.`getWaitingThreads(AbstractQueuedSynchronizer.ConditionObject condition)` Returns a collection containing those threads that may be waiting on the given condition associated with this synchronizer.
    `protected Collection<Thread>` | ReentrantReadWriteLock.`getWaitingThreads(Condition condition)` Returns a collection containing those threads that may be waiting on the given condition associated with the write lock.
    `protected Collection<Thread>` | ReentrantLock.`getWaitingThreads(Condition condition)` Returns a collection containing those threads that may be waiting on the given condition associated with this lock.

  - ### Uses of Collection in java.util.stream

    Methods in java.util.stream with type parameters of type Collection
    Modifier and Type | Method and Description
    --- | ---
    `static <T,C extends Collection<T>> Collector<T,?,C>` | Collectors.`toCollection(Supplier<C> collectionFactory)` Returns a `Collector` that accumulates the input elements into a new `Collection`, in encounter order.

  - ### Uses of Collection in org.openide.util

    Methods in org.openide.util that return Collection
    Modifier and Type | Method and Description
    --- | ---
    `abstract Collection<? extends T>` | Lookup.Result.`allInstances()` Get all instances in the result.
    `Collection<? extends Lookup.Item<T>>` | Lookup.Result.`allItems()` Get all registered items.
    `<T> Collection<? extends T>` | Lookup.`lookupAll(Class<T> clazz)` Find all instances corresponding to a given class.

  - ### Uses of Collection in org.openide.util.lookup

    Methods in org.openide.util.lookup with parameters of type Collection
    Modifier and Type | Method and Description
    --- | ---
    `<T,R> void` | InstanceContent.`set(Collection<T> col, InstanceContent.Convertor<T,R> conv)` Changes all pairs in the lookup to new values.
    `protected void` | AbstractLookup.`setPairs(Collection<? extends AbstractLookup.Pair> collection)` Changes all pairs in the lookup to new values.
    `void` | AbstractLookup.Content.`setPairs(Collection<? extends AbstractLookup.Pair> c)` Changes all pairs in the lookup to new values.
    `protected void` | AbstractLookup.`setPairs(Collection<? extends AbstractLookup.Pair> collection, Executor notifyIn)` Changes all pairs in the lookup to new values, notifies listeners using provided executor.

Copyright © 2025 API Design. All Rights Reserved.