当前页面:
在线文档首页 >
Java 2 SDK v1.4.2, Java 2 SDK 英文文档
Annotated Outline of the Collections Framework - Java 2 SDK v1.4.2, Java 2 SDK 英文文档
|
Annotated Outline of Collections Framework
|
The collections framework consists of:
- Collection Interfaces - The primary means by which
collections are manipulated.
- Collection
- A group of objects. No assumptions are made about the order of
the collection (if any), or whether it may contain duplicate elements.
- Set
- The familiar set abstraction. No duplicate elements permitted. May
or may not be ordered. Extends the Collection interface.
- List
- Ordered collection, also known as a sequence. Duplicates are
generally permitted. Allows positional access. Extends the
Collection interface.
- Map
- A mapping from keys to values. Each key can map to at most one value.
- SortedSet
- A set whose elements are automatically sorted, either in their
natural ordering (see the Comparable
interface), or by a Comparator
object provided when a SortedSet instance is created.
Extends the Set interface.
- SortedMap
- A map whose mappings are automatically sorted by key, either in the
keys' natural ordering or by a comparator provided when a
SortedMap instance is created. Extends the Map
interface.
- General-Purpose Implementations - The primary
implementations of the collection interfaces.
- HashSet
- Hash table implementation of the Set interface.
The best all-around implementation of the Set interface.
-
TreeSet
Red-black tree implementation of the SortedSet interface.
- LinkedHashSet
- Hash table and linked list implementation of the Set interface.
An insertion-ordered Set implementation that runs nearly as fast as
HashSet.
- ArrayList -
Resizable-array implementation of the List interface.
(Essentially an unsynchronized Vector.) The best all-around
implementation of the List interface.
-
LinkedList
- Doubly-linked list implementation of the List interface.
May provide better performance than the ArrayList
implementation if elements are frequently inserted or deleted within
the list. Useful for queues and double-ended queues (deques).
- HashMap - Hash
table implementation of the Map interface. (Essentially an
unsynchronized Hashtable that supports null keys and
values.) The best all-around implementation of the Map
interface.
-
TreeMap
Red-black tree implementation of the SortedMap interface.
- LinkedHashMap
- Hash table and linked list implementation of the Map interface.
An insertion-ordered Map implementation that runs nearly as fast as
HashMap. Also useful for building caches (see
removeEldestEntry(Map.Entry)
).
- Wrapper Implementations - Functionality-enhancing
implementations for use with other implementations. Accessed soley
through static factory methods.
-
Collections.unmodifiableInterface
- Return an unmodifiable view of a specified collection that throws an
UnsupportedOperationException if the user attempts to modify
it.
-
Collections.synchronizedInterface - Return
a synchronized collection that is backed by the specified (typically
unsynchronized) collection. As long as all accesses to the backing
collection are through the returned collection, thread-safety is
guaranteed.
- Convenience Implementations - High-performance
"mini-implementations" of the collection interfaces.
- Legacy Implementations - Older collection classes have
been retrofitted to implement the collection interfaces.
-
Vector
- Synchronized resizable-array implementation of the List interface
with additional "legacy methods."
-
Hashtable
- Synchronized hash table implementation of the Map interface
that does not allow null keys or values, with additional
"legacy methods."
- Special Purpose Implementations
-
WeakHashMap -
an implementation of the Map interface that stores only weak
references to its keys. Storing only weak references allows
key-value pairs to be garbage-collected when the key is no longer
referenced outside of the WeakHashMap. This class provides
the easiest way to harness 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.
- IdentityHashMap
- Identity-based 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 such transformations, you need to 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 thwarting "spoof attacks" resulting
from intentionally perverse equals methods. (IdentityHashMap never
invokes the equals method on its keys.) An added benefit of this
implementation is that it is fast.
Abstract Implementations - Partial implementations of
the collection interfaces to facilitate custom implementations.
-
AbstractCollection
- Skeletal implementation of a collection that is neither a set nor a
list (such as a "bag" or multiset).
-
AbstractSet
- Skeletal implementation of a set.
-
AbstractList
- Skeletal implementation of a list backed by a random-access data store
(such as an array).
-
AbstractSequentialList
- Skeletal implementation of a list backed by a sequential-access data store
(such as a linked list).
-
AbstractMap
- Skeletal implementation of a map.
Algorithms
-
sort(List) - Sorts a list using a merge sort
algorithm, which provides average-case performance comparable to a
high-quality quicksort, guaranteed O(n*log n) performance (unlike quicksort),
and stability (unlike quicksort). (A stable sort is one that does
not reorder equal elements.)
- binarySearch(List, Object) - Searches
for an element in an ordered list using the binary search algorithm.
- reverse(List)
- Reverses the order of the elements in the a list.
- shuffle(List)
- Randomly permutes the elements in a list.
- fill(List, Object) - Overwrites every
element in a list with the specified value.
- copy(List dest, List src) - Copies the
source list into the destination list.
-
min(Collection) - Returns the minimum element in a
collection.
-
max(Collection) - Returns the maximum element in a
collection.
- rotate(List list, int distance) - Rotates all of the elements
in the list by the the specified distance.
- replaceAll(List list, Object oldVal,
Object newVal) - Replaces all occurrences of one specified value with another.
- indexOfSubList(List source, List target) - Returns the index of the first sublist of source that is equal to
target.
- lastIndexOfSubList(List source, List target) -
Returns the index of the last sublist of source that is equal to
target.
- swap(List list, int, int) - Swaps the elements at
the specified positions in the specified list.
Infrastructure
- Iterators - Similar to the familiar
Enumeration interface,
but more powerful, and with improved method names.
-
Iterator
- In addition to the functionality of the Enumeration
interface, allows the user to remove elements from the backing
collection with well defined, useful semantics.
-
ListIterator
- Iterator for use with lists. In addition to the functionality of
the Iterator interface, supports bi-directional iteration,
element replacement, element insertion and index retrieval.
- Ordering
-
Comparable
- Imparts a natural ordering to classes that implement it. The
natural ordering may be used to sort a list or maintain order in a
sorted set or map. Many classes have been retrofitted to implement
this interface.
-
Comparator
- Represents an order relation, which may 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
Comparable interface.
- Runtime Exceptions
-
UnsupportedOperationException - Thrown by
collections if an unsupported optional operation is called.
-
ConcurrentModificationException - Thrown by
iterators and list iterators if the backing collection is modified
unexpectedly while the iteration is in progress. Also thrown by
sublist views of lists if the backing list is modified
unexpectedly.
- Performance
-
RandomAccess
- Marker interface that allows List implementations to indicate that
they support fast (generally constant time) random access. This allows
generic algorithms to alter their behavior to provide good performance when
applied to either random or sequential access lists.
Array Utilities
- Arrays
- Contains static methods to sort, search, compare and fill arrays of primitives and Objects.