Uses of Interface java.util.Collection (FlexDoc/Javadoc 2.0 Demo)

Overview

Module

Package

Class

Use

Tree

Deprecated

Index

Help

PREV NEXT All Classes All Packages

FRAMES NO FRAMES

FlexDoc/Javadoc 2.0
Demo Java Doc

Uses of Interface
java.util.Collection

Packages that use Collection
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.

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
abstract class	AbstractCollection<E> This class provides a skeletal implementation of the Collection interface, to minimize the effort required to implement this interface.
abstract 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).
abstract class	AbstractQueue<E> This class provides skeletal implementations of some Queue operations.
abstract 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).
abstract 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.
abstract 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
Collection<V>	AbstractMap.values() Returns a Collection view of the values contained in this map.
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>	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() Returns a Collection view of the values contained in this map.
Collection<V>	SortedMap.values() Returns a Collection view of the values contained in this map.
Collection<V>	TreeMap.values() Returns a Collection view of the values contained in this map.
Collection<V>	WeakHashMap.values() Returns a Collection view of the values contained in this map.

Methods in java.util with parameters of type Collection
boolean	AbstractCollection.addAll(Collection<? extends E> c) Adds all of the elements in the specified collection to this collection (optional operation).
boolean	AbstractCollection.containsAll(Collection<?> c) Returns true if this collection contains all of the elements in the specified collection.
boolean	AbstractCollection.removeAll(Collection<?> c) Removes all of this collection's elements that are also 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	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	AbstractSet.removeAll(Collection<?> c) Removes from this set all of its elements that are contained in the specified collection (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	ArrayDeque.removeAll(Collection<?> c) Removes all of this collection's elements that are also contained in the specified collection (optional operation).
boolean	ArrayDeque.retainAll(Collection<?> c) Retains only the elements in this collection that are contained in the specified collection (optional operation).
boolean	ArrayList.addAll(Collection<? extends E> c) Appends all of the elements in the specified collection to the end of this list, in the order that they are returned by the specified collection's Iterator.
boolean	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.removeAll(Collection<?> c) Removes from this list all of its elements that are contained in the specified collection.
boolean	ArrayList.retainAll(Collection<?> c) Retains only the elements in this list that are contained in the specified collection.
boolean	Collection.addAll(Collection<? extends E> c) Adds all of the elements in the specified collection to this collection (optional operation).
boolean	Collection.containsAll(Collection<?> c) Returns true if this collection contains all of the elements 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	Collection.retainAll(Collection<?> c) Retains only the elements in this collection that are contained in the specified collection (optional operation).
static <T> boolean	Collections.addAll(Collection<? super T> c, T... elements) Adds all of the specified elements to the specified collection.
static <E> Collection<E>	Collections.checkedCollection(Collection<E> c, Class<E> type) Returns a dynamically typesafe view of 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 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.
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.
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.
static <E extends Enum<E>> EnumSet<E>	EnumSet.copyOf(Collection<E> c) Creates an enum set initialized from the specified 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	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	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	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.containsAll(Collection<?> c) Returns true if this list contains all of the elements of the specified collection.
static <E> List<E>	List.copyOf(Collection<? extends E> coll) Returns an unmodifiable List containing the elements of the given Collection, in its iteration order.
boolean	List.removeAll(Collection<?> c) Removes from this list 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).
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 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.
boolean	PriorityQueue.removeAll(Collection<?> c) Removes all of this collection's elements that are also contained in the specified collection (optional operation).
boolean	PriorityQueue.retainAll(Collection<?> c) Retains only the elements in this collection that are contained in the specified 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).
boolean	Set.containsAll(Collection<?> c) Returns true if this set contains all of the elements of the specified collection.
static <E> Set<E>	Set.copyOf(Collection<? extends E> coll) Returns an unmodifiable Set containing the elements of the given Collection.
boolean	Set.removeAll(Collection<?> c) Removes from this set all of its elements 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> Spliterator<T>	Spliterators.spliterator(Collection<? extends T> c, int characteristics) Creates a Spliterator using the given collection's Collection.iterator() as the source of elements, and reporting its Collection.size() as its initial size.
boolean	TreeSet.addAll(Collection<? extends E> c) Adds all of the elements in the specified collection to this set.
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	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.containsAll(Collection<?> c) Returns true if this Vector contains all of the elements in the specified Collection.
boolean	Vector.removeAll(Collection<?> c) Removes from this Vector all of its elements that are contained in the specified Collection.
boolean	Vector.retainAll(Collection<?> c) Retains only the elements in this Vector that are contained in 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.
interface	TransferQueue<E> A BlockingQueue in which producers may wait for consumers to receive elements.

Classes in java.util.concurrent that implement Collection
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
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.
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.
protected Collection<Thread>	Semaphore.getQueuedThreads() Returns a collection containing threads that may be waiting to acquire.

