# Uses of Interface
java.util.Collection

Packages that use Collection
Package
Description
com.sun.jdi.event
This package defines JDI events and event processing.
com.sun.management
This package contains the JDK's extension to the standard implementation of the `java.lang.management` API and also defines the management interface for some other components of the platform.
com.sun.net.httpserver
Provides a simple high-level Http server API, which can be used to build embedded HTTP servers.
java.awt
Contains all of the classes for creating user interfaces and for painting graphics and images.
java.beans.beancontext
Provides classes and interfaces relating to bean context.
java.lang.module
Classes to support module descriptors and creating configurations of modules by means of resolution and service binding.
java.security
Provides the classes and interfaces for the security framework.
java.security.cert
Provides classes and interfaces for parsing and managing certificates, certificate revocation lists (CRLs), and certification paths.
java.util
Contains the collections framework, some internationalization support classes, a service loader, properties, random number generation, string parsing and scanning classes, base64 encoding and decoding, a bit array, and several miscellaneous utility classes.
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.jar
Provides classes for reading and writing the JAR (Java ARchive) file format, which is based on the standard ZIP file format with an optional manifest file.
java.util.stream
Classes to support functional-style operations on streams of elements, such as map-reduce transformations on collections.
javax.management
Provides the core classes for the Java Management Extensions.
javax.management.openmbean
Provides the open data types and Open MBean descriptor classes.
javax.management.relation
Provides the definition of the Relation Service.
javax.net.ssl
Provides classes for the secure socket package.
javax.print.attribute.standard
Package `javax.print.attribute.standard` contains classes for specific printing attributes.
javax.script
The scripting API consists of interfaces and classes that define Java Scripting Engines and provides a framework for their use in Java applications.
javax.sql.rowset
Standard interfaces and base classes for JDBC `RowSet` implementations.
javax.swing
Provides a set of "lightweight" (all-Java language) components that, to the maximum degree possible, work the same on all platforms.
javax.tools
Provides interfaces for tools which can be invoked from a program, for example, compilers.
jdk.jshell
Provides interfaces for creating tools, such as a Read-Eval-Print Loop (REPL), which interactively evaluate "snippets" of Java programming language code.

## Uses of Collection in com.sun.jdi.event

Subinterfaces of Collection in com.sun.jdi.event
Modifier and Type
Interface
Description
`interface`
`EventSet`
Several `Event` objects may be created at a given time by the target `VirtualMachine`.

## Uses of Collection in com.sun.management

Methods in com.sun.management that return Collection
Modifier and Type
Method
Description
`Collection<?>`
GcInfo.`values()`

## Uses of Collection in com.sun.net.httpserver

Methods in com.sun.net.httpserver that return Collection
Modifier and Type
Method
Description
`Collection<List<String>>`
Headers.`values()`

## Uses of Collection in java.awt

Methods in java.awt that return Collection
Modifier and Type
Method
Description
`Collection<Object>`
RenderingHints.`values()`
Returns a `Collection` view of the values contained in this `RenderingHints`.

## Uses of Collection in java.beans.beancontext

Subinterfaces of Collection in java.beans.beancontext
Modifier and Type
Interface
Description
`interface`
`BeanContext`
The BeanContext acts a logical hierarchical container for JavaBeans.
`interface`
`BeanContextServices`
The BeanContextServices interface provides a mechanism for a BeanContext to expose generic "services" to the BeanContextChild objects within.
Classes in java.beans.beancontext that implement Collection
Modifier and Type
Class
Description
`class`
`BeanContextServicesSupport`
This helper class provides a utility implementation of the java.beans.beancontext.BeanContextServices interface.
`class`
`BeanContextSupport`
This helper class provides a utility implementation of the java.beans.beancontext.BeanContext interface.
Fields in java.beans.beancontext declared as Collection
Modifier and Type
Field
Description
`protected Collection`
BeanContextMembershipEvent.`children`
The list of children affected by this event notification.
Methods in java.beans.beancontext with parameters of type Collection
Modifier and Type
Method
Description
`boolean`
BeanContextSupport.`addAll(Collection c)`
add Collection to set of Children (Unsupported) implementations must synchronized on the hierarchy lock and "children" protected field
`boolean`
BeanContextSupport.`containsAll(Collection c)`
Tests to see if all objects in the specified `Collection` are children of this `BeanContext`.
`protected final void`
BeanContextSupport.`deserialize(ObjectInputStream ois, Collection coll)`
used by readObject to deserialize a collection.
`boolean`
BeanContextSupport.`removeAll(Collection c)`
remove all specified children (Unsupported) implementations must synchronized on the hierarchy lock and "children" protected field
`boolean`
BeanContextSupport.`retainAll(Collection c)`
retain only specified children (Unsupported) implementations must synchronized on the hierarchy lock and "children" protected field
`protected final void`
BeanContextSupport.`serialize(ObjectOutputStream oos, Collection<?> coll)`
Used by writeObject to serialize a Collection.
Constructors in java.beans.beancontext with parameters of type Collection
Modifier
Constructor
Description
``
`BeanContextMembershipEvent(BeanContext bc, Collection changes)`
Construct a BeanContextMembershipEvent

