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.
javafx.animation	Provides the set of classes for ease of use transition based animations.
javafx.beans.binding	Provides classes that create and operate on a Binding that calculates a value that depends on one or more sources.
javafx.beans.property	The package javafx.beans.property defines read-only properties and writable properties, plus a number of implementations.
javafx.beans.value	The package javafx.beans.value contains the two fundamental interfaces ObservableValue and WritableValue and all of its sub-interfaces.
javafx.collections	Contains the essential JavaFX collections and collection utilities
javafx.collections.transformation	Provides JavaFX collections that wrap and transform (for example, sort or filter) other JavaFX collections.
javafx.scene	Provides the core set of base classes for the JavaFX Scene Graph API.
javafx.scene.control	The JavaFX User Interface Controls (UI Controls or just Controls) are specialized Nodes in the JavaFX Scenegraph especially suited for reuse in many different application contexts.
javafx.scene.shape	Provides the set of 2D classes for defining and performing operations on objects related to two-dimensional geometry.
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.tools	Provides interfaces for tools which can be invoked from a program, for example, compilers.
jdk.incubator.http	High level HTTP and WebSocket API
jdk.jshell	Provides interfaces for creating tools, such as a Read-Eval-Print Loop (REPL), which interactively evaluate "snippets" of Java programming language code.
jdk.nashorn.api.scripting	This package provides the javax.script integration, which is the preferred way to use Nashorn.

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 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 void	BeanContextSupport.serialize(ObjectOutputStream oos, Collection<?> coll)	Used by writeObject to serialize a Collection.

Constructors in java.beans.beancontext with parameters of type Collection

