Java™ Platform
Standard Ed. 6

Uses of Interface
java.util.Collection

Packages that use Collection
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.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, legacy collection classes, event model, date and time facilities, internationalization, and miscellaneous utility classes (a string tokenizer, a random-number generator, and a bit array). 
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. 
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.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 TM Scripting Engines and provides a framework for their use in Java applications. 
javax.sql.rowset Standard interfaces and base classes for JDBC RowSet implementations. 
 

Uses of Collection in java.awt
 

Methods in java.awt that return Collection
 Collection<Object> RenderingHints.values()
          Returns a Collection view of the values contained in this RenderinHints.
 

Uses of Collection in java.beans.beancontext
 

Subinterfaces of Collection in java.beans.beancontext
 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
 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
protected  Collection BeanContextMembershipEvent.children
          The list of children affected by this event notification.
 

Methods in java.beans.beancontext with parameters of type Collection
 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
BeanContextMembershipEvent(BeanContext bc, Collection changes)
          Contruct a BeanContextMembershipEvent
 

Uses of Collection in java.security
 

Methods in java.security that return Collection
 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
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<?>> X509CertSelector.getSubjectAlternativeNames()
          Returns a copy of the subjectAlternativeNames criterion.
 Collection<List<?>> X509Certificate.getSubjectAlternativeNames()
          Gets an immutable collection of subject alternative names from the SubjectAltName extension, (OID = 2.5.29.17).
 

Methods in java.security.cert with parameters of type Collection
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
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
 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
 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>
          Linked list implementation of the List interface.
 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
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> EnumMap.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.
 Collection<V> TreeMap.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> SortedMap.values()
          Returns a Collection view of the values contained in this map.
 Collection<V> AbstractMap.values()
          Returns a Collection view of the values contained in this map.
 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> Map.values()
          Returns a Collection view of the values contained in this map.
 

Methods in java.util with parameters of type Collection
 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 TreeSet.addAll(Collection<? extends E> c)
          Adds all of the elements in the specified collection to this set.
 boolean AbstractQueue.addAll(Collection<? extends E> c)
          Adds all of the elements in the specified collection to this queue.
 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 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 AbstractCollection.addAll(Collection<? extends E> c)
          Adds all of the elements in the specified collection to this collection (optional operation).
 boolean Vector.addAll(Collection<? extends E> c)
          Appends all of the elements in the specified Collection to the end of this Vector, in the order that they are returned by the specified Collection's Iterator.
 boolean Collection.addAll(Collection<? extends E> c)
          Adds all of the elements in the specified collection to this collection (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).
static
<T> boolean
Collections.addAll(Collection<? super T> c, T... elements)
          Adds all of the specified elements to the specified collection.
 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 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 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 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 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 Vector.addAll(int index, Collection<? extends E> c)
          Inserts all of the elements in the specified Collection into this Vector at the specified position.
static
<E> Collection<E>
Collections.checkedCollection(Collection<E> c, Class<E> type)
          Returns a dynamically typesafe view of the specified collection.
 boolean List.containsAll(Collection<?> c)
          Returns true if this list contains all of the elements of the specified collection.
 boolean AbstractCollection.containsAll(Collection<?> c)
          Returns true if this collection contains all of the elements in the specified collection.
 boolean Vector.containsAll(Collection<?> c)
          Returns true if this Vector 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 Set.containsAll(Collection<?> c)
          Returns true if this set contains all of the elements of the specified collection.
static
<E extends Enum<E>>
EnumSet<E>
EnumSet.copyOf(Collection<E> c)
          Creates an enum set initialized from the specified collection.
static boolean Collections.disjoint(Collection<?> c1, Collection<?> c2)
          Returns true if the two specified collections have no elements in common.
static boolean Collections.disjoint(Collection<?> c1, Collection<?> c2)
          Returns true if the two specified collections have no elements in common.
static
<T> Enumeration<T>
Collections.enumeration(Collection<T> c)
          Returns an enumeration over the specified collection.
static int Collections.frequency(Collection<?> c, Object o)
          Returns the number of elements in the specified collection equal to the specified object.
static
<T extends Object & Comparable<? super T>>
T
Collections.max(Collection<? extends T> coll)
          Returns the maximum element of the given collection, according to the natural ordering of its elements.
