java.util

Interfaces

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 linear collection that supports element insertion and removal at both ends.
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`.
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	`Observer` is the interface to be implemented by objects that receive notification of updates on an `Observable` object.
Queue<E>	A collection designed for holding elements prior to processing.
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.

Classes

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>	This class provides skeletal implementations of some `Queue` operations.
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>	Resizable-array implementation of the `Deque` interface.
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.
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.
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	`EventObject`s represent events.
FormattableFlags	FormattableFlags are used as a parameter to `formatTo(Formatter, int, int, int)` and change the output format in `Formattable`s.
Formatter	Formats arguments according to a format string (like `printf` in C).
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`.
HashSet<E>	HashSet is an implementation of a Set.
Hashtable<K, V>	Hashtable is a synchronized implementation of `Map`.
IdentityHashMap<K, V>	IdentityHashMap is a variant on HashMap which tests equality by reference instead of equality by value.
LinkedHashMap<K, V>	LinkedHashMap is an implementation of `Map` that guarantees iteration order.
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.
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 `String`s.
PropertyPermission	`PropertyPermission` objects represent a permission to access system properties.
PropertyResourceBundle	`PropertyResourceBundle` loads resources from an `InputStream`.
Random	This class provides methods that return pseudo-random values.
ResourceBundle	`ResourceBundle` is an abstract class which is the superclass of classes which provide `Locale`-specific resources.
ResourceBundle.Control
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.
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.
TreeMap<K, V>	A map whose entries are sorted by their keys.
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.

Enums

Formatter.BigDecimalLayoutForm The enumeration giving the available styles for formatting very large decimal numbers.

Exceptions

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 `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.

Errors

ServiceConfigurationError Thrown when a service provider can't be loaded by ServiceLoader.