< prev index next >
src/java.base/share/classes/java/util/doc-files/coll-reference.html
Print this page
*** 1,9 ****
! <?xml version="1.0" encoding="utf-8"?>
! <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
! "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
!
<!--
Copyright (c) 1998, 2017, Oracle and/or its affiliates. All rights reserved.
DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
This code is free software; you can redistribute it and/or modify it
--- 1,6 ----
! <!DOCTYPE html>
<!--
Copyright (c) 1998, 2017, Oracle and/or its affiliates. All rights reserved.
DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
This code is free software; you can redistribute it and/or modify it
*** 25,38 ****
Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
or visit www.oracle.com if you need additional information or have any
questions.
-->
! <html lang="en-US" xmlns="http://www.w3.org/1999/xhtml" xml:lang=
! "en-US">
<head>
<title>Outline of the Collections Framework</title>
</head>
<body>
<h1>Outline of the Collections Framework</h1>
<!-- Body text begins here -->
The collections framework consists of:
--- 22,35 ----
Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
or visit www.oracle.com if you need additional information or have any
questions.
-->
! <html lang="en-US">
<head>
<title>Outline of the Collections Framework</title>
+ <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
</head>
<body>
<h1>Outline of the Collections Framework</h1>
<!-- Body text begins here -->
The collections framework consists of:
*** 46,186 ****
the collection (if any) or whether it can contain duplicate
elements.</li>
<li><a href=
"../Set.html"><strong>Set</strong></a> - The
familiar set abstraction. No duplicate elements permitted. May or
! may not be ordered. Extends the <tt>Collection</tt> interface.</li>
<li><a href=
"../List.html"><strong>List</strong></a> -
Ordered collection, also known as a <i>sequence</i>. Duplicates are
generally permitted. Allows positional access. Extends the
! <tt>Collection</tt> interface.</li>
<li><a href=
"../Queue.html"><strong>Queue</strong></a> - A
collection designed for holding elements before processing. Besides
! basic <tt>Collection</tt> operations, queues provide additional
insertion, extraction, and inspection operations.</li>
<li><a href=
"../Deque.html"><strong>Deque</strong></a> - A
<em>double ended queue</em>, supporting element insertion and
! removal at both ends. Extends the <tt>Queue</tt> interface.</li>
<li><a href=
"../Map.html"><strong>Map</strong></a> - A
mapping from keys to values. Each key can map to one value.</li>
<li><a href=
"../SortedSet.html"><strong>SortedSet</strong></a>
- A set whose elements are automatically sorted, either in their
<i>natural ordering</i> (see the <a href=
! "../../lang/Comparable.html"><tt>Comparable</tt></a>
interface) or by a <a href=
! "../Comparator.html"><tt>Comparator</tt></a>
! object provided when a <tt>SortedSet</tt> instance is created.
! Extends the <tt>Set</tt> interface.</li>
<li><a href=
"../SortedMap.html"><strong>SortedMap</strong></a>
- A map whose mappings are automatically sorted by key, either
using the <i>natural ordering</i> of the keys or by a comparator
! provided when a <tt>SortedMap</tt> instance is created. Extends the
! <tt>Map</tt> interface.</li>
<li><a href=
"../NavigableSet.html"><strong>NavigableSet</strong></a>
! - A <tt>SortedSet</tt> extended with navigation methods reporting
! closest matches for given search targets. A <tt>NavigableSet</tt>
may be accessed and traversed in either ascending or descending
order.</li>
<li><a href=
"../NavigableMap.html"><strong>NavigableMap</strong></a>
! - A <tt>SortedMap</tt> extended with navigation methods returning
the closest matches for given search targets. A
! <tt>NavigableMap</tt> can be accessed and traversed in either
ascending or descending key order.</li>
<li><a href=
"../concurrent/BlockingQueue.html"><strong>BlockingQueue</strong></a>
! - A <tt>Queue</tt> 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 <tt><a href=
! "../concurrent/package-summary.html">java.util.concurrent</a></tt>
package.)</li>
<li><a href=
"../concurrent/TransferQueue.html"><strong>TransferQueue</strong></a>
! - A <tt>BlockingQueue</tt> in which producers can wait for
consumers to receive elements. (This interface is part of the
! <tt><a href=
! "../concurrent/package-summary.html">java.util.concurrent</a></tt>
package.)</li>
<li><a href=
"../concurrent/BlockingDeque.html"><strong>BlockingDeque</strong></a>
! - A <tt>Deque</tt> 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 <tt>Deque</tt> and <tt>BlockingQueue</tt> interfaces. (This
! interface is part of the <tt><a href=
! "../concurrent/package-summary.html">java.util.concurrent</a></tt>
package.)</li>
<li><a href=
"../concurrent/ConcurrentMap.html"><strong>ConcurrentMap</strong></a>
! - A <tt>Map</tt> with atomic <tt>putIfAbsent</tt>, <tt>remove</tt>,
! and <tt>replace</tt> methods. (This interface is part of the
! <tt>java.util.concurrent</tt> package.)</li>
<li><a href=
"../concurrent/ConcurrentNavigableMap.html"><strong>
! ConcurrentNavigableMap</strong></a> - A <tt>ConcurrentMap</tt> that
! is also a <tt>NavigableMap</tt>.</li>
</ul>
</li>
<li><strong>General-purpose implementations</strong> - The primary
implementations of the collection interfaces.
<ul>
<li><strong><a href=
"../HashSet.html">HashSet</a></strong> - Hash
! table implementation of the <tt>Set</tt> interface. The best
! all-around implementation of the <tt>Set</tt> interface.</li>
<li><a href=
"../TreeSet.html"><strong>TreeSet</strong></a>
! - Red-black tree implementation of the <tt>NavigableSet</tt>
interface.</li>
<li><strong><a href=
"../LinkedHashSet.html">LinkedHashSet</a></strong>
! - Hash table and linked list implementation of the <tt>Set</tt>
! interface. An insertion-ordered <tt>Set</tt> implementation that
! runs nearly as fast as <tt>HashSet</tt>.</li>
<li><strong><a href=
"../ArrayList.html">ArrayList</a></strong> -
! Resizable array implementation of the <tt>List</tt> interface (an
! unsynchronized <tt>Vector</tt>). The best all-around implementation
! of the <tt>List</tt> interface.</li>
<li><strong><a href=
"../ArrayDeque.html">ArrayDeque</a></strong> -
! Efficient, resizable array implementation of the <tt>Deque</tt>
interface.</li>
<li><a href=
"../LinkedList.html"><strong>LinkedList</strong></a>
! - Doubly-linked list implementation of the <tt>List</tt> interface.
! Provides better performance than the <tt>ArrayList</tt>
implementation if elements are frequently inserted or deleted
! within the list. Also implements the <tt>Deque</tt> interface. When
! accessed through the <tt>Queue</tt> interface, <tt>LinkedList</tt>
acts as a FIFO queue.</li>
<li><strong><a href=
"../PriorityQueue.html">PriorityQueue</a></strong>
- Heap implementation of an unbounded priority queue.</li>
<li><strong><a href=
"../HashMap.html">HashMap</a></strong> - Hash
! table implementation of the <tt>Map</tt> interface (an
! unsynchronized <tt>Hashtable</tt> that supports <tt>null</tt> keys
! and values). The best all-around implementation of the <tt>Map</tt>
interface.</li>
<li><a href=
"../TreeMap.html"><strong>TreeMap</strong></a>
! Red-black tree implementation of the <tt>NavigableMap</tt>
interface.</li>
<li><strong><a href=
"../LinkedHashMap.html">LinkedHashMap</a></strong>
! - Hash table and linked list implementation of the <tt>Map</tt>
! interface. An insertion-ordered <tt>Map</tt> implementation that
! runs nearly as fast as <tt>HashMap</tt>. Also useful for building
caches (see <a href=
"../LinkedHashMap.html#removeEldestEntry-java.util.Map.Entry-">
removeEldestEntry(Map.Entry)</a> ).</li>
</ul>
</li>
--- 43,183 ----
the collection (if any) or whether it can contain duplicate
elements.</li>
<li><a href=
"../Set.html"><strong>Set</strong></a> - The
familiar set abstraction. No duplicate elements permitted. May or
! may not be ordered. Extends the <code>Collection</code> interface.</li>
<li><a href=
"../List.html"><strong>List</strong></a> -
Ordered collection, also known as a <i>sequence</i>. Duplicates are
generally permitted. Allows positional access. Extends the
! <code>Collection</code> interface.</li>
<li><a href=
"../Queue.html"><strong>Queue</strong></a> - A
collection designed for holding elements before processing. Besides
! basic <code>Collection</code> operations, queues provide additional
insertion, extraction, and inspection operations.</li>
<li><a href=
"../Deque.html"><strong>Deque</strong></a> - A
<em>double ended queue</em>, supporting element insertion and
! removal at both ends. Extends the <code>Queue</code> interface.</li>
<li><a href=
"../Map.html"><strong>Map</strong></a> - A
mapping from keys to values. Each key can map to one value.</li>
<li><a href=
"../SortedSet.html"><strong>SortedSet</strong></a>
- A set whose elements are automatically sorted, either in their
<i>natural ordering</i> (see the <a href=
! "../../lang/Comparable.html"><code>Comparable</code></a>
interface) or by a <a href=
! "../Comparator.html"><code>Comparator</code></a>
! object provided when a <code>SortedSet</code> instance is created.
! Extends the <code>Set</code> interface.</li>
<li><a href=
"../SortedMap.html"><strong>SortedMap</strong></a>
- A map whose mappings are automatically sorted by key, either
using the <i>natural ordering</i> of the keys or by a comparator
! provided when a <code>SortedMap</code> instance is created. Extends the
! <code>Map</code> interface.</li>
<li><a href=
"../NavigableSet.html"><strong>NavigableSet</strong></a>
! - A <code>SortedSet</code> extended with navigation methods reporting
! closest matches for given search targets. A <code>NavigableSet</code>
may be accessed and traversed in either ascending or descending
order.</li>
<li><a href=
"../NavigableMap.html"><strong>NavigableMap</strong></a>
! - A <code>SortedMap</code> extended with navigation methods returning
the closest matches for given search targets. A
! <code>NavigableMap</code> can be accessed and traversed in either
ascending or descending key order.</li>
<li><a href=
"../concurrent/BlockingQueue.html"><strong>BlockingQueue</strong></a>
! - A <code>Queue</code> 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 <code><a href=
! "../concurrent/package-summary.html">java.util.concurrent</a></code>
package.)</li>
<li><a href=
"../concurrent/TransferQueue.html"><strong>TransferQueue</strong></a>
! - A <code>BlockingQueue</code> in which producers can wait for
consumers to receive elements. (This interface is part of the
! <code><a href=
! "../concurrent/package-summary.html">java.util.concurrent</a></code>
package.)</li>
<li><a href=
"../concurrent/BlockingDeque.html"><strong>BlockingDeque</strong></a>
! - A <code>Deque</code> 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 <code>Deque</code> and <code>BlockingQueue</code> interfaces. (This
! interface is part of the <code><a href=
! "../concurrent/package-summary.html">java.util.concurrent</a></code>
package.)</li>
<li><a href=
"../concurrent/ConcurrentMap.html"><strong>ConcurrentMap</strong></a>
! - A <code>Map</code> with atomic <code>putIfAbsent</code>, <code>remove</code>,
! and <code>replace</code> methods. (This interface is part of the
! <code>java.util.concurrent</code> package.)</li>
<li><a href=
"../concurrent/ConcurrentNavigableMap.html"><strong>
! ConcurrentNavigableMap</strong></a> - A <code>ConcurrentMap</code> that
! is also a <code>NavigableMap</code>.</li>
</ul>
</li>
<li><strong>General-purpose implementations</strong> - The primary
implementations of the collection interfaces.
<ul>
<li><strong><a href=
"../HashSet.html">HashSet</a></strong> - Hash
! table implementation of the <code>Set</code> interface. The best
! all-around implementation of the <code>Set</code> interface.</li>
<li><a href=
"../TreeSet.html"><strong>TreeSet</strong></a>
! - Red-black tree implementation of the <code>NavigableSet</code>
interface.</li>
<li><strong><a href=
"../LinkedHashSet.html">LinkedHashSet</a></strong>
! - Hash table and linked list implementation of the <code>Set</code>
! interface. An insertion-ordered <code>Set</code> implementation that
! runs nearly as fast as <code>HashSet</code>.</li>
<li><strong><a href=
"../ArrayList.html">ArrayList</a></strong> -
! Resizable array implementation of the <code>List</code> interface (an
! unsynchronized <code>Vector</code>). The best all-around implementation
! of the <code>List</code> interface.</li>
<li><strong><a href=
"../ArrayDeque.html">ArrayDeque</a></strong> -
! Efficient, resizable array implementation of the <code>Deque</code>
interface.</li>
<li><a href=
"../LinkedList.html"><strong>LinkedList</strong></a>
! - Doubly-linked list implementation of the <code>List</code> interface.
! Provides better performance than the <code>ArrayList</code>
implementation if elements are frequently inserted or deleted
! within the list. Also implements the <code>Deque</code> interface. When
! accessed through the <code>Queue</code> interface, <code>LinkedList</code>
acts as a FIFO queue.</li>
<li><strong><a href=
"../PriorityQueue.html">PriorityQueue</a></strong>
- Heap implementation of an unbounded priority queue.</li>
<li><strong><a href=
"../HashMap.html">HashMap</a></strong> - Hash
! table implementation of the <code>Map</code> interface (an
! unsynchronized <code>Hashtable</code> that supports <code>null</code> keys
! and values). The best all-around implementation of the <code>Map</code>
interface.</li>
<li><a href=
"../TreeMap.html"><strong>TreeMap</strong></a>
! Red-black tree implementation of the <code>NavigableMap</code>
interface.</li>
<li><strong><a href=
"../LinkedHashMap.html">LinkedHashMap</a></strong>
! - Hash table and linked list implementation of the <code>Map</code>
! interface. An insertion-ordered <code>Map</code> implementation that
! runs nearly as fast as <code>HashMap</code>. Also useful for building
caches (see <a href=
"../LinkedHashMap.html#removeEldestEntry-java.util.Map.Entry-">
removeEldestEntry(Map.Entry)</a> ).</li>
</ul>
</li>
*** 190,202 ****
<ul>
<li><a href=
"../Collections.html#unmodifiableCollection-java.util.Collection-">
<strong>Collections.unmodifiable<i>Interface</i></strong></a> -
Returns an unmodifiable view of a specified collection that throws
! an <tt>UnsupportedOperationException</tt> if the user attempts to
modify it.</li>
! <li><a name="synchWrappers" href=
"../Collections.html#synchronizedCollection-java.util.Collection-"
id=
"synchWrappers"><strong>Collections.synchronized<i>Interface</i></strong></a>
- Returns a synchronized collection that is backed by the specified
(typically unsynchronized) collection. As long as all accesses to
--- 187,199 ----
<ul>
<li><a href=
"../Collections.html#unmodifiableCollection-java.util.Collection-">
<strong>Collections.unmodifiable<i>Interface</i></strong></a> -
Returns an unmodifiable view of a specified collection that throws
! an <code>UnsupportedOperationException</code> if the user attempts to
modify it.</li>
! <li><a href=
"../Collections.html#synchronizedCollection-java.util.Collection-"
id=
"synchWrappers"><strong>Collections.synchronized<i>Interface</i></strong></a>
- Returns a synchronized collection that is backed by the specified
(typically unsynchronized) collection. As long as all accesses to
*** 204,214 ****
safety is guaranteed.</li>
<li><a href=
"../Collections.html#checkedCollection-java.util.Collection-java.lang.Class-">
<strong>Collections.checked<i>Interface</i></strong></a> - Returns
a dynamically type-safe view of the specified collection, which
! throws a <tt>ClassCastException</tt> 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
possibility.</li>
</ul>
--- 201,211 ----
safety is guaranteed.</li>
<li><a href=
"../Collections.html#checkedCollection-java.util.Collection-java.lang.Class-">
<strong>Collections.checked<i>Interface</i></strong></a> - Returns
a dynamically type-safe view of the specified collection, which
! throws a <code>ClassCastException</code> 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
possibility.</li>
</ul>
*** 217,232 ****
adapt one collections interface to another:
<ul>
<li><strong><a href=
"../Collections.html#newSetFromMap-java.util.Map-">
newSetFromMap(Map)</a></strong> - Creates a general-purpose
! <tt>Set</tt> implementation from a general-purpose <tt>Map</tt>
implementation.</li>
<li><strong><a href=
"../Collections.html#asLifoQueue-java.util.Deque-">
asLifoQueue(Deque)</a></strong> - Returns a view of a
! <tt>Deque</tt> as a Last In First Out (LIFO) <tt>Queue</tt>.</li>
</ul>
</li>
<li><strong>Convenience implementations</strong> - High-performance
"mini-implementations" of the collection interfaces.
<ul>
--- 214,229 ----
adapt one collections interface to another:
<ul>
<li><strong><a href=
"../Collections.html#newSetFromMap-java.util.Map-">
newSetFromMap(Map)</a></strong> - Creates a general-purpose
! <code>Set</code> implementation from a general-purpose <code>Map</code>
implementation.</li>
<li><strong><a href=
"../Collections.html#asLifoQueue-java.util.Deque-">
asLifoQueue(Deque)</a></strong> - Returns a view of a
! <code>Deque</code> as a Last In First Out (LIFO) <code>Queue</code>.</li>
</ul>
</li>
<li><strong>Convenience implementations</strong> - High-performance
"mini-implementations" of the collection interfaces.
<ul>
*** 257,336 ****
<li><strong>Legacy implementations</strong> - Older collection
classes were retrofitted to implement the collection interfaces.
<ul>
<li><a href=
"../Vector.html"><strong>Vector</strong></a> -
! Synchronized resizable array implementation of the <tt>List</tt>
interface with additional legacy methods.</li>
<li><a href=
"../Hashtable.html"><strong>Hashtable</strong></a>
! - Synchronized hash table implementation of the <tt>Map</tt>
! interface that does not allow <tt>null</tt> keys or values, plus
additional legacy methods.</li>
</ul>
</li>
<li><strong>Special-purpose implementations</strong>
<ul>
<li><strong><a href=
"../WeakHashMap.html">WeakHashMap</a></strong>
! - An implementation of the <tt>Map</tt> interface that stores only
<a href="../../lang/ref/WeakReference.html"><i>weak
references</i></a> 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 <tt>WeakHashMap</tt>. 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.</li>
<li><strong><a href=
"../IdentityHashMap.html">IdentityHashMap</a></strong>
! - Identity-based <tt>Map</tt> 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
table" that keeps track of which objects have already been seen.
Identity-based maps are also used to maintain
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. (<tt>IdentityHashMap</tt> never invokes the equals
method on its keys.) An added benefit of this implementation is
that it is fast.</li>
<li><strong><a href=
"../concurrent/CopyOnWriteArrayList.html">CopyOnWriteArrayList</a></strong>
! - A <tt>List</tt> implementation backed by an copy-on-write array.
! All mutative operations (such as <tt>add</tt>, <tt>set</tt>, and
! <tt>remove</tt>) are implemented by making a new copy of the array.
No synchronization is necessary, even during iteration, and
iterators are guaranteed never to throw
! <tt>ConcurrentModificationException</tt>. This implementation is
well-suited to maintaining event-handler lists (where change is
infrequent, and traversal is frequent and potentially
time-consuming).</li>
<li><strong><a href=
"../concurrent/CopyOnWriteArraySet.html">CopyOnWriteArraySet</a></strong>
! - A <tt>Set</tt> implementation backed by a copy-on-write array.
! This implementation is similar to <tt>CopyOnWriteArrayList</tt>.
! Unlike most <tt>Set</tt> implementations, the <tt>add</tt>,
! <tt>remove</tt>, and <tt>contains</tt> methods require time
proportional to the size of the set. This implementation is well
suited to maintaining event-handler lists that must prevent
duplicates.</li>
<li><strong><a href=
"../EnumSet.html">EnumSet</a></strong> - A
! high-performance <tt>Set</tt> implementation backed by a bit
! vector. All elements of each <tt>EnumSet</tt> instance must be
elements of a single enum type.</li>
<li><strong><a href=
"../EnumMap.html">EnumMap</a></strong> - A
! high-performance <tt>Map</tt> implementation backed by an array.
! All keys in each <tt>EnumMap</tt> instance must be elements of a
single enum type.</li>
</ul>
</li>
<li><strong>Concurrent implementations</strong> - These
! implementations are part of <tt>java.util.concurrent</tt>.
<ul>
<li><strong><a href=
"../concurrent/ConcurrentLinkedQueue.html">ConcurrentLinkedQueue</a></strong>
- An unbounded first in, first out (FIFO) queue based on linked
nodes.</li>
--- 254,333 ----
<li><strong>Legacy implementations</strong> - Older collection
classes were retrofitted to implement the collection interfaces.
<ul>
<li><a href=
"../Vector.html"><strong>Vector</strong></a> -
! Synchronized resizable array implementation of the <code>List</code>
interface with additional legacy methods.</li>
<li><a href=
"../Hashtable.html"><strong>Hashtable</strong></a>
! - Synchronized hash table implementation of the <code>Map</code>
! interface that does not allow <code>null</code> keys or values, plus
additional legacy methods.</li>
</ul>
</li>
<li><strong>Special-purpose implementations</strong>
<ul>
<li><strong><a href=
"../WeakHashMap.html">WeakHashMap</a></strong>
! - An implementation of the <code>Map</code> interface that stores only
<a href="../../lang/ref/WeakReference.html"><i>weak
references</i></a> 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 <code>WeakHashMap</code>. 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.</li>
<li><strong><a href=
"../IdentityHashMap.html">IdentityHashMap</a></strong>
! - Identity-based <code>Map</code> 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
table" that keeps track of which objects have already been seen.
Identity-based maps are also used to maintain
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. (<code>IdentityHashMap</code> never invokes the equals
method on its keys.) An added benefit of this implementation is
that it is fast.</li>
<li><strong><a href=
"../concurrent/CopyOnWriteArrayList.html">CopyOnWriteArrayList</a></strong>
! - A <code>List</code> implementation backed by an copy-on-write array.
! All mutative operations (such as <code>add</code>, <code>set</code>, and
! <code>remove</code>) are implemented by making a new copy of the array.
No synchronization is necessary, even during iteration, and
iterators are guaranteed never to throw
! <code>ConcurrentModificationException</code>. This implementation is
well-suited to maintaining event-handler lists (where change is
infrequent, and traversal is frequent and potentially
time-consuming).</li>
<li><strong><a href=
"../concurrent/CopyOnWriteArraySet.html">CopyOnWriteArraySet</a></strong>
! - A <code>Set</code> implementation backed by a copy-on-write array.
! This implementation is similar to <code>CopyOnWriteArrayList</code>.
! Unlike most <code>Set</code> implementations, the <code>add</code>,
! <code>remove</code>, and <code>contains</code> methods require time
proportional to the size of the set. This implementation is well
suited to maintaining event-handler lists that must prevent
duplicates.</li>
<li><strong><a href=
"../EnumSet.html">EnumSet</a></strong> - A
! high-performance <code>Set</code> implementation backed by a bit
! vector. All elements of each <code>EnumSet</code> instance must be
elements of a single enum type.</li>
<li><strong><a href=
"../EnumMap.html">EnumMap</a></strong> - A
! high-performance <code>Map</code> implementation backed by an array.
! All keys in each <code>EnumMap</code> instance must be elements of a
single enum type.</li>
</ul>
</li>
<li><strong>Concurrent implementations</strong> - These
! implementations are part of <code>java.util.concurrent</code>.
<ul>
<li><strong><a href=
"../concurrent/ConcurrentLinkedQueue.html">ConcurrentLinkedQueue</a></strong>
- An unbounded first in, first out (FIFO) queue based on linked
nodes.</li>
*** 350,413 ****
"../concurrent/DelayQueue.html"><strong>DelayQueue</strong></a>
- A time-based scheduling queue backed by a priority heap.</li>
<li><a href=
"../concurrent/SynchronousQueue.html"><strong>SynchronousQueue</strong></a>
- A simple rendezvous mechanism that uses the
! <tt>BlockingQueue</tt> interface.</li>
<li><a href=
"../concurrent/LinkedBlockingDeque.html"><strong>
LinkedBlockingDeque</strong></a> - An optionally bounded FIFO
blocking deque backed by linked nodes.</li>
<li><a href=
"../concurrent/LinkedTransferQueue.html"><strong>
LinkedTransferQueue</strong></a> - An unbounded
! <tt>TransferQueue</tt> backed by linked nodes.</li>
<li><a href=
"../concurrent/ConcurrentHashMap.html"><strong>ConcurrentHashMap</strong></a>
! - A highly concurrent, high-performance <tt>ConcurrentMap</tt>
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 <tt><a href=
! "../Hashtable.html">Hashtable</a></tt>. In
! addition to implementing <tt>ConcurrentMap</tt>, it supports all of
! the legacy methods of <tt>Hashtable</tt>.</li>
<li><a href=
"../concurrent/ConcurrentSkipListSet.html"><strong>
ConcurrentSkipListSet</strong></a> - Skips list implementation of
! the <tt>NavigableSet</tt> interface.</li>
<li><a href=
"../concurrent/ConcurrentSkipListMap.html"><strong>
ConcurrentSkipListMap</strong></a> - Skips list implementation of
! the <tt>ConcurrentNavigableMap</tt> interface.</li>
</ul>
</li>
<li><strong>Abstract implementations</strong> - Skeletal
implementations of the collection interfaces to facilitate custom
implementations.
<ul>
<li><a href=
"../AbstractCollection.html"><strong>AbstractCollection</strong></a>
! - Skeletal <tt>Collection</tt> implementation that is neither a set
nor a list (such as a "bag" or multiset).</li>
<li><a href=
"../AbstractSet.html"><strong>AbstractSet</strong></a>
! - Skeletal <tt>Set</tt> implementation.</li>
<li><a href=
"../AbstractList.html"><strong>AbstractList</strong></a>
! - Skeletal <tt>List</tt> implementation backed by a random access
data store (such as an array).</li>
<li><a href=
"../AbstractSequentialList.html"><strong>AbstractSequentialList</strong></a>
! - Skeletal <tt>List</tt> implementation backed by a sequential
access data store (such as a linked list).</li>
<li><a href=
"../AbstractQueue.html"><strong>AbstractQueue</strong></a>
! - Skeletal <tt>Queue</tt> implementation.</li>
<li><a href=
"../AbstractMap.html"><strong>AbstractMap</strong></a>
! - Skeletal <tt>Map</tt> implementation.</li>
</ul>
</li>
<li><strong>Algorithms</strong> - The <a href=
"../Collections.html"><strong>Collections</strong></a>
class contains these useful static methods.
--- 347,410 ----
"../concurrent/DelayQueue.html"><strong>DelayQueue</strong></a>
- A time-based scheduling queue backed by a priority heap.</li>
<li><a href=
"../concurrent/SynchronousQueue.html"><strong>SynchronousQueue</strong></a>
- A simple rendezvous mechanism that uses the
! <code>BlockingQueue</code> interface.</li>
<li><a href=
"../concurrent/LinkedBlockingDeque.html"><strong>
LinkedBlockingDeque</strong></a> - An optionally bounded FIFO
blocking deque backed by linked nodes.</li>
<li><a href=
"../concurrent/LinkedTransferQueue.html"><strong>
LinkedTransferQueue</strong></a> - An unbounded
! <code>TransferQueue</code> backed by linked nodes.</li>
<li><a href=
"../concurrent/ConcurrentHashMap.html"><strong>ConcurrentHashMap</strong></a>
! - A highly concurrent, high-performance <code>ConcurrentMap</code>
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 <code><a href=
! "../Hashtable.html">Hashtable</a></code>. In
! addition to implementing <code>ConcurrentMap</code>, it supports all of
! the legacy methods of <code>Hashtable</code>.</li>
<li><a href=
"../concurrent/ConcurrentSkipListSet.html"><strong>
ConcurrentSkipListSet</strong></a> - Skips list implementation of
! the <code>NavigableSet</code> interface.</li>
<li><a href=
"../concurrent/ConcurrentSkipListMap.html"><strong>
ConcurrentSkipListMap</strong></a> - Skips list implementation of
! the <code>ConcurrentNavigableMap</code> interface.</li>
</ul>
</li>
<li><strong>Abstract implementations</strong> - Skeletal
implementations of the collection interfaces to facilitate custom
implementations.
<ul>
<li><a href=
"../AbstractCollection.html"><strong>AbstractCollection</strong></a>
! - Skeletal <code>Collection</code> implementation that is neither a set
nor a list (such as a "bag" or multiset).</li>
<li><a href=
"../AbstractSet.html"><strong>AbstractSet</strong></a>
! - Skeletal <code>Set</code> implementation.</li>
<li><a href=
"../AbstractList.html"><strong>AbstractList</strong></a>
! - Skeletal <code>List</code> implementation backed by a random access
data store (such as an array).</li>
<li><a href=
"../AbstractSequentialList.html"><strong>AbstractSequentialList</strong></a>
! - Skeletal <code>List</code> implementation backed by a sequential
access data store (such as a linked list).</li>
<li><a href=
"../AbstractQueue.html"><strong>AbstractQueue</strong></a>
! - Skeletal <code>Queue</code> implementation.</li>
<li><a href=
"../AbstractMap.html"><strong>AbstractMap</strong></a>
! - Skeletal <code>Map</code> implementation.</li>
</ul>
</li>
<li><strong>Algorithms</strong> - The <a href=
"../Collections.html"><strong>Collections</strong></a>
class contains these useful static methods.
*** 489,505 ****
"../Enumeration.html">Enumeration</a>
interface, but more powerful, and with improved method names.
<ul>
<li><a href=
"../Iterator.html"><strong>Iterator</strong></a>
! - In addition to the functionality of the <tt>Enumeration</tt>
interface, enables the user to remove elements from the backing
collection with well-defined, useful semantics.</li>
<li><a href=
"../ListIterator.html"><strong>ListIterator</strong></a>
- Iterator for use with lists. In addition to the functionality of
! the <tt>Iterator</tt> interface, supports bidirectional iteration,
element replacement, element insertion, and index retrieval.</li>
</ul>
</li>
<li><strong>Ordering</strong>
<ul>
--- 486,502 ----
"../Enumeration.html">Enumeration</a>
interface, but more powerful, and with improved method names.
<ul>
<li><a href=
"../Iterator.html"><strong>Iterator</strong></a>
! - In addition to the functionality of the <code>Enumeration</code>
interface, enables the user to remove elements from the backing
collection with well-defined, useful semantics.</li>
<li><a href=
"../ListIterator.html"><strong>ListIterator</strong></a>
- Iterator for use with lists. In addition to the functionality of
! the <code>Iterator</code> interface, supports bidirectional iteration,
element replacement, element insertion, and index retrieval.</li>
</ul>
</li>
<li><strong>Ordering</strong>
<ul>
*** 512,522 ****
<li><a href=
"../Comparator.html"><strong>Comparator</strong></a>
- Represents an order relation, which can be used to sort a list or
maintain order in a sorted set or map. Can override a type's
natural ordering or order objects of a type that does not implement
! the <tt>Comparable</tt> interface.</li>
</ul>
</li>
<li><strong>Runtime exceptions</strong>
<ul>
<li><a href=
--- 509,519 ----
<li><a href=
"../Comparator.html"><strong>Comparator</strong></a>
- Represents an order relation, which can be used to sort a list or
maintain order in a sorted set or map. Can override a type's
natural ordering or order objects of a type that does not implement
! the <code>Comparable</code> interface.</li>
</ul>
</li>
<li><strong>Runtime exceptions</strong>
<ul>
<li><a href=
*** 534,544 ****
</li>
<li><strong>Performance</strong>
<ul>
<li><strong><a href=
"../RandomAccess.html">RandomAccess</a></strong>
! - Marker interface that lets <tt>List</tt> 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
lists.</li>
</ul>
--- 531,541 ----
</li>
<li><strong>Performance</strong>
<ul>
<li><strong><a href=
"../RandomAccess.html">RandomAccess</a></strong>
! - Marker interface that lets <code>List</code> 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
lists.</li>
</ul>
*** 548,564 ****
<li><strong>Array Utilities</strong>
<ul>
<li><a href=
"../Arrays.html"><strong>Arrays</strong></a> -
Contains static methods to sort, search, compare, hash, copy,
! resize, convert to <tt>String</tt>, and fill arrays of primitives
and objects.</li>
</ul>
</li>
</ul>
! <hr />
<p style="font-size:smaller">
! Copyright © 1998, 2017, Oracle and/or its affiliates. 500 Oracle Parkway<br />
Redwood Shores, CA 94065 USA. All rights reserved.</p>
<!-- Body text ends here -->
</body>
</html>
--- 545,561 ----
<li><strong>Array Utilities</strong>
<ul>
<li><a href=
"../Arrays.html"><strong>Arrays</strong></a> -
Contains static methods to sort, search, compare, hash, copy,
! resize, convert to <code>String</code>, and fill arrays of primitives
and objects.</li>
</ul>
</li>
</ul>
! <hr>
<p style="font-size:smaller">
! Copyright © 1998, 2017, Oracle and/or its affiliates. 500 Oracle Parkway<br>
Redwood Shores, CA 94065 USA. All rights reserved.</p>
<!-- Body text ends here -->
</body>
</html>
< prev index next >