# Package java.util

package java.util
Contains the collections framework, some internationalization support classes, a service loader, properties, random number generation, string parsing and scanning classes, base64 encoding and decoding, a bit array, and several miscellaneous utility classes. This package also contains legacy collection classes and legacy date and time classes.

## Java Collections Framework

For an overview, API outline, and design rationale, please see:

- Collections Framework Documentation

For a tutorial and programming guide with examples of use of the collections framework, please see:

- Collections Framework Tutorial

Since:
  1.0

- Related Packages
  Module
  Package
  Description
  java.base
  java.util.concurrent
  Utility classes commonly useful in concurrent programming.
  java.base
  java.util.function
  Functional interfaces provide target types for lambda expressions and method references.
  java.base
  java.util.jar
  Provides classes for reading and writing the JAR (Java ARchive) file format, which is based on the standard ZIP file format with an optional manifest file.
  java.logging
  java.util.logging
  Provides the classes and interfaces of the Java 2 platform's core logging facilities.
  java.prefs
  java.util.prefs
  This package allows applications to store and retrieve user and system preference and configuration data.
  java.base
  java.util.random
  This package contains classes and interfaces that support a generic API for random number generation.
  java.base
  java.util.regex
  Classes for matching character sequences against patterns specified by regular expressions.
  java.base
  java.util.spi
  Service provider classes for the classes in the java.util package.
  java.base
  java.util.stream
  Classes to support functional-style operations on streams of elements, such as map-reduce transformations on collections.
  java.base
  java.util.zip
  Provides classes for reading and writing the standard ZIP and GZIP file formats.
