See: Description
| Interface | Description |
|---|---|
| Collection<E> |
The root interface in the collection hierarchy.
|
| Comparator<T> |
A comparison function, which imposes a total ordering on some collection of objects.
|
| Deque<E> |
A linear collection that supports element insertion and removal at
both ends.
|
| Enumeration<E> |
An object that implements the Enumeration interface generates a series of elements, one at a
time.
|
| EventListener |
A tagging interface that all event listener interfaces must extend.
|
| Iterator<E> |
An iterator over a collection.
|
| List<E> |
An ordered collection (also known as a sequence).
|
| ListIterator<E> |
An iterator for lists that allows the programmer to traverse the list in either direction, modify
the list during iteration, and obtain the iterator's current position in the list.
|
| Map<K,V> |
An object that maps keys to values.
|
| Map.Entry<K,V> |
A map entry (key-value pair).
|
| NavigableMap<K,V> |
A
SortedMap extended with navigation methods returning the
closest matches for given search targets. |
| NavigableSet<E> |
A
SortedSet extended with navigation methods reporting
closest matches for given search targets. |
| Observer |
A class can implement the
Observer interface when it wants to be informed of changes
in observable objects. |
| Queue<E> |
A collection designed for holding elements prior to processing.
|
| RandomAccess |
Marker interface used by List implementations to indicate that they support fast
(generally constant time) random access.
|
| Set<E> |
A collection that contains no duplicate elements.
|
| SortedMap<K,V> |
A
Map that further provides a total ordering on its keys. |
| SortedSet<E> |
A
Set that further provides a total ordering on its elements. |
| Class | Description |
|---|---|
| AbstractCollection<E> |
This class provides a skeletal implementation of the Collection interface, to minimize
the effort required to implement this interface.
|
| 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). |
| AbstractMap<K,V> |
This class provides a skeletal implementation of the Map interface, to minimize the
effort required to implement this interface.
|
| AbstractMap.SimpleEntry<K,V> |
An Entry maintaining a key and a value.
|
| AbstractMap.SimpleImmutableEntry<K,V> |
An Entry maintaining an immutable key and value.
|
| AbstractQueue<E> |
This class provides skeletal implementations of some
Queue
operations. |
| 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).
|
| AbstractSet<E> |
This class provides a skeletal implementation of the Set interface to minimize the
effort required to implement this interface.
|
| ArrayDeque<E> |
Resizable-array implementation of the
Deque interface. |
| ArrayList<E> |
Resizable-array implementation of the List interface.
|
| Arrays |
This class contains various methods for manipulating arrays (such as
sorting and searching).
|
| BitSet |
This class implements a vector of bits that grows as needed.
|
| Calendar |
The
Calendar class is an abstract class that provides methods for converting between
a specific instant in time and a set of calendar fields such as YEAR
, MONTH , DAY_OF_MONTH, HOUR, and so on, and for
manipulating the calendar fields, such as getting the date of the next week. |
| Collections |
This class consists exclusively of static methods that operate on or return
collections.
|
| Date |
The class
Date represents a specific instant in time, with millisecond precision. |
| Dictionary<K,V> |
The
Dictionary class is the abstract parent of any class, such as
Hashtable, which maps keys to values. |
| EventObject |
The root class from which all event state objects shall be derived.
|
| HashMap<K,V> |
Hash table based implementation of the Map interface.
|
| HashSet<E> |
This class implements the Set interface, backed by a hash table (actually a HashMap instance).
|
| Hashtable<K,V> |
This class implements a hash table, which maps keys to values.
|
| LinkedList<E> |
Doubly-linked list implementation of the
List and Deque
interfaces. |
| Objects |
This class consists of
static utility methods for operating
on objects. |
| Observable |
This class represents an observable object, or "data" in the model-view paradigm.
|
| Properties |
The
Properties class represents a persistent set of
properties. |
| PropertyPermission |
This class is for property permissions.
|
| Random |
An instance of this class is used to generate a stream of pseudorandom numbers.
|
| Stack<E> |
The
Stack class represents a last-in-first-out (LIFO) stack of objects. |
| StringTokenizer |
The string tokenizer class allows an application to break a string into tokens.
|
| TimeZone |
TimeZone represents a time zone offset, and also figures out daylight savings. |
| TreeMap<K,V> |
A Red-Black tree based
NavigableMap implementation. |
| TreeSet<E> |
A
NavigableSet implementation based on a TreeMap. |
| Vector<E> |
The
Vector class implements a growable array of objects. |
| WeakHashMap<K,V> |
Hash table based implementation of the Map interface, with weak keys.
|
| Exception | Description |
|---|---|
| ConcurrentModificationException |
This exception may be thrown by methods that have detected concurrent modification of an object
when such modification is not permissible.
|
| EmptyStackException |
Thrown by methods in the
Stack class to indicate that the stack is empty. |
| NoSuchElementException |
Thrown by the
nextElement method of an Enumeration to indicate that
there are no more elements in the enumeration. |