|
Interface Summary |
| Collection<E> |
Collection is the root of the collection hierarchy. |
| Comparator<T> |
A Comparator is used to compare two objects to determine their ordering with
respect to each other. |
| Deque<E> |
A kind of collection that can insert or remove element at both ends("double
ended queue"). |
| Enumeration<E> |
A legacy iteration interface. |
| EventListener |
EventListener is the superclass of all event listener interfaces. |
| Formattable |
Classes that handle custom formatting for the 's' specifier of Formatter
should implement the Formattable interface. |
| Iterator<E> |
An iterator over a sequence of objects, such as a collection. |
| List<E> |
A List is a collection which maintains an ordering for its elements. |
| ListIterator<E> |
An ListIterator is used to sequence over a List of objects. |
| Map<K,V> |
A Map is a data structure consisting of a set of keys and values
in which each key is mapped to a single value. |
| Map.Entry<K,V> |
Map.Entry is a key/value mapping contained in a Map. |
| MapEntry.Type<RT,KT,VT> |
|
| NavigableMap<K,V> |
NavigableMap is a SortedMap with navigation methods answering the closest
matches for specified item. |
| NavigableSet<E> |
NavigableSet is a SortedSet with navigation methods answering the closest
matches for specified item. |
| Observer |
Observer is the interface to be implemented by objects that
receive notification of updates on an Observable object. |
| Queue<E> |
This kind of collection provides advanced operations compared to basic
collections, such as insertion, extraction, and inspection. |
| RandomAccess |
RandomAccess is implemented by List implementations that support fast
(usually constant time) random access. |
| Set<E> |
A Set is a data structure which does not allow duplicate elements. |
| SortedMap<K,V> |
A map that has its keys ordered. |
| SortedSet<E> |
SortedSet is a Set which iterates over its elements in a sorted order. |
|
Class Summary |
| AbstractCollection<E> |
Class AbstractCollection is an abstract implementation of the Collection interface. |
| AbstractList<E> |
AbstractList is an abstract implementation of the List interface, optimized
for a backing store which supports random access. |
| AbstractMap<K,V> |
A base class for Map implementations. |
| AbstractMap.SimpleEntry<K,V> |
A key-value mapping with mutable values. |
| AbstractMap.SimpleImmutableEntry<K,V> |
An immutable key-value mapping. |
| AbstractQueue<E> |
AbstractQueue is an abstract class which implements some of the methods in
Queue. |
| AbstractSequentialList<E> |
AbstractSequentialList is an abstract implementation of the List interface. |
| AbstractSet<E> |
An AbstractSet is an abstract implementation of the Set interface. |
| ArrayDeque<E> |
An implementation of Deque, backed by an array. |
| ArrayList<E> |
ArrayList is an implementation of List, backed by an array. |
| Arrays |
Arrays contains static methods which operate on arrays. |
| BitSet |
The BitSet class implements a bit field. |
| Calendar |
Calendar is an abstract base class for converting between a
Date object and a set of integer fields such as
YEAR, MONTH, DAY,
HOUR, and so on. |
| Collections |
Collections contains static methods which operate on
Collection classes. |
| Collections.SynchronizedCollection<E> |
|
| Collections.SynchronizedList<E> |
|
| Collections.SynchronizedMap<K,V> |
|
| Collections.SynchronizedRandomAccessList<E> |
|
| Collections.SynchronizedSet<E> |
|
| Collections.SynchronizedSortedMap<K,V> |
|
| Collections.SynchronizedSortedSet<E> |
|
| ComparableTimSort |
This is a near duplicate of TimSort, modified for use with
arrays of objects that implement Comparable, instead of using
explicit comparators. |
| Currency |
This class represents a currency as identified in the ISO 4217 currency
codes. |
| Date |
Date represents a specific moment in time, to the millisecond. |
| Dictionary<K,V> |
Note: Do not use this class since it is obsolete. |
| DualPivotQuicksort |
This class implements the Dual-Pivot Quicksort algorithm by
Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch. |
| EnumMap<K extends Enum<K>,V> |
An Map specialized for use with Enum types as keys. |
| EnumSet<E extends Enum<E>> |
An EnumSet is a specialized Set to be used with enums as keys. |
| EventListenerProxy |
This abstract class provides a simple wrapper for objects of type EventListener. |
| EventObject |
EventObjects represent events. |
| FormattableFlags |
FormattableFlags are used as a parameter to
Formattable.formatTo(Formatter, int, int, int) and change the output
format in Formattables. |
| Formatter |
Formats arguments according to a format string (like printf in C). |
| Grego |
A utility class providing proleptic Gregorian calendar functions
used by time zone and calendar code. |
| GregorianCalendar |
GregorianCalendar is a concrete subclass of Calendar
and provides the standard calendar used by most of the world. |
| HashMap<K,V> |
HashMap is an implementation of Map. |
| HashMap.HashMapEntry<K,V> |
|
| HashSet<E> |
HashSet is an implementation of a Set. |
| Hashtable<K,V> |
Hashtable is a synchronized implementation of Map. |
| HugeEnumSet<E extends Enum<E>> |
A concrete EnumSet for enums with more than 64 elements. |
| IdentityHashMap<K,V> |
IdentityHashMap is a variant on HashMap which tests equality by reference
instead of equality by value. |
| IdentityHashMap.IdentityHashMapEntry<K,V> |
|
| IdentityHashMap.IdentityHashMapEntrySet<KT,VT> |
|
| IdentityHashMap.IdentityHashMapIterator<E,KT,VT> |
|
| LinkedHashMap<K,V> |
LinkedHashMap is an implementation of Map that guarantees iteration order. |
| LinkedHashMap.LinkedEntry<K,V> |
LinkedEntry adds nxt/prv double-links to plain HashMapEntry. |
| LinkedHashSet<E> |
LinkedHashSet is a variant of HashSet. |
| LinkedList<E> |
LinkedList is an implementation of List, backed by a doubly-linked list. |
| ListResourceBundle |
ListResourceBundle is the abstract superclass of classes which provide
resources by implementing the getContents() method to return
the list of resources. |
| Locale |
Locale represents a language/country/variant combination. |
| MapEntry<K,V> |
MapEntry is an internal class which provides an implementation of Map.Entry. |
| MiniEnumSet<E extends Enum<E>> |
A concrete EnumSet for enums with 64 or fewer elements. |
| Observable |
Observable is used to notify a group of Observer objects when a change
occurs. |
| PriorityQueue<E> |
A PriorityQueue holds elements on a priority heap, which orders the elements
according to their natural order or according to the comparator specified at
construction time. |
| Properties |
A Properties object is a Hashtable where the keys and values
must be Strings. |
| PropertyPermission |
PropertyPermission objects represent a permission to access system
properties. |
| PropertyPermissionCollection |
A PermissionCollection for holding PropertyPermissions. |
| PropertyResourceBundle |
PropertyResourceBundle loads resources from an InputStream. |
| Random |
This class provides methods that generates pseudo-random numbers of different
types, such as int, long, double, and float. |
| ResourceBundle |
ResourceBundle is an abstract class which is the superclass of classes which
provide Locale-specific resources. |
| ResourceBundle.Control |
|
| ResourceBundle.MissingBundle |
|
| Scanner |
A parser that parses a text string of primitive types and strings with the
help of regular expressions. |
| ServiceLoader<S> |
A service-provider loader. |
| SimpleTimeZone |
SimpleTimeZone is a concrete subclass of TimeZone
that represents a time zone for use with a Gregorian calendar. |
| SpecialAccess |
Holder for special cross-package access objects. |
| Stack<E> |
Stack is a Last-In/First-Out(LIFO) data structure which represents a
stack of objects. |
| StringTokenizer |
The StringTokenizer class allows an application to break a string
into tokens by performing code point comparison. |
| Timer |
Timers schedule one-shot or recurring tasks for execution. |
| TimerTask |
The TimerTask class represents a task to run at a specified time. |
| TimeZone |
TimeZone represents a time zone, primarily used for configuring a Calendar or
SimpleDateFormat instance. |
| TimSort<T> |
A stable, adaptive, iterative mergesort that requires far fewer than
n lg(n) comparisons when running on partially sorted arrays, while
offering performance comparable to a traditional mergesort when run
on random arrays. |
| TreeMap<K,V> |
A map whose entries are sorted by their keys. |
| TreeMap.AscendingSubMap<K,V> |
|
| TreeMap.DescendingSubMap<K,V> |
|
| TreeMap.NavigableSubMap<K,V> |
|
| TreeMap.Node<K,V> |
|
| TreeSet<E> |
TreeSet is an implementation of SortedSet. |
| UUID |
UUID is an immutable representation of a 128-bit universally unique
identifier (UUID). |
| Vector<E> |
Vector is an implementation of List, backed by an array and synchronized. |
| WeakHashMap<K,V> |
WeakHashMap is an implementation of Map with keys which are WeakReferences. |
|
Exception Summary |
| ConcurrentModificationException |
An ConcurrentModificationException is thrown when a Collection is
modified and an existing iterator on the Collection is used to modify the
Collection as well. |
| DuplicateFormatFlagsException |
The unchecked exception will be thrown out if there are duplicate flags given
out in the format specifier. |
| EmptyStackException |
An EmptyStackException is thrown if the pop/peek method of a stack is
executed on an empty stack. |
| FormatFlagsConversionMismatchException |
A FormatFlagsConversionMismatchException will be thrown if a
conversion and the flags are incompatible. |
| FormatterClosedException |
A FormatterClosedException will be thrown if the formatter has been
closed. |
| IllegalFormatCodePointException |
An IllegalFormatCodePointException will be thrown if an invalid
Unicode code point (defined by Character.isValidCodePoint(int)) is
passed as a parameter to a Formatter. |
| IllegalFormatConversionException |
An IllegalFormatConversionException will be thrown when the parameter
is incompatible with the corresponding format specifier. |
| IllegalFormatException |
An IllegalFormatException is thrown when a format string that
contains either an illegal syntax or format specifier is transferred as a
parameter. |
| IllegalFormatFlagsException |
An IllegalFormatFlagsException will be thrown if the combination of
the format flags is illegal. |
| IllegalFormatPrecisionException |
An IllegalFormatPrecisionException will be thrown if the precision is
a negative other than -1 or in other cases where precision is not supported. |
| IllegalFormatWidthException |
An IllegalFormatWidthException will be thrown if the width is a
negative value other than -1 or in other cases where a width is not
supported. |
| InputMismatchException |
An InputMismatchException is thrown by a scanner to indicate that the
next token does not match or is out of range for the type specified in the
pattern. |
| InvalidPropertiesFormatException |
An InvalidPropertiesFormatException is thrown if loading the XML
document defining the properties does not follow the Properties
specification. |
| MissingFormatArgumentException |
A MissingFormatArgumentException will be thrown if there is no
corresponding argument with the specified conversion or an argument index
that refers to a missing argument. |
| MissingFormatWidthException |
A MissingFormatWidthException will be thrown if the format width is
missing but is required. |
| MissingResourceException |
A MissingResourceException is thrown by ResourceBundle when a
resource bundle cannot be found or a resource is missing from a resource
bundle. |
| NoSuchElementException |
A NoSuchElementException is thrown when trying to retrieve an element
past the end of an Enumeration, or the first or last element from an empty
Vector. |
| TooManyListenersException |
A TooManyListenersException is thrown when an attempt is made to add
more than one listener to an event source which only supports a single
listener. |
| UnknownFormatConversionException |
An UnknownFormatConversionException will be thrown if the format
conversion is unknown. |
| UnknownFormatFlagsException |
An UnknownFormatFlagsException will be thrown if there is
an unknown flag. |