Constructor	Description
BeanContextMembershipEvent(BeanContext bc, Collection changes)	Contruct 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 Certificates that match the specified selector.
abstract Collection<? extends CRL>	CertStoreSpi.engineGetCRLs(CRLSelector selector)	Returns a Collection of CRLs that match the specified selector.
Collection<? extends Certificate>	CertificateFactory.generateCertificates(InputStream inStream)	Returns a (possibly empty) collection view of the certificates read from the given input stream inStream.
Collection<? extends CRL>	CertificateFactory.generateCRLs(InputStream inStream)	Returns a (possibly empty) collection view of the CRLs read from the given input stream inStream.
Collection<? extends Certificate>	CertStore.getCertificates(CertSelector selector)	Returns a Collection of Certificates that match the specified selector.
Collection<?>	CollectionCertStoreParameters.getCollection()	Returns the Collection from which Certificates and CRLs are retrieved.
Collection<? extends CRL>	CertStore.getCRLs(CRLSelector selector)	Returns a Collection of CRLs 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

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 (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	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	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<Object>	Properties.values()
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 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	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	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

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 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 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	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	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	SynchronousQueue.retainAll(Collection<?> c)	Always returns false.

Constructors in java.util.concurrent with parameters of type Collection

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
Collection<Thread>	AbstractQueuedLongSynchronizer.getExclusiveQueuedThreads()	Returns a collection containing threads that may be waiting to acquire in exclusive mode.
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.
Collection<Thread>	AbstractQueuedLongSynchronizer.getQueuedThreads()	Returns a collection containing threads that may be waiting to acquire.
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.
Collection<Thread>	AbstractQueuedLongSynchronizer.getSharedQueuedThreads()	Returns a collection containing threads that may be waiting to acquire in shared mode.
Collection<Thread>	AbstractQueuedSynchronizer.getSharedQueuedThreads()	Returns a collection containing threads that may be waiting to acquire in shared mode.
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.
protected Collection<Thread>	AbstractQueuedSynchronizer.ConditionObject.getWaitingThreads()	Returns a collection containing those threads that may be waiting on this Condition.
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 javafx.animation

Constructors in javafx.animation with parameters of type Collection

Constructor	Description
KeyFrame(Duration time, String name, EventHandler<ActionEvent> onFinished, Collection<KeyValue> values)	Constructor of KeyFrame

Uses of Collection in javafx.beans.binding

Classes in javafx.beans.binding that implement Collection

Modifier and Type	Class	Description
class	ListBinding<E>	Base class that provides most of the functionality needed to implement a Binding of an ObservableList.
class	ListExpression<E>	ListExpression is an ObservableListValue plus additional convenience methods to generate bindings in a fluent style.
class	SetBinding<E>	Base class that provides most of the functionality needed to implement a Binding of an ObservableSet.
class	SetExpression<E>	SetExpression is an ObservableSetValue plus additional convenience methods to generate bindings in a fluent style.

Methods in javafx.beans.binding that return Collection

Modifier and Type	Method	Description
Collection<V>	MapExpression.values()

Methods in javafx.beans.binding with parameters of type Collection

Modifier and Type	Method	Description
boolean	ListExpression.addAll(int i, Collection<? extends E> elements)
boolean	ListExpression.addAll(Collection<? extends E> elements)
boolean	SetExpression.addAll(Collection<? extends E> elements)
boolean	ListExpression.containsAll(Collection<?> objects)
boolean	SetExpression.containsAll(Collection<?> objects)
boolean	ListExpression.removeAll(Collection<?> objects)
boolean	SetExpression.removeAll(Collection<?> objects)
boolean	ListExpression.retainAll(Collection<?> objects)
boolean	SetExpression.retainAll(Collection<?> objects)
boolean	ListExpression.setAll(Collection<? extends E> elements)

Uses of Collection in javafx.beans.property

Classes in javafx.beans.property that implement Collection

Modifier and Type	Class	Description
class	ListProperty<E>	This class provides a full implementation of a Property wrapping an ObservableList.
class	ListPropertyBase<E>	The class ListPropertyBase is the base class for a property wrapping an ObservableList.
class	ReadOnlyListProperty<E>	Superclass for all readonly properties wrapping an ObservableList.
class	ReadOnlyListPropertyBase<E>	Base class for all readonly properties wrapping an ObservableList.
class	ReadOnlyListWrapper<E>	This class provides a convenient class to define read-only properties.
class	ReadOnlySetProperty<E>	Superclass for all readonly properties wrapping an ObservableSet.
class	ReadOnlySetPropertyBase<E>	Base class for all readonly properties wrapping an ObservableSet.
class	ReadOnlySetWrapper<E>	This class provides a convenient class to define read-only properties.
class	SetProperty<E>	This class provides a full implementation of a Property wrapping an ObservableSet.
class	SetPropertyBase<E>	The class SetPropertyBase is the base class for a property wrapping an ObservableSet.
class	SimpleListProperty<E>	This class provides a full implementation of a Property wrapping an ObservableList.
class	SimpleSetProperty<E>	This class provides a full implementation of a Property wrapping an ObservableSet.

Uses of Collection in javafx.beans.value

Subinterfaces of Collection in javafx.beans.value

Modifier and Type	Interface	Description
interface	ObservableListValue<E>	An observable reference to an ObservableList.
interface	ObservableSetValue<E>	An observable reference to an ObservableSet.
interface	WritableListValue<E>	A writable reference to an ObservableList.
interface	WritableSetValue<E>	A writable reference to an ObservableSet.

Uses of Collection in javafx.collections

Subinterfaces of Collection in javafx.collections

Modifier and Type	Interface	Description
interface	ObservableList<E>	A list that allows listeners to track changes when they occur.
interface	ObservableSet<E>	A set that allows observers to track changes when they occur.

Classes in javafx.collections that implement Collection

Modifier and Type	Class	Description
class	ModifiableObservableListBase<E>	Abstract class that serves as a base class for ObservableList implementations that are modifiable.
class	ObservableListBase<E>	Abstract class that serves as a base class for ObservableList implementations.

Methods in javafx.collections with parameters of type Collection

Modifier and Type	Method	Description
boolean	ModifiableObservableListBase.addAll(int index, Collection<? extends E> c)
boolean	ModifiableObservableListBase.addAll(Collection<? extends E> c)
static <E> ObservableList<E>	FXCollections.observableArrayList(Collection<? extends E> col)	Creates a new observable array list and adds a content of collection col to it.
boolean	ModifiableObservableListBase.removeAll(Collection<?> c)
boolean	ModifiableObservableListBase.retainAll(Collection<?> c)
boolean	ModifiableObservableListBase.setAll(Collection<? extends E> col)
boolean	ObservableList.setAll(Collection<? extends E> col)	Clears the ObservableList and adds all elements from the collection.
boolean	ObservableListBase.setAll(Collection<? extends E> col)

Uses of Collection in javafx.collections.transformation

Classes in javafx.collections.transformation that implement Collection

Modifier and Type	Class	Description
class	FilteredList<E>	Wraps an ObservableList and filters its content using the provided Predicate.
class	SortedList<E>	Wraps an ObservableList and sorts its content.
class	TransformationList<E,F>	A base class for all lists that wrap another list in a way that changes (transforms) the wrapped list's elements, order, size, or structure.

Uses of Collection in javafx.scene

Constructors in javafx.scene with parameters of type Collection

Constructor	Description
Group(Collection<Node> children)	Constructs a group consisting of the given children.

Uses of Collection in javafx.scene.control

Constructors in javafx.scene.control with parameters of type Collection

Constructor	Description
ChoiceDialog(T defaultChoice, Collection<T> choices)	Creates a new ChoiceDialog instance with the first argument specifying the default choice that should be shown to the user, and the second argument specifying a collection of all available choices for the user.

Uses of Collection in javafx.scene.shape

Constructors in javafx.scene.shape with parameters of type Collection

Constructor	Description
Path(Collection<? extends PathElement> elements)	Creates new instance of Path

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.

Methods in javax.management.relation with parameters of type Collection

Modifier and Type	Method	Description
boolean	RoleList.addAll(int index, Collection<?> c)
boolean	RoleList.addAll(Collection<?> c)
boolean	RoleUnresolvedList.addAll(int index, Collection<?> c)
boolean	RoleUnresolvedList.addAll(Collection<?> c)

Uses of Collection in javax.net.ssl

Methods in javax.net.ssl that return Collection

Modifier and Type	Method	Description
Collection<SNIMatcher>	SSLParameters.getSNIMatchers()	Returns a Collection containing all SNIMatchers 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
void	SSLParameters.setSNIMatchers(Collection<SNIMatcher> matchers)	Sets the SNIMatchers 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
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

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.tools

Methods in javax.tools with parameters of type Collection

Modifier and Type	Method	Description
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.incubator.http

Methods in jdk.incubator.http that return Collection

Modifier and Type	Method	Description
Collection<CompletableFuture<HttpResponse<V>>>	MultiMapResult.values()

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 Snippets which might need updating if the given Snippet is updated.

Uses of Collection in jdk.nashorn.api.scripting

Methods in jdk.nashorn.api.scripting that return Collection

Modifier and Type	Method	Description
Collection<Object>	AbstractJSObject.values()
Collection<Object>	JSObject.values()	Returns the set of all property values of this object.
Collection<Object>	ScriptObjectMirror.values()