Package java.util

package java.util
  • Class
    Description
    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>
    This class is an abstract implementation of the Map interface.
    AbstractMap.SimpleEntry<K,V>
    A key-value mapping.
    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.
    Base64
    java.util.Base64: the basic, URL-safe and MIME encodings of RFC 4648 and RFC 2045, by the JDK's rules for padding and for what a decoder refuses.
    Base64.Decoder
    java.util.Base64.Decoder.
    Base64.Encoder
    java.util.Base64.Encoder.
    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.
    Collection<E>
    Collection is the root of the collection hierarchy.
    Collections
    Collections contains static methods which operate on Collection classes.
    Comparator<T>
    A Comparator is used to compare two objects to determine their ordering with respect to each other.
    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.
    Date
    The class Date represents a specific instant in time, with millisecond precision.
    Deque<E>
    A kind of collection that can insert or remove element at both ends("double ended queue").
    Dictionary<K,V>
    **Note: Do not use this class since it is obsolete.
    DoubleSummaryStatistics
    The count, sum, minimum, maximum and average of the values it was given.
    EmptyStackException
    Thrown by methods in the Stack class to indicate that the stack is empty.
    Enumeration<T>
    An object that implements the Enumeration interface generates a series of elements, one at a time.
    EventListener
    EventListener is the superclass of all event listener interfaces.
    EventListenerProxy
    This abstract class provides a simple wrapper for objects of type EventListener.
    EventObject
    java.util.EventObject: the root of every listener event, carrying the object the event happened on.
    HashMap<K,V>
    HashMap is an implementation of Map.
    HashSet<E>
    HashSet is an implementation of a Set.
    Hashtable<K,V>
    Hashtable associates keys with values.
    HexFormat
    java.util.HexFormat: bytes to hexadecimal text and back, with an optional delimiter between bytes and a prefix and suffix around each.
    IdentityHashMap<K,V>
    IdentityHashMap is a variant on HashMap which tests equality by reference instead of equality by value.
    IntSummaryStatistics
    The count, sum, minimum, maximum and average of the values it was given.
    Iterator<E>
    An Iterator is used to sequence over a collection of objects.
    LinkedHashMap<K,V>
    LinkedHashMap is a variant of HashMap.
    LinkedHashSet<E>
    LinkedHashSet is a variant of HashSet.
    LinkedList<E>
    LinkedList is an implementation of List, backed by a linked list.
    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.
    Locale
    A language, a country and a variant, with the JDK's value semantics: two locales of the same codes are equal, hash alike and print alike (en_US).
    LongSummaryStatistics
    The count, sum, minimum, maximum and average of the values it was given.
    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.
    MissingResourceException
    A resource bundle, or a key in one, could not be found.
    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.
    NoSuchElementException
    Thrown by the nextElement method of an Enumeration to indicate that there are no more elements in the enumeration.
    Objects
    This is a compatibility class which supports the java.util.Objects API.
    Observable
    Observable is used to notify a group of Observer objects when a change occurs.
    Observer
    Observer is the interface to be implemented by objects that receive notification of updates on an Observable object.
    Optional<T>
    A container that may or may not hold a non-null value (the Java 8 API).
    OptionalDouble
    A container that holds one double or nothing.
    OptionalInt
    A container that holds one int or nothing.
    OptionalLong
    A container that holds one long or nothing.
    PrimitiveIterator<T,T_CONS>
    An iterator that can hand out its elements unboxed.
    PrimitiveIterator.OfDouble
    An iterator of double values.
    PrimitiveIterator.OfInt
    An iterator of int values.
    PrimitiveIterator.OfLong
    An iterator of long values.
    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
    String keys and values, a second table of defaults behind them, and the .properties text format.
    Queue<E>
    This kind of collection provides advanced operations compared to basic collections, such as insertion, extraction, and inspection.
    Random
    An instance of this class is used to generate a stream of pseudorandom numbers.
    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.
    Spliterator<T>
    A source of elements that hands them out one at a time, which is what java.util.stream.StreamSupport makes a stream of.
    Spliterators
    Ways to make a Spliterator of a collection or an iterator, and an iterator of a spliterator.
    Stack<E>
    Stack is a Last-In/First-Out(LIFO) data structure which represents a stack of objects.
    StringJoiner
    java.util.StringJoiner: builds a sequence of strings separated by a delimiter, optionally between a prefix and a suffix.
    StringTokenizer
    The StringTokenizer class allows an application to break a string into tokens by performing code point comparison.
    Timer
     
    TimerTask
     
    TimeZone
    TimeZone represents a time zone offset, and also figures out daylight savings.
    TreeMap<K,V>
    TreeMap is an implementation of SortedMap.
    TreeSet<E>
    TreeSet is an implementation of SortedSet.
    UUID
    A 128 bit identifier: its canonical text form, random (version 4) generation and name based (version 3) generation.
    Vector<E>
    Vector is a variable size contiguous indexable array of objects.
    WeakHashMap<K,V>
    java.util.WeakHashMap: a map that does not keep its keys alive.