|
JavaTM 2 Platform Standard Ed. 5.0 |
|||||||||
PREV NEXT | FRAMES NO FRAMES |
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.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 Certificate s that
match the specified selector. |
abstract Collection<? extends CRL> |
CertStoreSpi.engineGetCRLs(CRLSelector selector)
Returns a Collection of CRL s that
match the specified selector. |
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 Certificate s that
match the specified selector. |
Collection<?> |
CollectionCertStoreParameters.getCollection()
Returns the Collection from which Certificate s
and CRL s are retrieved. |
Collection<? extends CRL> |
CertStore.getCRLs(CRLSelector selector)
Returns a Collection of CRL s that
match the specified selector. |
Collection<List<?>> |
X509Certificate.getIssuerAlternativeNames()
Gets an immutable collection of issuer alternative names from the IssuerAltName extension, (OID = 2.5.29.18). |
Collection<Object> |
X509CRLSelector.getIssuerNames()
Returns a copy of the issuerNames criterion. |
Collection<X500Principal> |
X509CRLSelector.getIssuers()
Returns the issuerNames criterion. |
Collection<List<?>> |
X509CertSelector.getPathToNames()
Returns a copy of the pathToNames criterion. |
Collection<List<?>> |
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 |
List<E>
An ordered collection (also known as a sequence). |
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 guarantees that its iterator will traverse the set in ascending element order, sorted according to the natural ordering of its elements (see Comparable), or by a Comparator provided at sorted set creation time. |
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 |
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>
This class implements the Set interface, backed by a TreeMap instance. |
class |
Vector<E>
The Vector class implements a growable array of
objects. |
Methods in java.util that return Collection | ||
---|---|---|
static
|
Collections.checkedCollection(Collection<E> c,
Class<E> type)
Returns a dynamically typesafe view of the specified collection. |
|
static
|
Collections.synchronizedCollection(Collection<T> c)
Returns a synchronized (thread-safe) collection backed by the specified collection. |
|
static
|
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> |
IdentityHashMap.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> |
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 Hashtable. |
|
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 |
AbstractQueue.addAll(Collection<? extends E> c)
Adds all of the elements in the specified collection to this queue. |
|
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 |
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
|
Collections.addAll(Collection<? super T> c,
T... a)
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. |
|
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
|
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
|
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
|
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
|
Collections.max(Collection<? extends T> coll)
Returns the maximum element of the given collection, according to the natural ordering of its elements. |
|
static
|
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
|
Collections.min(Collection<? extends T> coll)
Returns the minimum element of the given collection, according to the natural ordering of its elements. |
|
static
|
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 the elements that are contained in the specified collection (optional operation). |
|
boolean |
AbstractCollection.removeAll(Collection<?> c)
Removes from this collection 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 |
Collection.removeAll(Collection<?> c)
Removes all 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
|
Collections.synchronizedCollection(Collection<T> c)
Returns a synchronized (thread-safe) collection backed by the specified collection. |
|
static
|
Collections.unmodifiableCollection(Collection<? extends T> c)
Returns an unmodifiable view of the specified collection. |
Constructors in java.util with parameters of type Collection | |
---|---|
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 set containing the elements in the specified collection, sorted according to the elements' natural order. |
|
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 |
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 |
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 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 |
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 put must wait for a take, 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> |
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)
|
|
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 given collection is empty. |
|
boolean |
CopyOnWriteArraySet.containsAll(Collection<?> c)
|
|
boolean |
CopyOnWriteArrayList.containsAll(Collection<?> c)
Returns true if this Collection contains all of the elements in 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 |
DelayQueue.drainTo(Collection<? super E> c)
|
|
int |
BlockingQueue.drainTo(Collection<? super E> c)
Removes all available elements from this queue and adds them into 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 |
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 into the given collection. |
|
int |
ArrayBlockingQueue.drainTo(Collection<? super E> c,
int maxElements)
|
|
|
ExecutorService.invokeAll(Collection<Callable<T>> tasks)
Executes the given tasks, returning a list of Futures holding their status and results when all complete. |
|
|
AbstractExecutorService.invokeAll(Collection<Callable<T>> tasks)
|
|
|
ExecutorService.invokeAll(Collection<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. |
|
|
AbstractExecutorService.invokeAll(Collection<Callable<T>> tasks,
long timeout,
TimeUnit unit)
|
|
|
ExecutorService.invokeAny(Collection<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. |
|
|
AbstractExecutorService.invokeAny(Collection<Callable<T>> tasks)
|
|
|
ExecutorService.invokeAny(Collection<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. |
|
|
AbstractExecutorService.invokeAny(Collection<Callable<T>> tasks,
long timeout,
TimeUnit unit)
|
|
boolean |
SynchronousQueue.removeAll(Collection<?> c)
Always returns false. |
|
boolean |
CopyOnWriteArraySet.removeAll(Collection<?> c)
|
|
boolean |
CopyOnWriteArrayList.removeAll(Collection<?> c)
Removes from this Collection all of its elements that are contained in the specified Collection. |
|
boolean |
SynchronousQueue.retainAll(Collection<?> c)
Always returns false. |
|
boolean |
CopyOnWriteArraySet.retainAll(Collection<?> c)
|
|
boolean |
CopyOnWriteArrayList.retainAll(Collection<?> c)
Retains only the elements in this Collection that are contained in the specified Collection (optional operation). |
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. |
|
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. |
|
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> |
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> |
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> |
AbstractQueuedSynchronizer.getSharedQueuedThreads()
Returns a collection containing threads that may be waiting to acquire in shared mode. |
protected Collection<Thread> |
AbstractQueuedSynchronizer.ConditionObject.getWaitingThreads()
Returns a collection containing those threads that may be waiting on this Condition. |
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. |
Uses of Collection in javax.management.openmbean |
---|
Methods in javax.management.openmbean that return Collection | |
---|---|
Collection |
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 |
CompositeDataSupport.values()
Returns an unmodifiable Collection view of the item values contained in this CompositeData 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 to roles). |
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.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. |
|
JavaTM 2 Platform Standard Ed. 5.0 |
|||||||||
PREV NEXT | FRAMES NO FRAMES |
Copyright 2004 Sun Microsystems, Inc. All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.