#Java.util Classes and Interfaces

_{#Java.util Classes and Interfaces - 452 results found.}

Name	Description	Type	Package	Framework
AbstractCollection	This class provides a skeletal implementation of the Collection interface, to minimize the effort required to implement this interface.	Class	java.util	Java SE
AbstractExecutorService	Provides default implementations of ExecutorService execution methods.	Class	java.util.concurrent	Java SE
AbstractList	This class provides a skeletal implementation of the List interface to minimize the effort required to implement this interface	Class	java.util	Java SE
AbstractMap	This class provides a skeletal implementation of the Map interface, to minimize the effort required to implement this interface.	Class	java.util	Java SE
AbstractMap .SimpleEntry	An Entry maintaining a key and a value.	Class	java.util.AbstractMap	Java SE
AbstractMap .SimpleImmutableEntry	An Entry maintaining an immutable key and value.	Class	java.util.AbstractMap	Java SE
AbstractOwnableSynchronizer	A synchronizer that may be exclusively owned by a thread.	Class	java.util.concurrent.locks	Java SE
AbstractPreferences	This class provides a skeletal implementation of the Preferences class, greatly easing the task of implementing it.	Class	java.util.prefs	Java SE
AbstractQueue	This class provides skeletal implementations of some Queue operations.	Class	java.util	Java SE
AbstractQueuedLongSynchronizer	A version of AbstractQueuedSynchronizer in which synchronization state is maintained as a long.	Class	java.util.concurrent.locks	Java SE
AbstractQueuedSynchronizer	Provides a framework for implementing blocking locks and related synchronizers (semaphores, events, etc) that rely on	Class	java.util.concurrent.locks	Java SE
AbstractSequentialList	This class provides a skeletal implementation of the List interface to minimize the effort required to implement this interface	Class	java.util	Java SE
AbstractSet	This class provides a skeletal implementation of the Set interface to minimize the effort required to implement this	Class	java.util	Java SE
Adler32	A class that can be used to compute the Adler-32 checksum of a data stream.	Class	java.util.zip	Java SE
ArrayBlockingQueue	A bounded blocking queue backed by an array.	Class	java.util.concurrent	Java SE
ArrayDeque	Resizable-array implementation of the Deque interface.	Class	java.util	Java SE
ArrayList	Resizable-array implementation of the List interface.	Class	java.util	Java SE
Arrays	This class contains various methods for manipulating arrays (such as sorting and searching).	Class	java.util	Java SE
AtomicBoolean	A boolean value that may be updated atomically.	Class	java.util.concurrent.atomic	Java SE
AtomicInteger	An int value that may be updated atomically.	Class	java.util.concurrent.atomic	Java SE
AtomicIntegerArray	An int array in which elements may be updated atomically.	Class	java.util.concurrent.atomic	Java SE
AtomicIntegerFieldUpdater	A reflection-based utility that enables atomic updates to designated volatile int fields of designated classes.	Class	java.util.concurrent.atomic	Java SE
AtomicLong	A long value that may be updated atomically.	Class	java.util.concurrent.atomic	Java SE
AtomicLongArray	A long array in which elements may be updated atomically.	Class	java.util.concurrent.atomic	Java SE
AtomicLongFieldUpdater	A reflection-based utility that enables atomic updates to designated volatile long fields of designated classes.	Class	java.util.concurrent.atomic	Java SE
AtomicMarkableReference	An AtomicMarkableReference maintains an object reference along with a mark bit, that can be updated atomically.	Class	java.util.concurrent.atomic	Java SE
AtomicReference	An object reference that may be updated atomically.	Class	java.util.concurrent.atomic	Java SE
AtomicReferenceArray	An array of object references in which elements may be updated atomically.	Class	java.util.concurrent.atomic	Java SE
AtomicReferenceFieldUpdater	A reflection-based utility that enables atomic updates to designated volatile reference fields of designated	Class	java.util.concurrent.atomic	Java SE
AtomicStampedReference	An AtomicStampedReference maintains an object reference along with an integer stamp, that can be updated atomically.	Class	java.util.concurrent.atomic	Java SE
Attributes	The Attributes class maps Manifest attribute names to associated string values.	Class	java.util.jar	Java SE
Attributes .Name	The Attributes.	Class	java.util.jar.Attributes	Java SE
BackingStoreException	Thrown to indicate that a preferences operation could not complete because of a failure in the backing store, or a failure to contact the backing	Class	java.util.prefs	Java SE
Base64	This class consists exclusively of static methods for obtaining encoders and decoders for the Base64 encoding scheme.	Class	java.util	Java SE
Base64 .Decoder	This class implements a decoder for decoding byte data using the Base64 encoding scheme as specified in RFC 4648 and RFC 2045.	Class	java.util.Base64	Java SE
Base64 .Encoder	This class implements an encoder for encoding byte data using the Base64 encoding scheme as specified in RFC 4648 and RFC 2045.	Class	java.util.Base64	Java SE
BitSet	This class implements a vector of bits that grows as needed.	Class	java.util	Java SE
BrokenBarrierException	Exception thrown when a thread tries to wait upon a barrier that is in a broken state, or which enters the broken state while the thread	Class	java.util.concurrent	Java SE
BaseStream	Base interface for streams, which are sequences of elements supporting sequential and parallel aggregate operations.	Interface	java.util.stream	Java SE
BiConsumer	Represents an operation that accepts two input arguments and returns no result.	Interface	java.util.function	Java SE
BiFunction	Represents a function that accepts two arguments and produces a result.	Interface	java.util.function	Java SE
BinaryOperator	Represents an operation upon two operands of the same type, producing a result of the same type as the operands.	Interface	java.util.function	Java SE
BiPredicate	Represents a predicate (boolean-valued function) of two arguments.	Interface	java.util.function	Java SE
BlockingDeque	A Deque that additionally supports blocking operations that wait for the deque to become non-empty when retrieving an element, and wait for	Interface	java.util.concurrent	Java SE
BlockingQueue	A Queue that additionally supports operations that wait for the queue to become non-empty when retrieving an	Interface	java.util.concurrent	Java SE
BooleanSupplier	Represents a supplier of boolean-valued results.	Interface	java.util.function	Java SE
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,	Class	java.util	Java SE
Calendar .Builder	Calendar.	Class	java.util.Calendar	Java SE
CalendarDataProvider	An abstract class for service providers that provide locale-dependent Calendar parameters.	Class	java.util.spi	Java SE
CalendarNameProvider	An abstract class for service providers that provide localized string representations (display names) of Calendar field values.	Class	java.util.spi	Java SE
CancellationException	Exception indicating that the result of a value-producing task, such as a FutureTask, cannot be retrieved because the task	Class	java.util.concurrent	Java SE
CheckedInputStream	An input stream that also maintains a checksum of the data being read.	Class	java.util.zip	Java SE
CheckedOutputStream	An output stream that also maintains a checksum of the data being written.	Class	java.util.zip	Java SE
Collections	This class consists exclusively of static methods that operate on or return collections.	Class	java.util	Java SE
Collectors	operations, such as accumulating elements into collections, summarizing elements according to various criteria, etc.	Class	java.util.stream	Java SE
CompletableFuture	A Future that may be explicitly completed (setting its value and status), and may be used as a CompletionStage,	Class	java.util.concurrent	Java SE
CompletionException	Exception thrown when an error or other exception is encountered in the course of completing a result or task.	Class	java.util.concurrent	Java SE
ConcurrentHashMap	A hash table supporting full concurrency of retrievals and high expected concurrency for updates.	Class	java.util.concurrent	Java SE
ConcurrentHashMap .KeySetView	A view of a ConcurrentHashMap as a Set of keys, in which additions may optionally be enabled by mapping to a	Class	java.util.concurrent.ConcurrentHashMap	Java SE
ConcurrentLinkedDeque	An unbounded concurrent deque based on linked nodes.	Class	java.util.concurrent	Java SE
ConcurrentLinkedQueue	An unbounded thread-safe queue based on linked nodes.	Class	java.util.concurrent	Java SE
ConcurrentModificationException	This exception may be thrown by methods that have detected concurrent modification of an object when such modification is not permissible.	Class	java.util	Java SE
ConcurrentSkipListMap	A scalable concurrent ConcurrentNavigableMap implementation.	Class	java.util.concurrent	Java SE
ConcurrentSkipListSet	A scalable concurrent NavigableSet implementation based on a ConcurrentSkipListMap.	Class	java.util.concurrent	Java SE
ConsoleHandler	This Handler publishes log records to System.	Class	java.util.logging	Java SE
CopyOnWriteArrayList	A thread-safe variant of ArrayList in which all mutative operations (add, set, and so on) are implemented by	Class	java.util.concurrent	Java SE
CopyOnWriteArraySet	A Set that uses an internal CopyOnWriteArrayList for all of its operations.	Class	java.util.concurrent	Java SE
CountDownLatch	A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.	Class	java.util.concurrent	Java SE
CountedCompleter	A ForkJoinTask with a completion action performed when triggered and there are no remaining pending actions.	Class	java.util.concurrent	Java SE
CRC32	A class that can be used to compute the CRC-32 of a data stream.	Class	java.util.zip	Java SE
CRC32C	A class that can be used to compute the CRC-32C of a data stream.	Class	java.util.zip	Java SE
Currency	Represents a currency.	Class	java.util	Java SE
CurrencyNameProvider	An abstract class for service providers that provide localized currency symbols and display names for the	Class	java.util.spi	Java SE
CyclicBarrier	A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.	Class	java.util.concurrent	Java SE
Collector .Characteristics	Characteristics indicating properties of a Collector, which can be used to optimize reduction implementations.	Class	java.util.stream.Collector	Java SE
Callable	A task that returns a result and may throw an exception.	Interface	java.util.concurrent	Java SE
Checksum	An interface representing a data checksum.	Interface	java.util.zip	Java SE
Collection	The root interface in the collection hierarchy.	Interface	java.util	Java SE
Collector		Interface	java.util.stream	Java SE
Comparator	A comparison function, which imposes a total ordering on some collection of objects.	Interface	java.util	Java SE
CompletableFuture .AsynchronousCompletionTask	A marker interface identifying asynchronous tasks produced by async methods.	Interface	java.util.concurrent.CompletableFuture	Java SE
CompletionService	A service that decouples the production of new asynchronous tasks from the consumption of the results of completed tasks.	Interface	java.util.concurrent	Java SE
CompletionStage	A stage of a possibly asynchronous computation, that performs an action or computes a value when another CompletionStage completes.	Interface	java.util.concurrent	Java SE
ConcurrentMap	A Map providing thread safety and atomicity To maintain the specified guarantees, default implementations of	Interface	java.util.concurrent	Java SE
ConcurrentNavigableMap	A ConcurrentMap supporting NavigableMap operations, and recursively so for its navigable sub-maps.	Interface	java.util.concurrent	Java SE
Condition	Condition factors out the Object monitor methods (wait, notify	Interface	java.util.concurrent.locks	Java SE
Consumer	Represents an operation that accepts a single input argument and returns no result.	Interface	java.util.function	Java SE
DataFormatException	Signals that a data format error has occurred.	Class	java.util.zip	Java SE
Date	The class Date represents a specific instant in time, with millisecond precision.	Class	java.util	Java SE
Deflater	This class provides support for general purpose compression using the popular ZLIB compression library.	Class	java.util.zip	Java SE
DeflaterInputStream	compression format.	Class	java.util.zip	Java SE
DeflaterOutputStream	This class implements an output stream filter for compressing data in the deflate compression format.	Class	java.util.zip	Java SE
DelayQueue	An unbounded blocking queue of Delayed elements, in which an element can only be taken	Class	java.util.concurrent	Java SE
Dictionary	The Dictionary class is the abstract parent of any class, such as Hashtable, which maps keys to values.	Class	java.util	Java SE
DoubleAccumulator	One or more variables that together maintain a running double value updated using a supplied function.	Class	java.util.concurrent.atomic	Java SE
DoubleAdder	One or more variables that together maintain an initially zero double sum.	Class	java.util.concurrent.atomic	Java SE
DoubleSummaryStatistics	A state object for collecting statistics such as count, min, max, sum, and This class is designed to work with (though does not require)	Class	java.util	Java SE
DuplicateFormatFlagsException	Unchecked exception thrown when duplicate flags are provided in the format Unless otherwise specified, passing a null argument to any	Class	java.util	Java SE
Delayed	A mix-in style interface for marking objects that should be acted upon after a given delay.	Interface	java.util.concurrent	Java SE
Deque	A linear collection that supports element insertion and removal at both ends.	Interface	java.util	Java SE
DoubleBinaryOperator	Represents an operation upon two double-valued operands and producing a double-valued result.	Interface	java.util.function	Java SE
DoubleConsumer	Represents an operation that accepts a single double-valued argument and returns no result.	Interface	java.util.function	Java SE
DoubleFunction	Represents a function that accepts a double-valued argument and produces a result.	Interface	java.util.function	Java SE
DoublePredicate	Represents a predicate (boolean-valued function) of one double-valued argument.	Interface	java.util.function	Java SE
DoubleStream	A sequence of primitive double-valued elements supporting sequential and parallel aggregate operations.	Interface	java.util.stream	Java SE
DoubleStream .Builder	A mutable builder for a DoubleStream.	Interface	java.util.stream.DoubleStream	Java SE
DoubleSupplier	Represents a supplier of double-valued results.	Interface	java.util.function	Java SE
DoubleToIntFunction	Represents a function that accepts a double-valued argument and produces an int-valued result.	Interface	java.util.function	Java SE
DoubleToLongFunction	Represents a function that accepts a double-valued argument and produces a long-valued result.	Interface	java.util.function	Java SE
DoubleUnaryOperator	Represents an operation on a single double-valued operand that produces a double-valued result.	Interface	java.util.function	Java SE
EmptyStackException	Thrown by methods in the Stack class to indicate that the stack is empty.	Class	java.util	Java SE
EnumMap	A specialized Map implementation for use with enum type keys.	Class	java.util	Java SE
EnumSet	A specialized Set implementation for use with enum types.	Class	java.util	Java SE
ErrorManager	ErrorManager objects can be attached to Handlers to process any error that occurs on a Handler during Logging.	Class	java.util.logging	Java SE
EventListenerProxy	An abstract wrapper class for an EventListener class which associates a set of additional parameters with the listener.	Class	java.util	Java SE
EventObject	The root class from which all event state objects shall be derived.	Class	java.util	Java SE
Exchanger	A synchronization point at which threads can pair and swap elements within pairs.	Class	java.util.concurrent	Java SE
ExecutionException	Exception thrown when attempting to retrieve the result of a task that aborted by throwing an exception.	Class	java.util.concurrent	Java SE
ExecutorCompletionService	A CompletionService that uses a supplied Executor to execute tasks.	Class	java.util.concurrent	Java SE
Executors	Factory and utility methods for Executor, ExecutorService, ScheduledExecutorService, ThreadFactory, and Callable classes defined in this package.	Class	java.util.concurrent	Java SE
Enumeration	An object that implements the Enumeration interface generates a series of elements, one at a time.	Interface	java.util	Java SE
EventListener	A tagging interface that all event listener interfaces must extend.	Interface	java.util	Java SE
Executor	An object that executes submitted Runnable tasks.	Interface	java.util.concurrent	Java SE
ExecutorService	An Executor that provides methods to manage termination and methods that can produce a Future for tracking progress of	Interface	java.util.concurrent	Java SE
FileHandler	Simple file logging Handler.	Class	java.util.logging	Java SE
Flow	Interrelated interfaces and static methods for establishing flow-controlled components in which Publishers	Class	java.util.concurrent	Java SE
ForkJoinPool	An ExecutorService for running ForkJoinTasks.	Class	java.util.concurrent	Java SE
ForkJoinTask	Abstract base class for tasks that run within a ForkJoinPool.	Class	java.util.concurrent	Java SE
ForkJoinWorkerThread	A thread managed by a ForkJoinPool, which executes This class is subclassable solely for the sake of adding	Class	java.util.concurrent	Java SE
FormatFlagsConversionMismatchException	Unchecked exception thrown when a conversion and flag are incompatible.	Class	java.util	Java SE
FormattableFlags	FomattableFlags are passed to the Formattable.	Class	java.util	Java SE
Formatter	An interpreter for printf-style format strings.	Class	java.util	Java SE
Formatter	A Formatter provides support for formatting LogRecords.	Class	java.util.logging	Java SE
FormatterClosedException	Unchecked exception thrown when the formatter has been closed.	Class	java.util	Java SE
FutureTask	A cancellable asynchronous computation.	Class	java.util.concurrent	Java SE
Formatter .BigDecimalLayoutForm	Format the BigDecimal as a decimal number.	Class	java.util.Formatter	Java SE
Filter	A Filter can be used to provide fine grain control over what is logged, beyond the control provided by log levels.	Interface	java.util.logging	Java SE
Flow .Processor	A component that acts as both a Subscriber and Publisher.	Interface	java.util.concurrent.Flow	Java SE
Flow .Publisher	A producer of items (and related control messages) received by Subscribers.	Interface	java.util.concurrent.Flow	Java SE
Flow .Subscriber	A receiver of messages.	Interface	java.util.concurrent.Flow	Java SE
Flow .Subscription	Message control linking a Flow.	Interface	java.util.concurrent.Flow	Java SE
ForkJoinPool .ForkJoinWorkerThreadFactory	Factory for creating new ForkJoinWorkerThreads.	Interface	java.util.concurrent.ForkJoinPool	Java SE
ForkJoinPool .ManagedBlocker	A ManagedBlocker provides two methods.	Interface	java.util.concurrent.ForkJoinPool	Java SE
Formattable	The Formattable interface must be implemented by any class that needs to perform custom formatting using the 's' conversion	Interface	java.util	Java SE
Function	Represents a function that accepts one argument and produces a result.	Interface	java.util.function	Java SE
Future	A Future represents the result of an asynchronous computation.	Interface	java.util.concurrent	Java SE
GregorianCalendar	GregorianCalendar is a concrete subclass of Calendar and provides the standard calendar system	Class	java.util	Java SE
GZIPInputStream	This class implements a stream filter for reading compressed data in the GZIP file format.	Class	java.util.zip	Java SE
GZIPOutputStream	This class implements a stream filter for writing compressed data in the GZIP file format.	Class	java.util.zip	Java SE
Handler	A Handler object takes log messages from a Logger and exports them.	Class	java.util.logging	Java SE
HashMap	Hash table based implementation of the Map interface.	Class	java.util	Java SE
HashSet	This class implements the Set interface, backed by a hash table (actually a HashMap instance).	Class	java.util	Java SE
Hashtable	This class implements a hash table, which maps keys to values.	Class	java.util	Java SE
IdentityHashMap	This class implements the Map interface with a hash table, using reference-equality in place of object-equality when comparing keys (and	Class	java.util	Java SE
IllegalFormatCodePointException	Unchecked exception thrown when a character with an invalid Unicode code point as defined by Character.	Class	java.util	Java SE
IllegalFormatConversionException	Unchecked exception thrown when the argument corresponding to the format specifier is of an incompatible type.	Class	java.util	Java SE
IllegalFormatException	Unchecked exception thrown when a format string contains an illegal syntax or a format specifier that is incompatible with the given arguments.	Class	java.util	Java SE
IllegalFormatFlagsException	Unchecked exception thrown when an illegal combination flags is given.	Class	java.util	Java SE
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	Class	java.util	Java SE
IllegalFormatWidthException	Unchecked exception thrown when the format width is a negative value other than -1 or is otherwise unsupported.	Class	java.util	Java SE
IllformedLocaleException	Thrown by methods in Locale and Locale.	Class	java.util	Java SE
Inflater	This class provides support for general purpose decompression using the popular ZLIB compression library.	Class	java.util.zip	Java SE
InflaterInputStream	This class implements a stream filter for uncompressing data in the deflate compression format.	Class	java.util.zip	Java SE
InflaterOutputStream	deflate compression format.	Class	java.util.zip	Java SE
InputMismatchException	Thrown by a Scanner to indicate that the token retrieved does not match the pattern for the expected type, or	Class	java.util	Java SE
IntSummaryStatistics	A state object for collecting statistics such as count, min, max, sum, and This class is designed to work with (though does not require)	Class	java.util	Java SE
InvalidPreferencesFormatException	Thrown to indicate that an operation could not complete because the input did not conform to the appropriate XML document type	Class	java.util.prefs	Java SE
InvalidPropertiesFormatException	Thrown to indicate that an operation could not complete because the input did not conform to the appropriate XML document type	Class	java.util	Java SE
IntBinaryOperator	Represents an operation upon two int-valued operands and producing an int-valued result.	Interface	java.util.function	Java SE
IntConsumer	Represents an operation that accepts a single int-valued argument and returns no result.	Interface	java.util.function	Java SE
IntFunction	Represents a function that accepts an int-valued argument and produces a result.	Interface	java.util.function	Java SE
IntPredicate	Represents a predicate (boolean-valued function) of one int-valued argument.	Interface	java.util.function	Java SE
IntStream	A sequence of primitive int-valued elements supporting sequential and parallel aggregate operations.	Interface	java.util.stream	Java SE
IntStream .Builder	A mutable builder for an IntStream.	Interface	java.util.stream.IntStream	Java SE
IntSupplier	Represents a supplier of int-valued results.	Interface	java.util.function	Java SE
IntToDoubleFunction	Represents a function that accepts an int-valued argument and produces a double-valued result.	Interface	java.util.function	Java SE
IntToLongFunction	Represents a function that accepts an int-valued argument and produces a long-valued result.	Interface	java.util.function	Java SE
IntUnaryOperator	Represents an operation on a single int-valued operand that produces an int-valued result.	Interface	java.util.function	Java SE
Iterator	An iterator over a collection.	Interface	java.util	Java SE
JarEntry	This class is used to represent a JAR file entry.	Class	java.util.jar	Java SE
JarException	Signals that an error of some sort has occurred while reading from or writing to a JAR file.	Class	java.util.jar	Java SE
JarFile	The JarFile class is used to read the contents of a jar file from any file that can be opened with java.	Class	java.util.jar	Java SE
JarInputStream	The JarInputStream class is used to read the contents of a JAR file from any input stream.	Class	java.util.jar	Java SE
JarOutputStream	The JarOutputStream class is used to write the contents of a JAR file to any output stream.	Class	java.util.jar	Java SE
Level	The Level class defines a set of standard logging levels that can be used to control logging output.	Class	java.util.logging	Java SE
LinkedBlockingDeque	An optionally-bounded blocking deque based on The optional capacity bound constructor argument serves as a	Class	java.util.concurrent	Java SE
LinkedBlockingQueue	An optionally-bounded blocking queue based on This queue orders elements FIFO (first-in-first-out).	Class	java.util.concurrent	Java SE
LinkedHashMap	Hash table and linked list implementation of the Map interface, with predictable iteration order.	Class	java.util	Java SE
LinkedHashSet	Hash table and linked list implementation of the Set interface, with predictable iteration order.	Class	java.util	Java SE
LinkedList	Doubly-linked list implementation of the List and Deque interfaces.	Class	java.util	Java SE
LinkedTransferQueue	An unbounded TransferQueue based on linked nodes.	Class	java.util.concurrent	Java SE
ListResourceBundle	ListResourceBundle is an abstract subclass of ResourceBundle that manages resources for a locale	Class	java.util	Java SE
Locale	A Locale object represents a specific geographical, political, or cultural region.	Class	java.util	Java SE
Locale .Builder	Builder is used to build instances of Locale from values configured by the setters.	Class	java.util.Locale	Java SE
Locale .LanguageRange	This class expresses a Language Range defined in RFC 4647 Matching of	Class	java.util.Locale	Java SE
LocaleNameProvider	An abstract class for service providers that provide localized names for the	Class	java.util.spi	Java SE
LocaleServiceProvider	This is the super class of all the locale sensitive service provider Locale sensitive service provider interfaces are interfaces that	Class	java.util.spi	Java SE
LockSupport	Basic thread blocking primitives for creating locks and other synchronization classes.	Class	java.util.concurrent.locks	Java SE
Logger	A Logger object is used to log messages for a specific system or application component.	Class	java.util.logging	Java SE
LoggingPermission	The permission which the SecurityManager will check when code that is running with a SecurityManager calls one of the logging	Class	java.util.logging	Java SE
LogManager	There is a single global LogManager object that is used to maintain a set of shared state about Loggers and log services.	Class	java.util.logging	Java SE
LogRecord	LogRecord objects are used to pass logging requests between the logging framework and individual log Handlers.	Class	java.util.logging	Java SE
LongAccumulator	One or more variables that together maintain a running long value updated using a supplied function.	Class	java.util.concurrent.atomic	Java SE
LongAdder	One or more variables that together maintain an initially zero long sum.	Class	java.util.concurrent.atomic	Java SE
LongSummaryStatistics	A state object for collecting statistics such as count, min, max, sum, and This class is designed to work with (though does not require)	Class	java.util	Java SE
Locale .Category	the default locale for the specific functionality represented by theSince:1.	Class	java.util.Locale	Java SE
Locale .FilteringMode	This enum provides constants to select a filtering mode for locale matching.	Class	java.util.Locale	Java SE
List	An ordered collection (also known as a sequence).	Interface	java.util	Java SE
ListIterator	An iterator for lists that allows the programmer to traverse the list in either direction, modify	Interface	java.util	Java SE
Lock	Lock implementations provide more extensive locking operations than can be obtained using synchronized methods	Interface	java.util.concurrent.locks	Java SE
LoggingMXBean	The management interface for the logging facility.	Interface	java.util.logging	Java SE
LongBinaryOperator	Represents an operation upon two long-valued operands and producing a long-valued result.	Interface	java.util.function	Java SE
LongConsumer	Represents an operation that accepts a single long-valued argument and returns no result.	Interface	java.util.function	Java SE
LongFunction	Represents a function that accepts a long-valued argument and produces a result.	Interface	java.util.function	Java SE
LongPredicate	Represents a predicate (boolean-valued function) of one long-valued argument.	Interface	java.util.function	Java SE
LongStream	A sequence of primitive long-valued elements supporting sequential and parallel aggregate operations.	Interface	java.util.stream	Java SE
LongStream .Builder	A mutable builder for a LongStream.	Interface	java.util.stream.LongStream	Java SE
LongSupplier	Represents a supplier of long-valued results.	Interface	java.util.function	Java SE
LongToDoubleFunction	Represents a function that accepts a long-valued argument and produces a double-valued result.	Interface	java.util.function	Java SE
LongToIntFunction	Represents a function that accepts a long-valued argument and produces an int-valued result.	Interface	java.util.function	Java SE
LongUnaryOperator	Represents an operation on a single long-valued operand that produces a long-valued result.	Interface	java.util.function	Java SE
Manifest	The Manifest class is used to maintain Manifest entry names and their associated Attributes.	Class	java.util.jar	Java SE
Matcher	An engine that performs match operations on a character sequence by interpreting a Pattern.	Class	java.util.regex	Java SE
MemoryHandler	Handler that buffers requests in a circular buffer in memory.	Class	java.util.logging	Java SE
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	Class	java.util	Java SE
MissingFormatWidthException	Unchecked exception thrown when the format width is required.	Class	java.util	Java SE
MissingResourceException	Signals that a resource is missing.	Class	java.util	Java SE
Map	An object that maps keys to values.	Interface	java.util	Java SE
Map .Entry	A map entry (key-value pair).	Interface	java.util.Map	Java SE
MatchResult	The result of a match operation.	Interface	java.util.regex	Java SE
NodeChangeEvent	An event emitted by a Preferences node to indicate that a child of that node has been added or removed.	Class	java.util.prefs	Java SE
NoSuchElementException	Thrown by various accessor methods to indicate that the element being requestedSince:1.	Class	java.util	Java SE
NavigableMap	A SortedMap extended with navigation methods returning the closest matches for given search targets.	Interface	java.util	Java SE
NavigableSet	A SortedSet extended with navigation methods reporting closest matches for given search targets.	Interface	java.util	Java SE
NodeChangeListener	A listener for receiving preference node change events.	Interface	java.util.prefs	Java SE
Objects	This class consists of static utility methods for operating on objects, or checking certain conditions before operation.	Class	java.util	Java SE
Observable	This class represents an observable object, or data in the model-view paradigm.	Class	java.util	Java SE
Optional	A container object which may or may not contain a non-null value.	Class	java.util	Java SE
OptionalDouble	A container object which may or may not contain a double value.	Class	java.util	Java SE
OptionalInt	A container object which may or may not contain an int value.	Class	java.util	Java SE
OptionalLong	A container object which may or may not contain a long value.	Class	java.util	Java SE
ObjDoubleConsumer	Represents an operation that accepts an object-valued and a double-valued argument, and returns no result.	Interface	java.util.function	Java SE
ObjIntConsumer	Represents an operation that accepts an object-valued and a int-valued argument, and returns no result.	Interface	java.util.function	Java SE
ObjLongConsumer	Represents an operation that accepts an object-valued and a long-valued argument, and returns no result.	Interface	java.util.function	Java SE
Observer	A class can implement the Observer interface when it wants to be informed of changes in observable objects.	Interface	java.util	Java SE
Pack200	Transforms a JAR file to or from a packed stream in Pack200 format.	Class	java.util.jar	Java SE
Pattern	A compiled representation of a regular expression.	Class	java.util.regex	Java SE
PatternSyntaxException	Unchecked exception thrown to indicate a syntax error in a regular-expression pattern.	Class	java.util.regex	Java SE
Phaser	A reusable synchronization barrier, similar in functionality to but supporting more flexible usage.	Class	java.util.concurrent	Java SE
PreferenceChangeEvent	An event emitted by a Preferences node to indicate that a preference has been added, removed or has had its value changed.	Class	java.util.prefs	Java SE
Preferences	A node in a hierarchical collection of preference data.	Class	java.util.prefs	Java SE
PriorityBlockingQueue	An unbounded blocking queue that uses the same ordering rules as class PriorityQueue and supplies	Class	java.util.concurrent	Java SE
PriorityQueue	An unbounded priority queue based on a priority heap.	Class	java.util	Java SE
Properties	The Properties class represents a persistent set of properties.	Class	java.util	Java SE
PropertyPermission	This class is for property permissions.	Class	java.util	Java SE
PropertyResourceBundle	PropertyResourceBundle is a concrete subclass of ResourceBundle that manages resources for a locale	Class	java.util	Java SE
Pack200 .Packer	The packer engine applies various transformations to the input JAR file, making the pack stream highly compressible by a compressor such as	Interface	java.util.jar.Pack200	Java SE
Pack200 .Unpacker	The unpacker engine converts the packed stream to a JAR file.	Interface	java.util.jar.Pack200	Java SE
Predicate	Represents a predicate (boolean-valued function) of one argument.	Interface	java.util.function	Java SE
PreferenceChangeListener	A listener for receiving preference change events.	Interface	java.util.prefs	Java SE
PreferencesFactory	A factory object that generates Preferences objects.	Interface	java.util.prefs	Java SE
PrimitiveIterator	A base type for primitive specializations of Iterator.	Interface	java.util	Java SE
PrimitiveIterator .OfDouble	An Iterator specialized for double values.	Interface	java.util.PrimitiveIterator	Java SE
PrimitiveIterator .OfInt	An Iterator specialized for int values.	Interface	java.util.PrimitiveIterator	Java SE
PrimitiveIterator .OfLong	An Iterator specialized for long values.	Interface	java.util.PrimitiveIterator	Java SE
Queue	A collection designed for holding elements prior to processing.	Interface	java.util	Java SE
Random	An instance of this class is used to generate a stream of pseudorandom numbers.	Class	java.util	Java SE
RecursiveAction	A recursive resultless ForkJoinTask.	Class	java.util.concurrent	Java SE
RecursiveTask	A recursive result-bearing ForkJoinTask.	Class	java.util.concurrent	Java SE
ReentrantLock	A reentrant mutual exclusion Lock with the same basic behavior and semantics as the implicit monitor lock accessed using	Class	java.util.concurrent.locks	Java SE
ReentrantReadWriteLock	An implementation of ReadWriteLock supporting similar semantics to ReentrantLock.	Class	java.util.concurrent.locks	Java SE
ReentrantReadWriteLock .ReadLock	The lock returned by method ReentrantReadWriteLock.	Class	java.util.concurrent.locks.ReentrantReadWriteLock	Java SE
ReentrantReadWriteLock .WriteLock	The lock returned by method ReentrantReadWriteLock.	Class	java.util.concurrent.locks.ReentrantReadWriteLock	Java SE
RejectedExecutionException	Exception thrown by an Executor when a task cannot be accepted for execution.	Class	java.util.concurrent	Java SE
ResourceBundle	Resource bundles contain locale-specific objects.	Class	java.util	Java SE
ResourceBundle .Control	ResourceBundle.	Class	java.util.ResourceBundle	Java SE
RandomAccess	Marker interface used by List implementations to indicate that they support fast (generally constant time) random access.	Interface	java.util	Java SE
ReadWriteLock	A ReadWriteLock maintains a pair of associated locks, one for read-only operations and one for writing.	Interface	java.util.concurrent.locks	Java SE
RejectedExecutionHandler	A handler for tasks that cannot be executed by a ThreadPoolExecutor.	Interface	java.util.concurrent	Java SE
ResourceBundleControlProvider	An interface for service providers that provide implementations of ResourceBundle.	Interface	java.util.spi	Java SE
RunnableFuture	A Future that is Runnable.	Interface	java.util.concurrent	Java SE
RunnableScheduledFuture	A ScheduledFuture that is Runnable.	Interface	java.util.concurrent	Java SE
Scanner	A simple text scanner which can parse primitive types and strings using regular expressions.	Class	java.util	Java SE
ScheduledThreadPoolExecutor	A ThreadPoolExecutor that can additionally schedule commands to run after a given delay, or to execute periodically.	Class	java.util.concurrent	Java SE
Semaphore	A counting semaphore.	Class	java.util.concurrent	Java SE
ServiceConfigurationError	Error thrown when something goes wrong while loading a service provider.	Class	java.util	Java SE
ServiceLoader	A simple service-provider loading facility.	Class	java.util	Java SE
SimpleFormatter	Print a brief summary of the LogRecord in a human readable format.	Class	java.util.logging	Java SE
SimpleTimeZone	SimpleTimeZone is a concrete subclass of TimeZone that represents a time zone for use with a Gregorian calendar.	Class	java.util	Java SE
SocketHandler	Simple network logging Handler.	Class	java.util.logging	Java SE
Spliterators	Static classes and methods for operating on or creating instances of Spliterator and its primitive specializations	Class	java.util	Java SE
Spliterators .AbstractDoubleSpliterator	An abstract Spliterator.	Class	java.util.Spliterators	Java SE
Spliterators .AbstractIntSpliterator	An abstract Spliterator.	Class	java.util.Spliterators	Java SE
Spliterators .AbstractLongSpliterator	An abstract Spliterator.	Class	java.util.Spliterators	Java SE
Spliterators .AbstractSpliterator	An abstract Spliterator that implements trySplit to permit limited parallelism.	Class	java.util.Spliterators	Java SE
SplittableRandom	A generator of uniform pseudorandom values applicable for use in (among other contexts) isolated parallel computations that may	Class	java.util	Java SE
Stack	The Stack class represents a last-in-first-out (LIFO) stack of objects.	Class	java.util	Java SE
StampedLock	A capability-based lock with three modes for controlling read/write access.	Class	java.util.concurrent.locks	Java SE
StreamHandler	Stream based logging Handler.	Class	java.util.logging	Java SE
StreamSupport	Low-level utility methods for creating and manipulating streams.	Class	java.util.stream	Java SE
StringJoiner	StringJoiner is used to construct a sequence of characters separated by a delimiter and optionally starting with a supplied prefix	Class	java.util	Java SE
StringTokenizer	The string tokenizer class allows an application to break a string into tokens.	Class	java.util	Java SE
SubmissionPublisher	A Flow.	Class	java.util.concurrent	Java SE
SynchronousQueue	A blocking queue in which each insert operation must wait for a corresponding remove operation by another	Class	java.util.concurrent	Java SE
ScheduledExecutorService	An ExecutorService that can schedule commands to run after a given delay, or to execute periodically.	Interface	java.util.concurrent	Java SE
ScheduledFuture	A delayed result-bearing action that can be cancelled.	Interface	java.util.concurrent	Java SE
Set	A collection that contains no duplicate elements.	Interface	java.util	Java SE
SortedMap	A Map that further provides a total ordering on its keys.	Interface	java.util	Java SE
SortedSet	A Set that further provides a total ordering on its elements.	Interface	java.util	Java SE
Spliterator	An object for traversing and partitioning elements of a source.	Interface	java.util	Java SE
Spliterator .OfDouble	A Spliterator specialized for double values.	Interface	java.util.Spliterator	Java SE
Spliterator .OfInt	A Spliterator specialized for int values.	Interface	java.util.Spliterator	Java SE
Spliterator .OfLong	A Spliterator specialized for long values.	Interface	java.util.Spliterator	Java SE
Spliterator .OfPrimitive	A Spliterator specialized for primitive values.	Interface	java.util.Spliterator	Java SE
Stream	A sequence of elements supporting sequential and parallel aggregate operations.	Interface	java.util.stream	Java SE
Stream .Builder	A mutable builder for a Stream.	Interface	java.util.stream.Stream	Java SE
Supplier	Represents a supplier of results.	Interface	java.util.function	Java SE
ThreadLocalRandom	A random number generator isolated to the current thread.	Class	java.util.concurrent	Java SE
ThreadPoolExecutor	An ExecutorService that executes each submitted task using one of possibly several pooled threads, normally configured	Class	java.util.concurrent	Java SE
ThreadPoolExecutor .AbortPolicy	A handler for rejected tasks that throws a RejectedExecutionException.	Class	java.util.concurrent.ThreadPoolExecutor	Java SE
ThreadPoolExecutor .CallerRunsPolicy	A handler for rejected tasks that runs the rejected task directly in the calling thread of the execute method,	Class	java.util.concurrent.ThreadPoolExecutor	Java SE
ThreadPoolExecutor .DiscardOldestPolicy	A handler for rejected tasks that discards the oldest unhandled request and then retries execute, unless the executor	Class	java.util.concurrent.ThreadPoolExecutor	Java SE
ThreadPoolExecutor .DiscardPolicy		Class	java.util.concurrent.ThreadPoolExecutor	Java SE
TimeoutException	Exception thrown when a blocking operation times out.	Class	java.util.concurrent	Java SE
Timer	A facility for threads to schedule tasks for future execution in a background thread.	Class	java.util	Java SE
TimerTask	A task that can be scheduled for one-time or repeated execution by a A timer task is not reusable.	Class	java.util	Java SE
TimeZone	TimeZone represents a time zone offset, and also figures out daylight Typically, you get a TimeZone using getDefault	Class	java.util	Java SE
TimeZoneNameProvider	An abstract class for service providers that provide localized time zone names for the	Class	java.util.spi	Java SE
TooManyListenersException	The TooManyListenersException Exception is used as part of the Java Event model to annotate and implement a unicast special case of	Class	java.util	Java SE
TreeMap	A Red-Black tree based NavigableMap implementation.	Class	java.util	Java SE
TreeSet	A NavigableSet implementation based on a TreeMap.	Class	java.util	Java SE
TimeUnit	A TimeUnit represents time durations at a given unit of granularity and provides utility methods to convert across units,	Class	java.util.concurrent	Java SE
ThreadFactory	An object that creates new threads on demand.	Interface	java.util.concurrent	Java SE
ToDoubleBiFunction	Represents a function that accepts two arguments and produces a double-valued result.	Interface	java.util.function	Java SE
ToDoubleFunction	Represents a function that produces a double-valued result.	Interface	java.util.function	Java SE
ToIntBiFunction	Represents a function that accepts two arguments and produces an int-valued result.	Interface	java.util.function	Java SE
ToIntFunction	Represents a function that produces an int-valued result.	Interface	java.util.function	Java SE
ToLongBiFunction	Represents a function that accepts two arguments and produces a long-valued result.	Interface	java.util.function	Java SE
ToLongFunction	Represents a function that produces a long-valued result.	Interface	java.util.function	Java SE
TransferQueue	A BlockingQueue in which producers may wait for consumers to receive elements.	Interface	java.util.concurrent	Java SE
UnknownFormatConversionException	Unchecked exception thrown when an unknown conversion is given.	Class	java.util	Java SE
UnknownFormatFlagsException	Unchecked exception thrown when an unknown flag is given.	Class	java.util	Java SE
UUID	A class that represents an immutable universally unique identifier (UUID).	Class	java.util	Java SE
UnaryOperator	Represents an operation on a single operand that produces a result of the same type as its operand.	Interface	java.util.function	Java SE
Vector	The Vector class implements a growable array of objects.	Class	java.util	Java SE
WeakHashMap	Hash table based implementation of the Map interface, with An entry in a WeakHashMap will automatically be removed when	Class	java.util	Java SE
XMLFormatter	Format a LogRecord into a standard XML format.	Class	java.util.logging	Java SE
ZipEntry	This class is used to represent a ZIP file entry.	Class	java.util.zip	Java SE
ZipError	Signals that an unrecoverable error has occurred.	Class	java.util.zip	Java SE
ZipException	Signals that a Zip exception of some sort has occurred.	Class	java.util.zip	Java SE
ZipFile	This class is used to read entries from a zip file.	Class	java.util.zip	Java SE
ZipInputStream	This class implements an input stream filter for reading files in the ZIP file format.	Class	java.util.zip	Java SE
ZipOutputStream	This class implements an output stream filter for writing files in the ZIP file format.	Class	java.util.zip	Java SE
AdaptiveCoding		Class	sun.java.util.jar.pack	Code Trails
Attribute		Class	sun.java.util.jar.pack	Code Trails
Attribute .FormatException		Class	sun.java.util.jar.pack.Attribute	Code Trails
Attribute .Holder	Base class for any attributed object (Class, Field, Method, Code).	Class	sun.java.util.jar.pack.Attribute	Code Trails
Attribute .Layout	A "class" of attributes, characterized by a context-type, name and format.	Class	sun.java.util.jar.pack.Attribute	Code Trails
Attribute .ValueStream		Class	sun.java.util.jar.pack.Attribute	Code Trails
BandStructure		Class	sun.java.util.jar.pack	Code Trails
BandStructure .ByteCounter	An output stream which counts the number of bytes written.	Class	sun.java.util.jar.pack.BandStructure	Code Trails
ClassReader		Class	sun.java.util.jar.pack	Code Trails
ClassReader .ClassFormatException		Class	sun.java.util.jar.pack.ClassReader	Code Trails
ClassWriter		Class	sun.java.util.jar.pack	Code Trails
Code		Class	sun.java.util.jar.pack	Code Trails
Coding		Class	sun.java.util.jar.pack	Code Trails
CodingChooser		Class	sun.java.util.jar.pack	Code Trails
CodingChooser .Choice		Class	sun.java.util.jar.pack.CodingChooser	Code Trails
CodingChooser .Sizer		Class	sun.java.util.jar.pack.CodingChooser	Code Trails
CodingMethod		Interface	sun.java.util.jar.pack	Code Trails
ConstantPool		Class	sun.java.util.jar.pack	Code Trails
ConstantPool .ClassEntry		Class	sun.java.util.jar.pack.ConstantPool	Code Trails
ConstantPool .DescriptorEntry		Class	sun.java.util.jar.pack.ConstantPool	Code Trails
ConstantPool .Entry	Entries in the constant pool.	Class	sun.java.util.jar.pack.ConstantPool	Code Trails
ConstantPool .Index	An Index is a mapping between CP entries and small integers.	Class	sun.java.util.jar.pack.ConstantPool	Code Trails
ConstantPool .IndexGroup	Coherent group of constant pool indexes.	Class	sun.java.util.jar.pack.ConstantPool	Code Trails
ConstantPool .LiteralEntry		Class	sun.java.util.jar.pack.ConstantPool	Code Trails
ConstantPool .MemberEntry		Class	sun.java.util.jar.pack.ConstantPool	Code Trails
ConstantPool .NumberEntry		Class	sun.java.util.jar.pack.ConstantPool	Code Trails
ConstantPool .SignatureEntry		Class	sun.java.util.jar.pack.ConstantPool	Code Trails
ConstantPool .StringEntry		Class	sun.java.util.jar.pack.ConstantPool	Code Trails
ConstantPool .Utf8Entry		Class	sun.java.util.jar.pack.ConstantPool	Code Trails
Constants		Class	sun.java.util.jar.pack	Code Trails
Calendar	Calendar is an abstract base class for converting between a Date object and a set of integer fields such as	Class	java.util	Java ME
Date	The class Date represents a specific instant in time, with millisecond This class has been subset for the J2ME based on the JDK 1.	Class	java.util	Java ME
EmptyStackException	Thrown by methods in the Stack class to indicate that the stack is empty.	Class	java.util	Java ME
Enumeration	An object that implements the Enumeration interface generates a series of elements, one at a time.	Interface	java.util	Java ME
Hashtable	This class implements a hashtable, which maps keys to values.	Class	java.util	Java ME
NoSuchElementException	Thrown by the nextElement method of an Enumeration to indicate that there are no more	Class	java.util	Java ME
Random	An instance of this class is used to generate a stream of pseudorandom numbers.	Class	java.util	Java ME
Stack	The Stack class represents a last-in-first-out (LIFO) stack of objects.	Class	java.util	Java ME
TimeZone	TimeZone represents a time zone offset, and also figures out daylight savings.	Class	java.util	Java ME
Timer	A facility for threads to schedule tasks for future execution in a background thread.	Class	java.util	Java ME
TimerTask	A task that can be scheduled for one-time or repeated execution by aSince:1.	Class	java.util	Java ME
Vector	The Vector class implements a growable array of objects.	Class	java.util	Java ME
Utils		Class	org.apache.axis.wsdl.toJava	Apache Axis
AbstractCollection	modifiable collection it's necessary to override the add() method that currently throws an UnsupportedOperationException.	Class	java.util	CodeName One
AbstractList	AbstractList is an abstract implementation of the List interface, optimized for a backing store which supports random access.	Class	java.util	CodeName One
AbstractMap	This class is an abstract implementation of the Map interface.	Class	java.util	CodeName One
AbstractMap .SimpleEntry	A key-value mapping.	Class	java.util.AbstractMap	CodeName One
AbstractMap .SimpleImmutableEntry	An immutable key-value mapping.	Class	java.util.AbstractMap	CodeName One
AbstractQueue	AbstractQueue is an abstract class which implements some of the methods in Queue.	Class	java.util	CodeName One
AbstractSequentialList	AbstractSequentialList is an abstract implementation of the List interface.	Class	java.util	CodeName One
AbstractSet	An AbstractSet is an abstract implementation of the Set interface.	Class	java.util	CodeName One
ArrayDeque	An implementation of Deque, backed by an array.	Class	java.util	CodeName One
ArrayList	ArrayList is an implementation of List, backed by an array.	Class	java.util	CodeName One
Arrays	Arrays contains static methods which operate on arrays.	Class	java.util	CodeName One
BitSet	The BitSet class implements a bit field.	Class	java.util	CodeName One
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.	Class	java.util	CodeName One
Collection	Collection is the root of the collection hierarchy.	Interface	java.util	CodeName One
Collections	Collections contains static methods which operate on Collection classes.	Class	java.util	CodeName One
Comparator	A Comparator is used to compare two objects to determine their ordering with respect to each other.	Interface	java.util	CodeName One
ConcurrentModificationException	An ConcurrentModificationException is thrown when a Collection is modified and an existing iterator on the Collection is used to modify the	Class	java.util	CodeName One
Date	The class Date represents a specific instant in time, with millisecond precision.	Class	java.util	CodeName One
Deque	A kind of collection that can insert or remove element at both ends("double ended queue").	Interface	java.util	CodeName One
Dictionary	Note: Do not use this class since it is obsolete.	Class	java.util	CodeName One
EmptyStackException	Thrown by methods in the Stack class to indicate that the stack is empty.	Class	java.util	CodeName One
Enumeration	An object that implements the Enumeration interface generates a series of elements, one at a time.	Interface	java.util	CodeName One
EventListener		Interface	java.util	CodeName One
EventListenerProxy	This abstract class provides a simple wrapper for objects of type EventListener.	Class	java.util	CodeName One
HashMap	HashMap is an implementation of Map.	Class	java.util	CodeName One
HashSet	HashSet is an implementation of a Set.	Class	java.util	CodeName One
Hashtable	Hashtable associates keys with values.	Class	java.util	CodeName One
IdentityHashMap	IdentityHashMap is a variant on HashMap which tests equality by reference instead of equality by value.	Class	java.util	CodeName One
Iterator	An Iterator is used to sequence over a collection of objects.	Interface	java.util	CodeName One
LinkedHashMap	LinkedHashMap is a variant of HashMap.	Class	java.util	CodeName One
LinkedHashSet	LinkedHashSet is a variant of HashSet.	Class	java.util	CodeName One
LinkedList	LinkedList is an implementation of List, backed by a linked list.	Class	java.util	CodeName One
List	A List is a collection which maintains an ordering for its elements.	Interface	java.util	CodeName One
ListIterator	An ListIterator is used to sequence over a List of objects.	Interface	java.util	CodeName One
Map	A Map is a data structure consisting of a set of keys and values in which each key is mapped to a single value.	Interface	java.util	CodeName One
Map .Entry	Map.	Interface	java.util.Map	CodeName One
NavigableMap	NavigableMap is a SortedMap with navigation methods answering the closest matches for specified item.	Interface	java.util	CodeName One
NavigableSet	NavigableSet is a SortedSet with navigation methods answering the closest matches for specified item.	Interface	java.util	CodeName One
NoSuchElementException	Thrown by the nextElement method of an Enumeration to indicate that there are no more elements in the enumeration.	Class	java.util	CodeName One
Observable	Observable is used to notify a group of Observer objects when a change occurs.	Class	java.util	CodeName One
Observer	Observer is the interface to be implemented by objects that receive notification of updates on an Observable object.	Interface	java.util	CodeName One
PriorityQueue	A PriorityQueue holds elements on a priority heap, which orders the elements according to their natural order or according to the comparator specified at	Class	java.util	CodeName One
Queue	This kind of collection provides advanced operations compared to basic collections, such as insertion, extraction, and inspection.	Interface	java.util	CodeName One
Random	An instance of this class is used to generate a stream of pseudorandom numbers.	Class	java.util	CodeName One
RandomAccess		Interface	java.util	CodeName One
Set	A Set is a data structure which does not allow duplicate elements.	Interface	java.util	CodeName One
SortedMap	A map that has its keys ordered.	Interface	java.util	CodeName One
SortedSet	SortedSet is a Set which iterates over its elements in a sorted order.	Interface	java.util	CodeName One
Stack	Stack is a Last-In/First-Out(LIFO) data structure which represents a stack of objects.	Class	java.util	CodeName One
StringTokenizer	The StringTokenizer class allows an application to break a string into tokens by performing code point comparison.	Class	java.util	CodeName One
Timer		Class	java.util	CodeName One
TimerTask		Class	java.util	CodeName One
TimeZone	TimeZone represents a time zone offset, and also figures out daylight savings.	Class	java.util	CodeName One
TreeMap	TreeMap is an implementation of SortedMap.	Class	java.util	CodeName One
TreeSet	TreeSet is an implementation of SortedSet.	Class	java.util	CodeName One
Vector	Vector is a variable size contiguous indexable array of objects.	Class	java.util	CodeName One

Search Java Classes and Packages