Methods in java.util.concurrent with parameters of type Collection
<T> List<Future<T>>	AbstractExecutorService.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, 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> T	AbstractExecutorService.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, 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.
int	ArrayBlockingQueue.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 maxElements) Removes at most the given number of available elements from this queue and adds them to the given collection.
boolean	ArrayBlockingQueue.removeAll(Collection<?> c) Removes all of this collection's elements that are also contained in the specified collection (optional operation).
boolean	ArrayBlockingQueue.retainAll(Collection<?> c) Retains only the elements in this collection that are contained in the specified collection (optional operation).
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.
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.
final boolean	ConcurrentHashMap.KeySetView.containsAll(Collection<?> c) Returns true if this collection contains all of the elements in the specified collection.
boolean	ConcurrentHashMap.KeySetView.removeAll(Collection<?> c) Removes all of this collection's elements that are also contained in the specified collection (optional operation).
final boolean	ConcurrentHashMap.KeySetView.retainAll(Collection<?> c) Retains only the elements in this collection that are contained in the specified collection (optional operation).
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	ConcurrentLinkedDeque.removeAll(Collection<?> c) Removes all of this collection's elements that are also contained in the specified collection (optional operation).
boolean	ConcurrentLinkedDeque.retainAll(Collection<?> c) Retains only the elements in this collection that are contained in the specified collection (optional operation).
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	ConcurrentLinkedQueue.removeAll(Collection<?> c) Removes all of this collection's elements that are also contained in the specified collection (optional operation).
boolean	ConcurrentLinkedQueue.retainAll(Collection<?> c) Retains only the elements in this collection that are contained in the specified collection (optional operation).
boolean	ConcurrentSkipListSet.removeAll(Collection<?> c) Removes from this set all of its elements that are contained in the specified collection.
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	CopyOnWriteArrayList.containsAll(Collection<?> c) Returns true if this list contains all of the elements of the specified collection.
boolean	CopyOnWriteArrayList.removeAll(Collection<?> c) Removes from this list all of its elements 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.
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	CopyOnWriteArraySet.containsAll(Collection<?> c) Returns true if this set contains all of the elements of the specified collection.
boolean	CopyOnWriteArraySet.removeAll(Collection<?> c) Removes from this set all of its elements 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.
int	DelayQueue.drainTo(Collection<? super E> c) Removes all available elements from this queue and adds them to the given collection.
int	DelayQueue.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.
<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> 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.
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.
<T> List<Future<T>>	ForkJoinPool.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>>	ForkJoinPool.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> T	ForkJoinPool.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	ForkJoinPool.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.
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.
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	LinkedBlockingDeque.drainTo(Collection<? super E> c) Removes all available elements from this queue and adds them to the given collection.
int	LinkedBlockingDeque.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.
boolean	LinkedBlockingDeque.removeAll(Collection<?> c) Removes all of this collection's elements that are also contained in the specified collection (optional operation).
boolean	LinkedBlockingDeque.retainAll(Collection<?> c) Retains only the elements in this collection that are contained in the specified collection (optional operation).
int	LinkedBlockingQueue.drainTo(Collection<? super E> c) Removes all available elements from this queue and adds them to the given collection.
int	LinkedBlockingQueue.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.
boolean	LinkedBlockingQueue.removeAll(Collection<?> c) Removes all of this collection's elements that are also contained in the specified collection (optional operation).
boolean	LinkedBlockingQueue.retainAll(Collection<?> c) Retains only the elements in this collection that are contained in the specified collection (optional operation).
int	LinkedTransferQueue.drainTo(Collection<? super E> c) Removes all available elements from this queue and adds them to the given collection.
int	LinkedTransferQueue.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.
boolean	LinkedTransferQueue.removeAll(Collection<?> c) Removes all of this collection's elements that are also contained in the specified collection (optional operation).
boolean	LinkedTransferQueue.retainAll(Collection<?> c) Retains only the elements in this collection that are contained in the specified collection (optional operation).
int	PriorityBlockingQueue.drainTo(Collection<? super E> c) Removes all available elements from this queue and adds them to the given collection.
int	PriorityBlockingQueue.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.
boolean	PriorityBlockingQueue.removeAll(Collection<?> c) Removes all of this collection's elements that are also contained in the specified collection (optional operation).
boolean	PriorityBlockingQueue.retainAll(Collection<?> c) Retains only the elements in this collection that are contained in the specified collection (optional operation).
boolean	SynchronousQueue.containsAll(Collection<?> c) Returns false unless the given collection is empty.
int	SynchronousQueue.drainTo(Collection<? super E> c) Removes all available elements from this queue and adds them to the given collection.
int	SynchronousQueue.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.
boolean	SynchronousQueue.removeAll(Collection<?> c) Always returns false.
boolean	SynchronousQueue.retainAll(Collection<?> c) Always returns false.

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

Overview

Module

Package

Class

Use

Tree

Deprecated

Index

Help

PREV NEXT All Classes All Packages

FRAMES NO FRAMES

FlexDoc/Javadoc 2.0
Demo Java Doc

Java API documentation generated with FlexDoc/Javadoc 2.0 using JavadocClassic 3.0 template set.

FlexDoc/Javadoc is a template-driven programming tool for rapid development of any Javadoc-based Java API documentation generators (i.e. doclets). If you need to customize your Javadoc without writing a full-blown doclet from scratch, FlexDoc/Javadoc may be the only tool able to help you! Find out more at www.flexdoc.xyz