## Uses of Collection in java.lang.module

Methods in java.lang.module with parameters of type Collection
Modifier and Type
Method
Description
`Configuration`
Configuration.`resolve(ModuleFinder before, ModuleFinder after, Collection<String> roots)`
Resolves a collection of root modules, with this configuration as its parent, to create a new configuration.
`static Configuration`
Configuration.`resolve(ModuleFinder before, List<Configuration> parents, ModuleFinder after, Collection<String> roots)`
Resolves a collection of root modules to create a configuration.
`Configuration`
Configuration.`resolveAndBind(ModuleFinder before, ModuleFinder after, Collection<String> roots)`
Resolves a collection of root modules, with service binding, and with this configuration as its parent, to create a new configuration.
`static Configuration`
Configuration.`resolveAndBind(ModuleFinder before, List<Configuration> parents, ModuleFinder after, Collection<String> roots)`
Resolves a collection of root modules, with service binding, to create configuration.

## Uses of Collection in java.security

Methods in java.security that return Collection
Modifier and Type
Method
Description
`Collection<Object>`
Provider.`values()`
Returns an unmodifiable Collection view of the property values contained in this `Provider`.

## Uses of Collection in java.security.cert

Methods in java.security.cert that return Collection
Modifier and Type
Method
Description
`abstract Collection<? extends Certificate>`
CertificateFactorySpi.`engineGenerateCertificates(InputStream inStream)`
Returns a (possibly empty) collection view of the certificates read from the given input stream `inStream`.
`abstract Collection<? extends CRL>`
CertificateFactorySpi.`engineGenerateCRLs(InputStream inStream)`
Returns a (possibly empty) collection view of the CRLs read from the given input stream `inStream`.
`abstract Collection<? extends Certificate>`
CertStoreSpi.`engineGetCertificates(CertSelector selector)`
Returns a `Collection` of `Certificate`s that match the specified selector.
`abstract Collection<? extends CRL>`
CertStoreSpi.`engineGetCRLs(CRLSelector selector)`
Returns a `Collection` of `CRL`s that match the specified selector.
`final Collection<? extends Certificate>`
CertificateFactory.`generateCertificates(InputStream inStream)`
Returns a (possibly empty) collection view of the certificates read from the given input stream `inStream`.
`final Collection<? extends CRL>`
CertificateFactory.`generateCRLs(InputStream inStream)`
Returns a (possibly empty) collection view of the CRLs read from the given input stream `inStream`.
`final Collection<? extends Certificate>`
CertStore.`getCertificates(CertSelector selector)`
Returns a `Collection` of `Certificate`s that match the specified selector.
`Collection<?>`
CollectionCertStoreParameters.`getCollection()`
Returns the `Collection` from which `Certificate`s and `CRL`s are retrieved.
`final Collection<? extends CRL>`
CertStore.`getCRLs(CRLSelector selector)`
Returns a `Collection` of `CRL`s that match the specified selector.
`Collection<List<?>>`
X509Certificate.`getIssuerAlternativeNames()`
Gets an immutable collection of issuer alternative names from the `IssuerAltName` extension, (OID = 2.5.29.18).
`Collection<Object>`
X509CRLSelector.`getIssuerNames()`
Returns a copy of the issuerNames criterion.
`Collection<X500Principal>`
X509CRLSelector.`getIssuers()`
Returns the issuerNames criterion.
`Collection<List<?>>`
X509CertSelector.`getPathToNames()`
Returns a copy of the pathToNames criterion.
`Collection<List<?>>`
X509Certificate.`getSubjectAlternativeNames()`
Gets an immutable collection of subject alternative names from the `SubjectAltName` extension, (OID = 2.5.29.17).
`Collection<List<?>>`
X509CertSelector.`getSubjectAlternativeNames()`
Returns a copy of the subjectAlternativeNames criterion.
Methods in java.security.cert with parameters of type Collection
Modifier and Type
Method
Description
`abstract void`
PKIXCertPathChecker.`check(Certificate cert, Collection<String> unresolvedCritExts)`
Performs the check(s) on the specified certificate using its internal state and removes any critical extensions that it processes from the specified collection of OID strings that represent the unresolved critical extensions.
`void`
X509CRLSelector.`setIssuerNames(Collection<?> names)`
Note: use X509CRLSelector.setIssuers(Collection) instead or only specify the byte array form of distinguished names when using this method.
`void`
X509CRLSelector.`setIssuers(Collection<X500Principal> issuers)`
Sets the issuerNames criterion.
`void`
X509CertSelector.`setPathToNames(Collection<List<?>> names)`
Sets the pathToNames criterion.
`void`
X509CertSelector.`setSubjectAlternativeNames(Collection<List<?>> names)`
Sets the subjectAlternativeNames criterion.
Constructors in java.security.cert with parameters of type Collection
Modifier
Constructor
Description
``
`CollectionCertStoreParameters(Collection<?> collection)`
Creates an instance of `CollectionCertStoreParameters` which will allow certificates and CRLs to be retrieved from the specified `Collection`.