- 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 unmodifiable Entry maintaining a key and a 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).
  Base64
  This class consists exclusively of static methods for obtaining encoders and decoders for the Base64 encoding scheme.
  Base64.Decoder
  This class implements a decoder for decoding byte data using the Base64 encoding scheme as specified in RFC 4648 and RFC 2045.
  Base64.Encoder
  This class implements an encoder for encoding byte data using the Base64 encoding scheme as specified in RFC 4648 and RFC 2045.
  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.
  Calendar.Builder
  `Calendar.Builder` is used for creating a `Calendar` from various date-time parameters.
  Collection<E>
  The root interface in the collection hierarchy.
  Collections
  This class consists exclusively of static methods that operate on or return collections.
  Comparator<T>
  A comparison function, which imposes a total ordering on some collection of objects.
  ConcurrentModificationException
  This exception may be thrown by methods that have detected concurrent modification of an object when such modification is not permissible.
  Currency
  Represents a currency.
  Date
  The class `Date` represents a specific instant in time, with millisecond precision.
  Deque<E>
  A linear collection that supports element insertion and removal at both ends.
  Dictionary<K,V>
  The `Dictionary` class is the abstract parent of any class, such as `Hashtable`, which maps keys to values.
  DoubleSummaryStatistics
  A state object for collecting statistics such as count, min, max, sum, and average.
  DuplicateFormatFlagsException
  Unchecked exception thrown when duplicate flags are provided in the format specifier.
  EmptyStackException
  Thrown by methods in the `Stack` class to indicate that the stack is empty.
  Enumeration<E>
  An object that implements the Enumeration interface generates a series of elements, one at a time.
  EnumMap<K extends Enum<K>, V>
  A specialized `Map` implementation for use with enum type keys.
  EnumSet<E extends Enum<E>>
  A specialized `Set` implementation for use with enum types.
  EventListener
  A tagging interface that all event listener interfaces must extend.
  EventListenerProxy<T extends EventListener>
  An abstract wrapper class for an `EventListener` class which associates a set of additional parameters with the listener.
  EventObject
  The root class from which all event state objects shall be derived.
  FormatFlagsConversionMismatchException
  Unchecked exception thrown when a conversion and flag are incompatible.
  Formattable
  The `Formattable` interface must be implemented by any class that needs to perform custom formatting using the `'s'` conversion specifier of `Formatter`.
  FormattableFlags
  FormattableFlags are passed to the `Formattable.formatTo()` method and modify the output format for Formattables.
  Formatter
  An interpreter for printf-style format strings.
  Formatter.BigDecimalLayoutForm
  Enum for `BigDecimal` formatting.
  FormatterClosedException
  Unchecked exception thrown when the formatter has been closed.
  GregorianCalendar
  `GregorianCalendar` is a concrete subclass of `Calendar` and provides the standard calendar system used by most of the world.
  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.
  HexFormat
  `HexFormat` converts between bytes and chars and hex-encoded strings which may include additional formatting markup such as prefixes, suffixes, and delimiters.
  IdentityHashMap<K,V>
  This class implements the `Map` interface with a hash table, using reference-equality in place of object-equality when comparing keys (and values).
  IllegalFormatCodePointException
  Unchecked exception thrown when a character with an invalid Unicode code point as defined by `Character.isValidCodePoint(int)` is passed to the `Formatter`.
  IllegalFormatConversionException
  Unchecked exception thrown when the argument corresponding to the format specifier is of an incompatible type.
  IllegalFormatException
  Unchecked exception thrown when a format string contains an illegal syntax or a format specifier that is incompatible with the given arguments.
  IllegalFormatFlagsException
  Unchecked exception thrown when an illegal combination flags is given.
  IllegalFormatPrecisionException
  Unchecked exception thrown when the precision is a negative value other than `-1`, the conversion does not support a precision, or the value is otherwise unsupported.
  IllegalFormatWidthException
  Unchecked exception thrown when the format width is a negative value other than `-1` or is otherwise unsupported.
  IllformedLocaleException
  Thrown by methods in `Locale` and `Locale.Builder` to indicate that an argument is not a well-formed BCP 47 tag.
  InputMismatchException
  Thrown by a `Scanner` to indicate that the token retrieved does not match the pattern for the expected type, or that the token is out of range for the expected type.
  IntSummaryStatistics
  A state object for collecting statistics such as count, min, max, sum, and average.
  InvalidPropertiesFormatException
  Thrown to indicate that an operation could not complete because the input did not conform to the appropriate XML document type for a collection of properties, as per the `Properties` specification.
  Iterator<E>
  An iterator over a collection.
  LinkedHashMap<K,V>
  Hash table and linked list implementation of the `Map` interface, with well-defined encounter order.
  LinkedHashSet<E>
  Hash table and linked list implementation of the `Set` interface, with well-defined encounter order.
  LinkedList<E>
  Doubly-linked list implementation of the `List` and `Deque` interfaces.
  List<E>
  An ordered collection, where the user has precise control over where in the list each element is inserted.
  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.
  ListResourceBundle
  `ListResourceBundle` is an abstract subclass of `ResourceBundle` that manages resources for a locale in a convenient and easy to use list.
  Locale
  A `Locale` represents a specific geographical, political, or cultural region.
  Locale.Builder
  `Builder` is used to build instances of `Locale` from values configured by the setters.
  Locale.Category
  Enum for locale categories.
  Locale.FilteringMode
  This enum provides constants to select a filtering mode for locale matching.
  Locale.IsoCountryCode
  Enum for specifying the type defined in ISO 3166.
  Locale.LanguageRange
  This class expresses a Language Range defined in RFC 4647 Matching of Language Tags.
  LongSummaryStatistics
  A state object for collecting statistics such as count, min, max, sum, and average.
  Map<K,V>
  An object that maps keys to values.
  Map.Entry<K,V>
  A map entry (key-value pair).
  MissingFormatArgumentException
  Unchecked exception thrown when there is a format specifier which does not have a corresponding argument or if an argument index refers to an argument that does not exist.
  MissingFormatWidthException
  Unchecked exception thrown when the format width is required.
  MissingResourceException
  Signals that a resource is missing.
  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.
  NoSuchElementException
  Thrown by various accessor methods to indicate that the element being requested does not exist.
  Objects
  This class consists of `static` utility methods for operating on objects, or checking certain conditions before operation.
  Observable
  Deprecated.
  This class and the `Observer` interface have been deprecated.
  Observer
  Deprecated.
  This interface has been deprecated.
  Optional<T>
  A container object which may or may not contain a non-`null` value.
  OptionalDouble
  A container object which may or may not contain a `double` value.
  OptionalInt
  A container object which may or may not contain an `int` value.
  OptionalLong
  A container object which may or may not contain a `long` value.
  PrimitiveIterator<T,T_CONS>
  A base type for primitive specializations of `Iterator`.
  PrimitiveIterator.OfDouble
  An Iterator specialized for `double` values.
  PrimitiveIterator.OfInt
  An Iterator specialized for `int` values.
  PrimitiveIterator.OfLong
  An Iterator specialized for `long` values.
  PriorityQueue<E>
  An unbounded priority queue based on a priority heap.
  Properties
  The `Properties` class represents a persistent set of properties.
  PropertyPermission
  Deprecated, for removal: This API element is subject to removal in a future version.
  This permission cannot be used for controlling access to resources as the Security Manager is no longer supported.
  PropertyResourceBundle
  `PropertyResourceBundle` is a concrete subclass of `ResourceBundle` that manages resources for a locale using a set of static strings from a property file.
  Queue<E>
  A collection designed for holding elements prior to processing.
  Random
  An instance of this class is used to generate a stream of pseudorandom numbers; its period is only 248.
  RandomAccess
  Marker interface used by `List` implementations to indicate that they support fast (generally constant time) random access.
  ResourceBundle
  Resource bundles contain locale-specific objects.
  ResourceBundle.Control
  `ResourceBundle.Control` defines a set of callback methods that are invoked by the `ResourceBundle.getBundle` factory methods during the bundle loading process.
  Scanner
  A simple text scanner which can parse primitive types and strings using regular expressions.
  SequencedCollection<E>
  A collection that has a well-defined encounter order, that supports operations at both ends, and that is reversible.
  SequencedMap<K,V>
  A Map that has a well-defined encounter order, that supports operations at both ends, and that is reversible.
  SequencedSet<E>
  A collection that is both a `SequencedCollection` and a `Set`.
  ServiceConfigurationError
  Error thrown when something goes wrong while locating, loading, or instantiating a service provider.
  ServiceLoader<S>
  A facility to load implementations of a service.
  ServiceLoader.Provider<S>
  Represents a service provider located by `ServiceLoader`.
  Set<E>
  A collection that contains no duplicate elements.
  SimpleTimeZone
  `SimpleTimeZone` is a concrete subclass of `TimeZone` that represents a time zone for use with a Gregorian calendar.
  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.
  Spliterator<T>
  An object for traversing and partitioning elements of a source.
  Spliterator.OfDouble
  A Spliterator specialized for `double` values.
  Spliterator.OfInt
  A Spliterator specialized for `int` values.
  Spliterator.OfLong
  A Spliterator specialized for `long` values.
  Spliterator.OfPrimitive<T, T_CONS, T_SPLITR extends Spliterator.OfPrimitive<T,T_CONS,T_SPLITR>>
  A Spliterator specialized for primitive values.
  Spliterators
  Static classes and methods for operating on or creating instances of `Spliterator` and its primitive specializations `Spliterator.OfInt`, `Spliterator.OfLong`, and `Spliterator.OfDouble`.
  Spliterators.AbstractDoubleSpliterator
  An abstract `Spliterator.OfDouble` that implements `trySplit` to permit limited parallelism.
  Spliterators.AbstractIntSpliterator
  An abstract `Spliterator.OfInt` that implements `trySplit` to permit limited parallelism.
  Spliterators.AbstractLongSpliterator
  An abstract `Spliterator.OfLong` that implements `trySplit` to permit limited parallelism.
  Spliterators.AbstractSpliterator<T>
  An abstract `Spliterator` that implements `trySplit` to permit limited parallelism.
  SplittableRandom
  A generator of uniform pseudorandom values (with period 264) applicable for use in (among other contexts) isolated parallel computations that may generate subtasks.
  Stack<E>
  The `Stack` class represents a last-in-first-out (LIFO) stack of objects.
  StringJoiner
  `StringJoiner` is used to construct a sequence of characters separated by a delimiter and optionally starting with a supplied prefix and ending with a supplied suffix.
  StringTokenizer
  The string tokenizer class allows an application to break a string into tokens.
  Timer
  A facility for threads to schedule tasks for future execution in a background thread.
  TimerTask
  A task that can be scheduled for one-time or repeated execution by a `Timer`.
  TimeZone
  `TimeZone` represents a time zone offset, and also figures out daylight savings.
  TooManyListenersException
  The `TooManyListenersException` Exception is used as part of the Java Event model to annotate and implement a unicast special case of a multicast Event Source.
  TreeMap<K,V>
  A Red-Black tree based `NavigableMap` implementation.
  TreeSet<E>
  A `NavigableSet` implementation based on a `TreeMap`.
  UnknownFormatConversionException
  Unchecked exception thrown when an unknown conversion is given.
  UnknownFormatFlagsException
  Unchecked exception thrown when an unknown flag is given.
  UUID
  A class that represents an immutable universally unique identifier (UUID).
  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.