static
<T> T
Collections.max(Collection<? extends T> coll, Comparator<? super T> comp)
          Returns the maximum element of the given collection, according to the order induced by the specified comparator.
static
<T extends Object & Comparable<? super T>>
T
Collections.min(Collection<? extends T> coll)
          Returns the minimum element of the given collection, according to the natural ordering of its elements.
static
<T> T
Collections.min(Collection<? extends T> coll, Comparator<? super T> comp)
          Returns the minimum element of the given collection, according to the order induced by the specified comparator.
 boolean AbstractSet.removeAll(Collection<?> c)
          Removes from this set all of its elements that are contained in the specified collection (optional operation).
 boolean List.removeAll(Collection<?> c)
          Removes from this list all of its elements that are contained in the specified collection (optional operation).
 boolean AbstractCollection.removeAll(Collection<?> c)
          Removes all of this collection's elements that are also 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 Collection.removeAll(Collection<?> c)
          Removes all of this collection's elements that are also 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 List.retainAll(Collection<?> c)
          Retains only the elements in this list that are contained in the specified collection (optional operation).
 boolean AbstractCollection.retainAll(Collection<?> c)
          Retains only the elements in this collection 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.
 boolean Collection.retainAll(Collection<?> c)
          Retains only the elements in this collection 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).
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
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
 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.
 

Classes in java.util.concurrent that implement Collection
 class ArrayBlockingQueue<E>
          A bounded blocking queue backed by an array.
 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 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
protected  Collection<Thread> Semaphore.getQueuedThreads()
          Returns a collection containing threads that may be waiting to acquire.
 Collection<V> ConcurrentSkipListMap.values()
          Returns a Collection view of the values contained in this map.
 Collection<V> ConcurrentHashMap.values()
          Returns a Collection view of the values contained in this map.
 

Methods in java.util.concurrent with parameters of type Collection
 boolean CopyOnWriteArraySet.addAll(Collection<? extends E> c)
          Adds all of the elements in the specified collection to this set if they're not already present.
 boolean CopyOnWriteArrayList.addAll(Collection<? extends E> c)
          Appends all of the elements in the specified collection to the end of this list, in the order that they are returned by the specified collection's iterator.
 boolean CopyOnWriteArrayList.addAll(int index, Collection<? extends E> c)
          Inserts all of the elements in the specified collection into this list, starting at the specified position.
 int CopyOnWriteArrayList.addAllAbsent(Collection<? extends E> c)
          Appends all of the elements in the specified collection that are not already contained in this list, to the end of this list, in the order that they are returned by the specified collection's iterator.
 boolean SynchronousQueue.containsAll(Collection<?> c)
          Returns false unless the given collection is empty.
 boolean CopyOnWriteArraySet.containsAll(Collection<?> c)
          Returns true if this set contains all of the elements of the specified collection.
 boolean CopyOnWriteArrayList.containsAll(Collection<?> c)
          Returns true if this list contains all of the elements of the specified collection.
 int SynchronousQueue.drainTo(Collection<? super E> c)
           
 int PriorityBlockingQueue.drainTo(Collection<? super E> c)
           
 int LinkedBlockingQueue.drainTo(Collection<? super E> c)
           
 int LinkedBlockingDeque.drainTo(Collection<? super E> c)
           
 int DelayQueue.drainTo(Collection<? super E> c)
           
 int BlockingQueue.drainTo(Collection<? super E> c)
          Removes all available elements from this queue and adds them to the given collection.
 int ArrayBlockingQueue.drainTo(Collection<? super E> c)
           
 int SynchronousQueue.drainTo(Collection<? super E> c, int maxElements)
           
 int PriorityBlockingQueue.drainTo(Collection<? super E> c, int maxElements)
           
 int LinkedBlockingQueue.drainTo(Collection<? super E> c, int maxElements)
           
 int LinkedBlockingDeque.drainTo(Collection<? super E> c, int maxElements)
           
 int DelayQueue.drainTo(Collection<? super E> c, int maxElements)
           
 int BlockingQueue.drainTo(Collection<? super E> c, int maxElements)
          Removes at most the given number of available elements from this queue and adds them to the given collection.
 int ArrayBlockingQueue.drainTo(Collection<? super E> c, int maxElements)
           
<T> List<Future<T>>
ExecutorService.invokeAll(Collection<? extends Callable<T>> tasks)
          Executes the given tasks, returning a list of Futures holding their status and results when all complete.