## Uses of Collection in java.util

Subinterfaces of Collection in java.util
Modifier and Type
Interface
Description
`interface`
`Deque<E>`
A linear collection that supports element insertion and removal at both ends.
`interface`
`List<E>`
An ordered collection, where the user has precise control over where in the list each element is inserted.
`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`
`SequencedCollection<E>`
A collection that has a well-defined encounter order, that supports operations at both ends, and that is reversible.
`interface`
`SequencedSet<E>`
A collection that is both a `SequencedCollection` and a `Set`.
`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
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 well-defined encounter 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
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>`
AbstractMap.`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>`
HashMap.`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>`
IdentityHashMap.`values()`
Returns a `Collection` view of the values contained in this map.
`Collection<V>`
LinkedHashMap.`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>`
SortedMap.`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>`
WeakHashMap.`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
Description
`boolean`
AbstractCollection.`addAll(Collection<? extends E> c)`
Adds all of the elements in the specified collection to this collection (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).
`boolean`
AbstractQueue.`addAll(Collection<? extends E> c)`
Adds all of the elements in the specified collection to this queue.
`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`
ArrayDeque.`addAll(Collection<? extends E> c)`
Adds all of the elements in the specified collection at the end of this deque, as if by calling `ArrayDeque.addLast(E)` on each one, in the order that they are returned by the collection's iterator.
`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`
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`
Collection.`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`
Deque.`addAll(Collection<? extends E> c)`
Adds all of the elements in the specified collection at the end of this deque, as if by calling `Deque.addLast(E)` on each one, in the order that they are returned by the collection's iterator.
`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`
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`
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`
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`
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`
TreeSet.`addAll(Collection<? extends E> c)`
Adds all of the elements in the specified collection to this set.
`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`
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.
`static <E> Collection<E>`
Collections.`checkedCollection(Collection<E> c, Class<E> type)`
Returns a dynamically typesafe view of the specified collection.
`boolean`
AbstractCollection.`containsAll(Collection<?> c)`
Returns `true` if this collection contains all of the elements in the specified collection.
`boolean`
Collection.`containsAll(Collection<?> c)`
Returns `true` if this collection contains all of the elements in the specified collection.
`boolean`
List.`containsAll(Collection<?> c)`
Returns `true` if this list contains all of the elements of the specified collection.
`boolean`
Set.`containsAll(Collection<?> c)`
Returns `true` if this set contains all of the elements of the specified collection.
`boolean`
Vector.`containsAll(Collection<?> c)`
Returns true if this Vector 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 <E> List<E>`
List.`copyOf(Collection<? extends E> coll)`
Returns an unmodifiable List containing the elements of the given Collection, in its iteration order.
`static <E> Set<E>`
Set.`copyOf(Collection<? extends E> coll)`
Returns an unmodifiable Set containing the elements of the given Collection.
`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 List<Locale>`
Locale.`filter(List<Locale.LanguageRange> priorityList, Collection<Locale> locales)`
Returns a list of matching `Locale` instances using the filtering mechanism defined in RFC 4647.
`static List<Locale>`
Locale.`filter(List<Locale.LanguageRange> priorityList, Collection<Locale> locales, Locale.FilteringMode mode)`
Returns a list of matching `Locale` instances using the filtering mechanism defined in RFC 4647.
`static List<String>`
Locale.`filterTags(List<Locale.LanguageRange> priorityList, Collection<String> tags)`
Returns a list of matching languages tags using the basic filtering mechanism defined in RFC 4647.
`static List<String>`
Locale.`filterTags(List<Locale.LanguageRange> priorityList, Collection<String> tags, Locale.FilteringMode mode)`
Returns a list of matching languages tags using the basic filtering mechanism defined in RFC 4647.
`static int`
Collections.`frequency(Collection<?> c, Object o)`
Returns the number of elements in the specified collection equal to the specified object.
`static Locale`
Locale.`lookup(List<Locale.LanguageRange> priorityList, Collection<Locale> locales)`
Returns a `Locale` instance for the best-matching language tag using the lookup mechanism defined in RFC 4647.
`static String`
Locale.`lookupTag(List<Locale.LanguageRange> priorityList, Collection<String> tags)`
Returns the best-matching language tag using the lookup mechanism defined in RFC 4647.
`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`
AbstractCollection.`removeAll(Collection<?> c)`
Removes all of this collection's elements that are also contained in the specified collection (optional operation).
`boolean`
AbstractSet.`removeAll(Collection<?> c)`
Removes from this set all of its elements that are contained in the specified collection (optional operation).
`boolean`
ArrayDeque.`removeAll(Collection<?> c)`
`boolean`
ArrayList.`removeAll(Collection<?> c)`
Removes from this list all of its elements that are contained in the specified collection.
`boolean`
Collection.`removeAll(Collection<?> c)`
Removes all of this collection's elements that are also 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`
PriorityQueue.`removeAll(Collection<?> c)`
`boolean`
Set.`removeAll(Collection<?> c)`
Removes from this set all of its elements that are contained in the specified collection (optional operation).
`boolean`
Vector.`removeAll(Collection<?> c)`
Removes from this Vector all of its elements 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).
`boolean`
ArrayDeque.`retainAll(Collection<?> c)`
`boolean`
ArrayList.`retainAll(Collection<?> c)`
Retains only the elements in this list that are contained in the specified collection.
`boolean`
Collection.`retainAll(Collection<?> c)`
Retains only the elements in this collection 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`
PriorityQueue.`retainAll(Collection<?> c)`
`boolean`
Set.`retainAll(Collection<?> c)`
Retains only the elements in this set that are 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.
`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
Modifier
Constructor
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
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
Description
`class`
`ArrayBlockingQueue<E>`
A bounded blocking queue backed by an array.
`static final class`
`ConcurrentHashMap.KeySetView<K,V>`
A view of a ConcurrentHashMap as a `Set` of keys, in which additions may optionally be enabled by mapping to a common value.
`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 generally becomes eligible for removal 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
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>`
ConcurrentHashMap.`values()`
Returns a `Collection` view of the values contained in this map.
`Collection<V>`
ConcurrentSkipListMap.`values()`
Returns a `Collection` view of the values contained in this map.
Methods in java.util.concurrent with parameters of type Collection
Modifier and Type
Method
Description
`boolean`
ConcurrentHashMap.KeySetView.`addAll(Collection<? extends K> c)`
Adds all of the elements in the specified collection to this set, as if by calling `ConcurrentHashMap.KeySetView.add(K)` on each one.
`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`
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`
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.
`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`
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`
LinkedBlockingDeque.`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.
`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`
CopyOnWriteArrayList.`containsAll(Collection<?> c)`
Returns `true` if this list contains all of the elements of the specified collection.
`boolean`
CopyOnWriteArraySet.`containsAll(Collection<?> c)`
Returns `true` if this set contains all of the elements of the specified collection.
`boolean`
SynchronousQueue.`containsAll(Collection<?> c)`
Returns `false` unless the given collection is empty.
`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`
ArrayBlockingQueue.`drainTo(Collection<? super E> c)`
`int`
ArrayBlockingQueue.`drainTo(Collection<? super E> c, int maxElements)`
`int`
BlockingQueue.`drainTo(Collection<? super E> c)`
Removes all available elements from this queue and adds them to the given collection.
`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`
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)`
Executes the given tasks, returning a list of Futures holding their status and results when all complete.
`<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>>`
ForkJoinPool.`invokeAll(Collection<? extends Callable<T>> tasks)`
`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`
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)`
Executes the given tasks, returning the result of one that has completed successfully (i.e., without throwing an exception), if any do.
`<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.
`boolean`
ArrayBlockingQueue.`removeAll(Collection<?> c)`
`boolean`
ConcurrentLinkedDeque.`removeAll(Collection<?> c)`
`boolean`
ConcurrentLinkedQueue.`removeAll(Collection<?> c)`
`boolean`
ConcurrentSkipListSet.`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`
CopyOnWriteArraySet.`removeAll(Collection<?> c)`
Removes from this set all of its elements that are contained in the specified collection.
`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)`
Always returns `false`.
`boolean`
ArrayBlockingQueue.`retainAll(Collection<?> c)`
`boolean`
ConcurrentLinkedDeque.`retainAll(Collection<?> c)`
`boolean`
ConcurrentLinkedQueue.`retainAll(Collection<?> c)`
`boolean`
CopyOnWriteArrayList.`retainAll(Collection<?> c)`
Retains only the elements in this list that are contained in the specified collection.
`boolean`
CopyOnWriteArraySet.`retainAll(Collection<?> c)`
Retains only the elements in this set that are contained in the specified collection.
`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)`
Always returns `false`.
Constructors in java.util.concurrent with parameters of type Collection
Modifier
Constructor
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
Description
`final Collection<Thread>`
AbstractQueuedLongSynchronizer.`getExclusiveQueuedThreads()`
Returns a collection containing threads that may be waiting to acquire in exclusive mode.
`final Collection<Thread>`
AbstractQueuedSynchronizer.`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.
`final Collection<Thread>`
AbstractQueuedLongSynchronizer.`getQueuedThreads()`
Returns a collection containing threads that may be waiting to acquire.
`final Collection<Thread>`
AbstractQueuedSynchronizer.`getQueuedThreads()`
Returns a collection containing threads that may be waiting to acquire.
`protected Collection<Thread>`
ReentrantLock.`getQueuedThreads()`
Returns a collection containing threads that may be waiting to acquire this 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>`
ReentrantReadWriteLock.`getQueuedWriterThreads()`
Returns a collection containing threads that may be waiting to acquire the write lock.
`final Collection<Thread>`
AbstractQueuedLongSynchronizer.`getSharedQueuedThreads()`
Returns a collection containing threads that may be waiting to acquire in shared mode.
`final Collection<Thread>`
AbstractQueuedSynchronizer.`getSharedQueuedThreads()`
Returns a collection containing threads that may be waiting to acquire in shared mode.
`protected final Collection<Thread>`
AbstractQueuedLongSynchronizer.ConditionObject.`getWaitingThreads()`
Returns a collection containing those threads that may be waiting on this Condition.
`final 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.
`protected final Collection<Thread>`
AbstractQueuedSynchronizer.ConditionObject.`getWaitingThreads()`
Returns a collection containing those threads that may be waiting on this Condition.
`final 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>`
ReentrantLock.`getWaitingThreads(Condition condition)`
Returns a collection containing those threads that may be waiting on the given condition associated with this lock.
`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.

