Collection interface.
Collection interface.
Collection operations, queues provide additional
insertion, extraction, and inspection operations.Queue interface.
Comparable
interface) or by a Comparator
-object provided when a SortedSet instance is created.
-Extends the Set interface.
+"../Comparator.html">Comparator
+object provided when a SortedSet instance is created.
+Extends the Set interface.
SortedMap instance is created. Extends the
+Map interface.
SortedSet extended with navigation methods reporting
+closest matches for given search targets. A NavigableSet
may be accessed and traversed in either ascending or descending
order.SortedMap extended with navigation methods returning
the closest matches for given search targets. A
-NavigableMap can be accessed and traversed in either
+NavigableMap can be accessed and traversed in either
ascending or descending key order.Queue with operations that wait for the queue to
become nonempty when retrieving an element and that wait for space
to become available in the queue when storing an element. (This
-interface is part of the java.util.concurrent
+interface is part of the java.util.concurrent
package.)BlockingQueue in which producers can wait for
consumers to receive elements. (This interface is part of the
-java.util.concurrent
+java.util.concurrent
package.)Deque with operations that wait for the deque to
become nonempty when retrieving an element and wait for space to
become available in the deque when storing an element. Extends both
-the Deque and BlockingQueue interfaces. (This
-interface is part of the java.util.concurrent
+the Deque and BlockingQueue interfaces. (This
+interface is part of the java.util.concurrent
package.)Map with atomic putIfAbsent, remove,
+and replace methods. (This interface is part of the
+java.util.concurrent package.)
ConcurrentMap that
+is also a NavigableMap.
Set interface. The best
+all-around implementation of the Set interface.NavigableSet
interface.Set
+interface. An insertion-ordered Set implementation that
+runs nearly as fast as HashSet.
List interface (an
+unsynchronized Vector). The best all-around implementation
+of the List interface.
Deque
interface.List interface.
+Provides better performance than the ArrayList
implementation if elements are frequently inserted or deleted
-within the list. Also implements the Deque interface. When
-accessed through the Queue interface, LinkedList
+within the list. Also implements the Deque interface. When
+accessed through the Queue interface, LinkedList
acts as a FIFO queue.Map interface (an
+unsynchronized Hashtable that supports null keys
+and values). The best all-around implementation of the Map
interface.NavigableMap
interface.Map
+interface. An insertion-ordered Map implementation that
+runs nearly as fast as HashMap. Also useful for building
caches (see
removeEldestEntry(Map.Entry) ).UnsupportedOperationException if the user attempts to
modify it.
-ClassCastException if a client attempts to add an
element of the wrong type. The generics mechanism in the language
provides compile-time (static) type checking, but it is possible to
bypass this mechanism. Dynamically type-safe views eliminate this
@@ -219,12 +216,12 @@
Set implementation from a general-purpose Map
implementation.Deque as a Last In First Out (LIFO) Queue.
List
interface with additional legacy methods.Map
+interface that does not allow null keys or values, plus
additional legacy methods.Map interface that stores only
weak
references to its keys. Storing only weak references
enables key-value pairs to be garbage collected when the key is no
-longer referenced outside of the WeakHashMap. This class
+longer referenced outside of the WeakHashMap. This class
is the easiest way to use the power of weak references. It is
useful for implementing registry-like data structures, where the
utility of an entry vanishes when its key is no longer reachable by
any thread.Map implementation based on a hash table.
This class is useful for topology-preserving object graph
transformations (such as serialization or deep copying). To perform
these transformations, you must maintain an identity-based "node
@@ -292,43 +289,43 @@
object-to-meta-information mappings in dynamic debuggers and
similar systems. Finally, identity-based maps are useful in
preventing "spoof attacks" resulting from intentionally perverse
-equals methods. (IdentityHashMap never invokes the equals
+equals methods. (IdentityHashMap never invokes the equals
method on its keys.) An added benefit of this implementation is
that it is fast.List implementation backed by an copy-on-write array.
+All mutative operations (such as add, set, and
+remove) are implemented by making a new copy of the array.
No synchronization is necessary, even during iteration, and
iterators are guaranteed never to throw
-ConcurrentModificationException. This implementation is
+ConcurrentModificationException. This implementation is
well-suited to maintaining event-handler lists (where change is
infrequent, and traversal is frequent and potentially
time-consuming).Set implementation backed by a copy-on-write array.
+This implementation is similar to CopyOnWriteArrayList.
+Unlike most Set implementations, the add,
+remove, and contains methods require time
proportional to the size of the set. This implementation is well
suited to maintaining event-handler lists that must prevent
duplicates.Set implementation backed by a bit
+vector. All elements of each EnumSet instance must be
elements of a single enum type.Map implementation backed by an array.
+All keys in each EnumMap instance must be elements of a
single enum type.java.util.concurrent.
BlockingQueue interface.TransferQueue backed by linked nodes.
ConcurrentMap
implementation based on a hash table. This implementation never
blocks when performing retrievals and enables the client to select
the concurrency level for updates. It is intended as a drop-in
-replacement for Hashtable. In
-addition to implementing ConcurrentMap, it supports all of
-the legacy methods of Hashtable.Hashtable. In
+addition to implementing ConcurrentMap, it supports all of
+the legacy methods of Hashtable.
NavigableSet interface.
ConcurrentNavigableMap interface.
Collection implementation that is neither a set
nor a list (such as a "bag" or multiset).Set implementation.List implementation backed by a random access
data store (such as an array).List implementation backed by a sequential
access data store (such as a linked list).Queue implementation.
Map implementation.
Enumeration
interface, enables the user to remove elements from the backing
collection with well-defined, useful semantics.Iterator interface, supports bidirectional iteration,
element replacement, element insertion, and index retrieval.Comparable interface.
List implementations indicate
that they support fast (generally constant time) random access.
This lets generic algorithms change their behavior to provide good
performance when applied to either random or sequential access
@@ -550,14 +547,14 @@
String, and fill arrays of primitives
and objects.
-Copyright © 1998, 2017, Oracle and/or its affiliates. 500 Oracle Parkway
+Copyright © 1998, 2017, Oracle and/or its affiliates. 500 Oracle Parkway
Redwood Shores, CA 94065 USA. All rights reserved.