<T> List<Future<T>>
AbstractExecutorService.invokeAll(Collection<? extends Callable<T>> tasks)
           
<T> List<Future<T>>
ExecutorService.invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
          Executes the given tasks, returning a list of Futures holding their status and results when all complete or the timeout expires, whichever happens first.
<T> List<Future<T>>
AbstractExecutorService.invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
           
<T> T
ExecutorService.invokeAny(Collection<? extends Callable<T>> tasks)
          Executes the given tasks, returning the result of one that has completed successfully (i.e., without throwing an exception), if any do.
<T> T
AbstractExecutorService.invokeAny(Collection<? extends Callable<T>> tasks)
           
<T> T
ExecutorService.invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
          Executes the given tasks, returning the result of one that has completed successfully (i.e., without throwing an exception), if any do before the given timeout elapses.
<T> T
AbstractExecutorService.invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
           
 boolean SynchronousQueue.removeAll(Collection<?> c)
          Always returns false.
 boolean CopyOnWriteArraySet.removeAll(Collection<?> c)
          Removes from this set all of its elements that are contained in the specified collection.
 boolean CopyOnWriteArrayList.removeAll(Collection<?> c)
          Removes from this list all of its elements that are contained in the specified collection.
 boolean ConcurrentSkipListSet.removeAll(Collection<?> c)
          Removes from this set all of its elements that are contained in the specified collection.
 boolean SynchronousQueue.retainAll(Collection<?> c)
          Always returns false.
 boolean CopyOnWriteArraySet.retainAll(Collection<?> c)
          Retains only the elements in this set that are contained in the specified collection.
 boolean CopyOnWriteArrayList.retainAll(Collection<?> c)
          Retains only the elements in this list that are contained in the specified collection.
 

Constructors in java.util.concurrent with parameters of type Collection
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.
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.
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
 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.
protected  Collection<Thread> ReentrantReadWriteLock.getQueuedThreads()
          Returns a collection containing threads that may be waiting to acquire either the read or write 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.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.
protected  Collection<Thread> AbstractQueuedSynchronizer.ConditionObject.getWaitingThreads()
          Returns a collection containing those threads that may be waiting on this Condition.
 Collection<Thread> AbstractQueuedLongSynchronizer.getWaitingThreads(AbstractQueuedLongSynchronizer.ConditionObject condition)
          Returns a collection containing those threads that may be waiting on the given condition associated with this synchronizer.
 Collection<Thread> AbstractQueuedSynchronizer.getWaitingThreads(AbstractQueuedSynchronizer.ConditionObject condition)
          Returns a collection containing those threads that may be waiting on the given condition associated with this synchronizer.
protected  Collection<Thread> ReentrantReadWriteLock.getWaitingThreads(Condition condition)
          Returns a collection containing those threads that may be waiting on the given condition associated with the write lock.
protected  Collection<Thread> ReentrantLock.getWaitingThreads(Condition condition)
          Returns a collection containing those threads that may be waiting on the given condition associated with this lock.
 

Uses of Collection in java.util.jar
 

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

Uses of Collection in javax.management
 

Classes in javax.management that implement Collection
 class AttributeList
          Represents a list of values for attributes of an MBean.
 

Methods in javax.management with parameters of type Collection
 boolean AttributeList.addAll(Collection<?> c)
           
 boolean AttributeList.addAll(int index, Collection<?> c)
           
 

Uses of Collection in javax.management.openmbean
 

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

Uses of Collection in javax.management.relation
 

Classes in javax.management.relation that implement Collection
 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
 boolean RoleUnresolvedList.addAll(Collection<?> c)
           
 boolean RoleList.addAll(Collection<?> c)
           
 boolean RoleUnresolvedList.addAll(int index, Collection<?> c)
           
 boolean RoleList.addAll(int index, Collection<?> c)
           
 

Uses of Collection in javax.print.attribute.standard
 

Classes in javax.print.attribute.standard that implement Collection
 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
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
 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
 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.
 


Java™ Platform
Standard Ed. 6

Submit a bug or feature
For further API reference and developer documentation, see Java SE Developer Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.

Copyright © 1993, 2011, Oracle and/or its affiliates. All rights reserved.

Scripting on this page tracks web page traffic, but does not change the content in any way.