## Uses of Collection in java.util.jar

Methods in java.util.jar that return Collection
Modifier and Type
Method
Description
`Collection<Object>`
Attributes.`values()`
Returns a Collection view of the attribute values contained in this Map.

## Uses of Collection in java.util.stream

Methods in java.util.stream with type parameters of type Collection
Modifier and Type
Method
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 javax.management

Classes in javax.management that implement Collection
Modifier and Type
Class
Description
`class`
`AttributeList`
Represents a list of values for attributes of an MBean.
Methods in javax.management with parameters of type Collection
Modifier and Type
Method
Description
`boolean`
AttributeList.`addAll(int index, Collection<?> c)`
Inserts all of the elements in the specified collection into this list, starting at the specified position.
`boolean`
AttributeList.`addAll(Collection<?> 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.

## Uses of Collection in javax.management.openmbean

Methods in javax.management.openmbean that return Collection
Modifier and Type
Method
Description
`Collection<?>`
CompositeData.`values()`
Returns an unmodifiable Collection view of the item values contained in this `CompositeData` instance.
`Collection<?>`
CompositeDataSupport.`values()`
Returns an unmodifiable Collection view of the item values contained in this `CompositeData` instance.
`Collection<?>`
TabularData.`values()`
Returns a collection view of the `CompositeData` values (ie the rows) contained in this `TabularData` instance.
`Collection<Object>`
TabularDataSupport.`values()`
Returns a collection view of the rows contained in this `TabularDataSupport` instance.

## Uses of Collection in javax.management.relation

Classes in javax.management.relation that implement Collection
Modifier and Type
Class
Description
`class`
`RoleList`
A RoleList represents a list of roles (Role objects).
`class`
`RoleUnresolvedList`
A RoleUnresolvedList represents a list of RoleUnresolved objects, representing roles not retrieved from a relation due to a problem encountered when trying to access (read or write) the roles.

## Uses of Collection in javax.net.ssl

Methods in javax.net.ssl that return Collection
Modifier and Type
Method
Description
`final Collection<SNIMatcher>`
SSLParameters.`getSNIMatchers()`
Returns a `Collection` containing all `SNIMatcher`s of the Server Name Indication (SNI) parameter, or null if none has been set.
Methods in javax.net.ssl with parameters of type Collection
Modifier and Type
Method
Description
`final void`
SSLParameters.`setSNIMatchers(Collection<SNIMatcher> matchers)`
Sets the `SNIMatcher`s of the Server Name Indication (SNI) parameter.

## Uses of Collection in javax.print.attribute.standard

Classes in javax.print.attribute.standard that implement Collection
Modifier and Type
Class
Description
`final class`
`JobStateReasons`
Class `JobStateReasons` is a printing attribute class, a set of enumeration values, that provides additional information about the job's current state, i.e., information that augments the value of the job's `JobState` attribute.
Constructors in javax.print.attribute.standard with parameters of type Collection
Modifier
Constructor
Description
``
`JobStateReasons(Collection<JobStateReason> collection)`
Construct a new job state reasons attribute that contains the same `JobStateReason` objects as the given collection.

## Uses of Collection in javax.script

Methods in javax.script that return Collection
Modifier and Type
Method
Description
`Collection<Object>`
SimpleBindings.`values()`
Returns a `Collection` view of the values contained in this map.

## Uses of Collection in javax.sql.rowset

Methods in javax.sql.rowset that return Collection
Modifier and Type
Method
Description
`Collection<?>`
JoinRowSet.`getRowSets()`
Returns a `Collection` object containing the `RowSet` objects that have been added to this `JoinRowSet` object.
`Collection<?>`
CachedRowSet.`toCollection()`
Converts this `CachedRowSet` object to a `Collection` object that contains all of this `CachedRowSet` object's data.
`Collection<?>`
CachedRowSet.`toCollection(int column)`
Converts the designated column in this `CachedRowSet` object to a `Collection` object.
`Collection<?>`
CachedRowSet.`toCollection(String column)`
Converts the designated column in this `CachedRowSet` object to a `Collection` object.

## Uses of Collection in javax.swing

Methods in javax.swing with parameters of type Collection
Modifier and Type
Method
Description
`void`
DefaultComboBoxModel.`addAll(int index, Collection<? extends E> c)`
Adds all of the elements present in the collection, starting from the specified index.
`void`
DefaultComboBoxModel.`addAll(Collection<? extends E> c)`
Adds all of the elements present in the collection.
`void`
DefaultListModel.`addAll(int index, Collection<? extends E> c)`
Adds all of the elements present in the collection, starting from the specified index.
`void`
DefaultListModel.`addAll(Collection<? extends E> c)`
Adds all of the elements present in the collection to the list.

## Uses of Collection in javax.tools

Methods in javax.tools with parameters of type Collection
Modifier and Type
Method
Description
`default Iterable<? extends JavaFileObject>`
StandardJavaFileManager.`getJavaFileObjectsFromPaths(Collection<? extends Path> paths)`
Returns file objects representing the given paths.
`default void`
StandardJavaFileManager.`setLocationForModule(JavaFileManager.Location location, String moduleName, Collection<? extends Path> paths)`
Associates the given search path with the given module and location, which must be a module-oriented or output location.
`default void`
StandardJavaFileManager.`setLocationFromPaths(JavaFileManager.Location location, Collection<? extends Path> paths)`
Associates the given search path with the given location.

## Uses of Collection in jdk.jshell

Methods in jdk.jshell that return Collection
Modifier and Type
Method
Description
`abstract Collection<Snippet>`
SourceCodeAnalysis.`dependents(Snippet snippet)`
Returns a collection of `Snippet`s which might need updating if the given `Snippet` is updated.