This class provides a skeletal implementation of the Collection interface, to minimize the effort required to implement this interface.

Provides default implementations of ExecutorService execution methods.

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

This class provides a skeletal implementation of the Map interface, to minimize the effort required to implement this interface.

An Entry maintaining a key and a value.

An unmodifiable Entry maintaining a key and a value.

Thrown when an application tries to call an abstract method.

This class provides skeletal implementations of some Queue operations.

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

This class provides a skeletal implementation of the Set interface to minimize the effort required to implement this interface.

An abstract implementation of UndoableEdit, implementing simple responses to all boolean methods in that interface.

The common interface extended by all annotation interfaces.

Thrown when the annotation parser attempts to read an annotation from a class file and determines that the annotation is malformed.

Thrown to indicate that a program has attempted to access an element of an annotation whose type has changed after the annotation was compiled (or serialized).

An object to which char sequences and values can be appended.

Thrown when an exceptional arithmetic condition has occurred.

A bounded blocking queue backed by an array.

Resizable-array implementation of the Deque interface.

Thrown to indicate that an array has been accessed with an illegal index.

Resizable-array implementation of the List interface.

This class contains various methods for manipulating arrays (such as sorting and searching).

Thrown to indicate that an attempt has been made to store the wrong type of object into an array of objects.

Thrown to indicate that an assertion has failed.

An object that may hold resources (such as file or socket handles) until it is closed.

This class consists exclusively of static methods for obtaining encoders and decoders for the Base64 encoding scheme.

This class implements a decoder for decoding byte data using the Base64 encoding scheme as specified in RFC 4648 and RFC 2045.

This class implements an encoder for encoding byte data using the Base64 encoding scheme as specified in RFC 4648 and RFC 2045.

This class implements a vector of bits that grows as needed.

A Deque that additionally supports blocking operations that wait for the deque to become non-empty when retrieving an element, and wait for space to become available in the deque when storing an element.

A Queue that additionally supports operations that wait for the queue to become non-empty when retrieving an element, and wait for space to become available in the queue when storing an element.

The Boolean class wraps a value of the primitive type boolean in an object.

Thrown to indicate that an invokedynamic instruction or a dynamic constant failed to resolve its bootstrap method and arguments, or for invokedynamic instruction the bootstrap method has failed to provide a call site with a target of the correct method type, or for a dynamic constant the bootstrap method has failed to provide a constant value of the required type.

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 is waiting.

A BufferedInputStream adds functionality to another input stream-namely, the ability to buffer the input and to support the mark and reset methods.

The class implements a buffered output stream.

Reads text from a character-input stream, buffering characters so as to provide for the efficient reading of characters, arrays, and lines.

Writes text to a character-output stream, buffering characters so as to provide for the efficient writing of single characters, arrays, and strings.

The Byte class wraps a value of primitive type byte in an object.

A ByteArrayInputStream contains an internal buffer that contains bytes that may be read from the stream.

This class implements an output stream in which the data is written into a byte array.

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 is used for creating a Calendar from various date-time parameters.

A task that returns a result and may throw an exception.

Exception indicating that the result of a value-producing task, such as a FutureTask, cannot be retrieved because the task was cancelled.

Thrown when an UndoableEdit is told to redo() and can't.

Thrown when an UndoableEdit is told to undo() and can't.

The Catalog class represents an entity Catalog as defined by XML Catalogs, OASIS Standard V1.1, 7 October 2005.

The exception class handles errors that may happen while processing or using a catalog.

The CatalogFeatures holds a collection of features and properties.

The Builder class for building the CatalogFeatures object.

A Feature type as defined in the Catalog Features table.

The Catalog Manager manages the creation of XML Catalogs and Catalog Resolvers.

A Catalog Resolver that implements SAX EntityResolver, StAX XMLResolver, DOM LS LSResourceResolver used by Schema Validation, and Transform URIResolver, and resolves external references using catalogs.

The Character class wraps a value of the primitive type char in an object.

Instances of this class represent particular subsets of the Unicode character set.

A family of character subsets representing the character blocks in the Unicode specification.

A family of character subsets representing the character scripts defined in the Unicode Standard Annex #24: Script Names.

This class implements a character buffer that can be used as a character-input stream.

This class implements a character buffer that can be used as an Writer.

Base class for character conversion exceptions.

A CharSequence is a readable sequence of char values.

Instances of the class Class represent classes and interfaces in a running Java application.

Thrown to indicate that the code has attempted to cast an object to a subclass of which it is not an instance.

Thrown when the Java Virtual Machine detects a circularity in the superclass hierarchy of a class being loaded.

Thrown when the Java Virtual Machine attempts to read a class file and determines that the file is malformed or otherwise cannot be interpreted as a class file.

A class loader is an object that is responsible for loading classes.

Thrown when an application tries to load in a class through its string name using: The forName method in class Class.

Lazily associate a computed value with (potentially) every type.

A class implements the Cloneable interface to indicate to the Object.clone() method that it is legal for that method to make a field-for-field copy of instances of that class.

Thrown to indicate that the clone method in class Object has been called to clone an object, but that the object's class does not implement the Cloneable interface.

A Closeable is a source or destination of data that can be closed.

The root interface in the collection hierarchy.

This class consists exclusively of static methods that operate on or return collections.

This interface imposes a total ordering on the objects of each class that implements it.

A comparison function, which imposes a total ordering on some collection of objects.

Deprecated, for removal. JIT compilers and their technologies vary too widely to be controlled effectively by a standardized interface.

A Future that may be explicitly completed (setting its value and status), and may be used as a CompletionStage, supporting dependent functions and actions that trigger upon its completion.

A marker interface identifying asynchronous tasks produced by async methods.

Exception thrown when an error or other exception is encountered in the course of completing a result or task.

A service that decouples the production of new asynchronous tasks from the consumption of the results of completed tasks.

A stage of a possibly asynchronous computation, that performs an action or computes a value when another CompletionStage completes.

A concrete subclass of AbstractUndoableEdit, used to assemble little UndoableEdits into great big ones.

A hash table supporting full concurrency of retrievals and high expected concurrency for updates.

A view of a ConcurrentHashMap as a Set of keys, in which additions may optionally be enabled by mapping to a common value.

An unbounded concurrent deque based on linked nodes.

An unbounded thread-safe queue based on linked nodes.

A Map providing thread safety and atomicity guarantees.

This exception may be thrown by methods that have detected concurrent modification of an object when such modification is not permissible.

A ConcurrentMap supporting NavigableMap operations, and recursively so for its navigable sub-maps.

A scalable concurrent ConcurrentNavigableMap implementation.

A scalable concurrent NavigableSet implementation based on a ConcurrentSkipListMap.

Methods to access the character-based console device, if any, associated with the current Java virtual machine.

A thread-safe variant of ArrayList in which all mutative operations (add, set, and so on) are implemented by making a fresh copy of the underlying array.

A Set that uses an internal CopyOnWriteArrayList for all of its operations.

A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.

A ForkJoinTask with a completion action performed when triggered and there are no remaining pending actions.

Represents a currency.

A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.

The DataInput interface provides for reading bytes from a binary stream and reconstructing from them data in any of the Java primitive types.

A data input stream lets an application read primitive Java data types from an underlying input stream in a machine-independent way.

The DataOutput interface provides for converting data from any of the Java primitive types to a series of bytes and writing these bytes to a binary stream.

A data output stream lets an application write primitive Java data types to an output stream in a portable way.

The class Date represents a specific instant in time, with millisecond precision.

A mix-in style interface for marking objects that should be acted upon after a given delay.

An unbounded blocking queue of Delayed elements, in which an element can only be taken when its delay has expired.

A program element annotated @Deprecated is one that programmers are discouraged from using.

A linear collection that supports element insertion and removal at both ends.

The Dictionary class is the abstract parent of any class, such as Hashtable, which maps keys to values.

The user doclet must implement this interface, as described in the package description.

An encapsulation of option name, aliases, parameters and descriptions as used by the Doclet.

The kind of an option.

Represents the operating environment of a single invocation of the doclet.

The mode specifying the level of detail of module documentation.

The Document is a container for text that serves as the model for swing text components.

If the annotation @Documented is present on the declaration of an annotation interface A, then any @A annotation on an element is considered part of the element's public contract.

The Double class wraps a value of the primitive type double in an object.

A state object for collecting statistics such as count, min, max, sum, and average.

Unchecked exception thrown when duplicate flags are provided in the format specifier.

The constants of this enumerated class provide a simple classification of the syntactic locations where annotations may appear in a Java program.

Thrown by methods in the Stack class to indicate that the stack is empty.

This is the common base class of all Java language enumeration classes.

A nominal descriptor for an enum constant.

Thrown when an application tries to access an enum constant by name and the enum type contains no constant with the specified name.

An object that implements the Enumeration interface generates a series of elements, one at a time.

A specialized Map implementation for use with enum type keys.

A specialized Set implementation for use with enum types.

Signals that an end of file or end of stream has been reached unexpectedly during input.

An Error is a subclass of Throwable that indicates serious problems that a reasonable application should not try to catch.

A tagging interface that all event listener interfaces must extend.

An abstract wrapper class for an EventListener class which associates a set of additional parameters with the listener.

The root class from which all event state objects shall be derived.

The class Exception and its subclasses are a form of Throwable that indicates conditions that a reasonable application might want to catch.

Signals that an unexpected exception has occurred in a static initializer.

A synchronization point at which threads can pair and swap elements within pairs.

Exception thrown when attempting to retrieve the result of a task that aborted by throwing an exception.

An object that executes submitted Runnable tasks.

A CompletionService that uses a supplied Executor to execute tasks.

Factory and utility methods for Executor, ExecutorService, ScheduledExecutorService, ThreadFactory, and Callable classes defined in this package.

An Executor that provides methods to manage termination and methods that can produce a Future for tracking progress of one or more asynchronous tasks.

Only the identity of the class of an Externalizable instance is written in the serialization stream and it is the responsibility of the class to save and restore the contents of its instances.

An abstract representation of file and directory pathnames.

Instances of the file descriptor class serve as an opaque handle to the underlying machine-specific structure representing an open file, an open socket, or another source or sink of bytes.

A filter for abstract pathnames.

A FileInputStream obtains input bytes from a file in a file system.

Instances of classes that implement this interface are used to filter filenames.

Signals that an attempt to open the file denoted by a specified pathname has failed.

A file output stream is an output stream for writing data to a File or to a FileDescriptor.

This class represents access to a file or directory.

Reads text from character files using a default buffer size.

Writes text to character files using a default buffer size.

A FilterInputStream contains some other input stream, which it uses as its basic source of data, possibly transforming the data along the way or providing additional functionality.

This class is the superclass of all classes that filter output streams.

Abstract class for reading filtered character streams.

Abstract class for writing filtered character streams.

The Float class wraps a value of primitive type float in an object.

Interrelated interfaces and static methods for establishing flow-controlled components in which Publishers produce items consumed by one or more Subscribers, each managed by a Subscription.

A component that acts as both a Subscriber and Publisher.

A producer of items (and related control messages) received by Subscribers.

A receiver of messages.

Message control linking a Flow.Publisher and Flow.Subscriber.

A Flushable is a destination of data that can be flushed.

An ExecutorService for running ForkJoinTasks.

Factory for creating new ForkJoinWorkerThreads.

Interface for extending managed parallelism for tasks running in ForkJoinPools.

Abstract base class for tasks that run within a ForkJoinPool.

A thread managed by a ForkJoinPool, which executes ForkJoinTasks.

Unchecked exception thrown when a conversion and flag are incompatible.

The Formattable interface must be implemented by any class that needs to perform custom formatting using the 's' conversion specifier of Formatter.

FormattableFlags are passed to the Formattable.formatTo() method and modify the output format for Formattables.

An interpreter for printf-style format strings.

Enum for BigDecimal formatting.

Unchecked exception thrown when the formatter has been closed.

An informative annotation type used to indicate that an interface type declaration is intended to be a functional interface as defined by the Java Language Specification.

A Future represents the result of an asynchronous computation.

A cancellable asynchronous computation.

GregorianCalendar is a concrete subclass of Calendar and provides the standard calendar system used by most of the world.

GroupLayout is a LayoutManager that hierarchically groups components in order to position them in a Container.

Enumeration of the possible ways ParallelGroup can align its children.

Hash table based implementation of the Map interface.

This class implements the Set interface, backed by a hash table (actually a HashMap instance).

This class implements a hash table, which maps keys to values.

HexFormat converts between bytes and chars and hex-encoded strings which may include additional formatting markup such as prefixes, suffixes, and delimiters.

A document that models HTML.

An iterator to iterate over a particular type of tag.

This class implements the Map interface with a hash table, using reference-equality in place of object-equality when comparing keys (and values).

Thrown if an application attempts to access or modify a field, or to call a method that it does not have access to.

An IllegalAccessException is thrown when an application tries to reflectively create an instance (other than an array), set or get a field, or invoke a method, but the currently executing method does not have access to the definition of the specified class, field, method or constructor.

Thrown to indicate that a method has been passed an illegal or inappropriate argument.

Thrown to indicate that a method has been called by an inappropriate caller.

Unchecked exception thrown when a character with an invalid Unicode code point as defined by Character.isValidCodePoint(int) is passed to the Formatter.

Unchecked exception thrown when the argument corresponding to the format specifier is of an incompatible type.

Unchecked exception thrown when a format string contains an illegal syntax or a format specifier that is incompatible with the given arguments.

Unchecked exception thrown when an illegal combination flags is given.

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.

Unchecked exception thrown when the format width is a negative value other than -1 or is otherwise unsupported.

Thrown to indicate that a thread has attempted to wait on an object's monitor or to notify other threads waiting on an object's monitor without owning the specified monitor.

Signals that a method has been invoked at an illegal or inappropriate time.

Thrown to indicate that a thread is not in an appropriate state for the requested operation.

Thrown by methods in Locale and Locale.Builder to indicate that an argument is not a well-formed BCP 47 tag.

Thrown when an incompatible class change has occurred to some class definition.

Thrown to indicate that a program has attempted to access an element of an annotation interface that was added to the annotation interface definition after the annotation was compiled (or serialized).

Thrown to indicate that an index of some sort (such as to an array, to a string, or to a vector) is out of range.

This class extends ThreadLocal to provide inheritance of values from parent thread to child thread: when a child thread is created, the child receives initial values for all inheritable thread-local variables for which the parent has values.

Indicates that an annotation interface is automatically inherited.

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.

This abstract class is the superclass of all classes representing an input stream of bytes.

An InputStreamReader is a bridge from byte streams to character streams: It reads bytes and decodes them into characters using a specified charset.

Thrown when an application tries to use the Java new construct to instantiate an abstract class or an interface.

Thrown when an application tries to create an instance of a class using the newInstance method in class Class, but the specified class object cannot be instantiated.

The Integer class wraps a value of the primitive type int in an object.

Thrown to indicate some unexpected internal error has occurred in the Java Virtual Machine.

Thrown when a thread is waiting, sleeping, or otherwise occupied, and the thread is interrupted, either before or during the activity.

Signals that an I/O operation has been interrupted.

A state object for collecting statistics such as count, min, max, sum, and average.

Thrown when the Serialization runtime detects one of the following problems with a Class.

Indicates that one or more deserialized objects failed validation tests.

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.

Thrown when a serious I/O error has occurred.

Signals that an I/O exception of some sort has occurred.

Implementing this interface allows an object to be the target of the enhanced for statement (sometimes called the "for-each loop" statement).

An iterator over a collection.

JOptionPane makes it easy to pop up a standard dialog box that prompts users for a value or informs them of something.

JTextComponent is the base class for swing text components.

Represents a drop location for JTextComponents.

Binding record for creating key bindings.

Thrown when creating a module layer fails.

Deprecated. This class incorrectly assumes that bytes adequately represent characters.

A buffered character-input stream that keeps track of line numbers.

Subclasses of LinkageError indicate that a class has some dependency on another class; however, the latter class has incompatibly changed after the compilation of the former class.

An optionally-bounded blocking deque based on linked nodes.

An optionally-bounded blocking queue based on linked nodes.

Hash table and linked list implementation of the Map interface, with predictable iteration order.

Hash table and linked list implementation of the Set interface, with predictable iteration order.

Doubly-linked list implementation of the List and Deque interfaces.

An unbounded TransferQueue based on linked nodes.

An ordered collection (also known as a sequence).

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 is an abstract subclass of ResourceBundle that manages resources for a locale in a convenient and easy to use list.

A Locale object represents a specific geographical, political, or cultural region.

Builder is used to build instances of Locale from values configured by the setters.

Enum for locale categories.

This enum provides constants to select a filtering mode for locale matching.

Enum for specifying the type defined in ISO 3166.

This class expresses a Language Range defined in RFC 4647 Matching of Language Tags.

The Long class wraps a value of the primitive type long in an object.

A state object for collecting statistics such as count, min, max, sum, and average.

An object that maps keys to values.

A map entry (key-value pair).

The class Math contains methods for performing basic numeric operations such as the elementary exponential, logarithm, square root, and trigonometric functions.

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.

Unchecked exception thrown when the format width is required.

Signals that a resource is missing.

Represents a run-time module, either named or unnamed.

A layer of modules in the Java virtual machine.

Controls a module layer.

Indicates that a field defining a constant value may be referenced from native code.

A SortedMap extended with navigation methods returning the closest matches for given search targets.

A SortedSet extended with navigation methods reporting closest matches for given search targets.

Thrown if an application tries to create an array with negative size.

Thrown if the Java Virtual Machine or a ClassLoader instance tries to load in the definition of a class (as part of a normal method call or as part of creating a new instance using the new expression) and no definition of the class could be found.

Thrown by various accessor methods to indicate that the element being requested does not exist.

Thrown if an application tries to access or modify a specified field of an object, and that object no longer has that field.

Signals that the class doesn't have a field of a specified name.

Thrown if an application tries to call a specified method of a class (either static or instance), and that class no longer has a definition of that method.

Thrown when a particular method cannot be found.

Thrown when serialization or deserialization is not active.

Thrown when an instance is required to have a Serializable interface.

Thrown when an application attempts to use null in a case where an object is required.

The abstract class Number is the superclass of platform classes representing numeric values that are convertible to the primitive types byte, double, float, int, long, and short.

Thrown to indicate that the application has attempted to convert a string to one of the numeric types, but that the string does not have the appropriate format.

Class Object is the root of the class hierarchy.

ObjectInput extends the DataInput interface to include the reading of objects.

Filter classes, array lengths, and graph metrics during deserialization.

A utility class to set and get the JVM-wide deserialization filter factory, the static JVM-wide filter, or to create a filter from a pattern string.

FilterInfo provides access to information about the current object being deserialized and the status of the ObjectInputStream.

The status of a check on the class, array length, number of references, depth, and stream size.

An ObjectInputStream deserializes primitive data and objects previously written using an ObjectOutputStream.

Provide access to the persistent fields read from the input stream.

Callback interface to allow validation of objects within a graph.

ObjectOutput extends the DataOutput interface to include writing of objects.

An ObjectOutputStream writes primitive data types and graphs of Java objects to an OutputStream.

Provide programmatic access to the persistent fields to be written to ObjectOutput.

This class consists of static utility methods for operating on objects, or checking certain conditions before operation.

Serialization's descriptor for classes.

Constants written into the Object Serialization Stream.

Superclass of all exceptions specific to Object Stream classes.

A description of a Serializable field from a Serializable class.

Deprecated. This class and the Observer interface have been deprecated.

Deprecated. This interface has been deprecated.

A container object which may or may not contain a non-null value.

Exception indicating the failure of an object read operation due to unread primitive data, or the end of data belonging to a serialized object in the stream.

A container object which may or may not contain a double value.

A container object which may or may not contain an int value.

A container object which may or may not contain a long value.

Thrown when the Java Virtual Machine cannot allocate an object because it is out of memory, and no more memory could be made available by the garbage collector.

This abstract class is the superclass of all classes representing an output stream of bytes.

An OutputStreamWriter is a bridge from character streams to byte streams: Characters written to it are encoded into bytes using a specified charset.

Indicates that a method declaration is intended to override a method declaration in a supertype.

Represents metadata about a run-time package associated with a class loader.

A reusable synchronization barrier, similar in functionality to CyclicBarrier and CountDownLatch but supporting more flexible usage.

A piped input stream should be connected to a piped output stream; the piped input stream then provides whatever data bytes are written to the piped output stream.

A piped output stream can be connected to a piped input stream to create a communications pipe.

Piped character-input streams.

Piped character-output streams.

A base type for primitive specializations of Iterator.

An Iterator specialized for double values.

An Iterator specialized for int values.

An Iterator specialized for long values.

A PrintStream adds functionality to another output stream, namely the ability to print representations of various data values conveniently.

Prints formatted representations of objects to a text-output stream.

An unbounded blocking queue that uses the same ordering rules as class PriorityQueue and supplies blocking retrieval operations.

An unbounded priority queue based on a priority heap.

Process provides control of native processes started by ProcessBuilder.start and Runtime.exec.

This class is used to create operating system processes.

Represents a source of subprocess input or a destination of subprocess output.

The type of a Redirect.

ProcessHandle identifies and provides control of native processes.

Information snapshot about the process.

The Properties class represents a persistent set of properties.

This class is for property permissions.

PropertyResourceBundle is a concrete subclass of ResourceBundle that manages resources for a locale using a set of static strings from a property file.

A PushbackInputStream adds functionality to another input stream, namely the ability to "push back" or "unread" bytes, by storing pushed-back bytes in an internal buffer.

A character-stream reader that allows characters to be pushed back into the stream.

A collection designed for holding elements prior to processing.

An instance of this class is used to generate a stream of pseudorandom numbers; its period is only 2⁴⁸.

Marker interface used by List implementations to indicate that they support fast (generally constant time) random access.

Instances of this class support both reading and writing to a random access file.

A Readable is a source of characters.

Abstract class for reading character streams.

This is the common base class of all Java language record classes.

A recursive resultless ForkJoinTask.

A recursive result-bearing ForkJoinTask.

Common superclass of exceptions thrown by reflective operations in core reflection.

Exception thrown by an Executor when a task cannot be accepted for execution.

A handler for tasks that cannot be executed by a ThreadPoolExecutor.

The annotation interface java.lang.annotation.Repeatable is used to indicate that the annotation interface whose declaration it (meta-)annotates is repeatable.

Interface for reporting diagnostics and other messages.

Resource bundles contain locale-specific objects.

ResourceBundle.Control defines a set of callback methods that are invoked by the ResourceBundle.getBundle factory methods during the bundle loading process.

Indicates how long annotations with the annotated interface are to be retained.

Annotation retention policy.

The Runnable interface should be implemented by any class whose instances are intended to be executed by a thread.

A Future that is Runnable.

A ScheduledFuture that is Runnable.

Every Java application has a single instance of class Runtime that allows the application to interface with the environment in which the application is running.

A representation of a version string for an implementation of the Java SE Platform.

RuntimeException is the superclass of those exceptions that can be thrown during the normal operation of the Java Virtual Machine.

This class is for runtime permissions.

A programmer assertion that the body of the annotated method or constructor does not perform potentially unsafe operations on its varargs parameter.

A simple text scanner which can parse primitive types and strings using regular expressions.

An ExecutorService that can schedule commands to run after a given delay, or to execute periodically.

A delayed result-bearing action that can be cancelled.

A ThreadPoolExecutor that can additionally schedule commands to run after a given delay, or to execute periodically.

Thrown by the security manager to indicate a security violation.

Deprecated, for removal. The Security Manager is deprecated and subject to removal in a future release.

A counting semaphore.

A SequenceInputStream represents the logical concatenation of other input streams.

Indicates that an annotated field or method is part of the serialization mechanism defined by the Java Object Serialization Specification.

Serializability of a class is enabled by the class implementing the java.io.Serializable interface.

This class is for Serializable permissions.

Error thrown when something goes wrong while locating, loading, or instantiating a service provider.

A facility to load implementations of a service.

Represents a service provider located by ServiceLoader.

A collection that contains no duplicate elements.

The Short class wraps a value of primitive type short in an object.

SimpleTimeZone is a concrete subclass of TimeZone that represents a time zone for use with a Gregorian calendar.

A Map that further provides a total ordering on its keys.

A Set that further provides a total ordering on its elements.

An object for traversing and partitioning elements of a source.

A Spliterator specialized for double values.

A Spliterator specialized for int values.

A Spliterator specialized for long values.

A Spliterator specialized for primitive values.

Static classes and methods for operating on or creating instances of Spliterator and its primitive specializations Spliterator.OfInt, Spliterator.OfLong, and Spliterator.OfDouble.

An abstract Spliterator.OfDouble that implements trySplit to permit limited parallelism.

An abstract Spliterator.OfInt that implements trySplit to permit limited parallelism.

An abstract Spliterator.OfLong that implements trySplit to permit limited parallelism.

An abstract Spliterator that implements trySplit to permit limited parallelism.

A generator of uniform pseudorandom values (with period 2⁶⁴) applicable for use in (among other contexts) isolated parallel computations that may generate subtasks.

The Stack class represents a last-in-first-out (LIFO) stack of objects.

Thrown when a stack overflow occurs because an application recurses too deeply.

An element in a stack trace, as returned by Throwable.getStackTrace().

A stack walker.

Stack walker option to configure the stack frame information obtained by a StackWalker.

A StackFrame object represents a method invocation returned by StackWalker.

This doclet generates HTML-formatted documentation for the specified modules, packages and types.

StateEdit is a general edit for objects that change state.

StateEditable defines the interface for objects that can have their state undone/redone by a StateEdit.

Thrown when control information that was read from an object stream violates internal consistency checks.

The StreamTokenizer class takes an input stream and parses it into "tokens", allowing the tokens to be read one at a time.

The class StrictMath contains methods for performing basic numeric operations such as the elementary exponential, logarithm, square root, and trigonometric functions.

The String class represents character strings.

A thread-safe, mutable sequence of characters.

Deprecated. This class does not properly convert characters into bytes.

A mutable sequence of characters.

Thrown by String methods to indicate that an index is either negative or greater than the size of the string.

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.

A character stream whose source is a string.

The string tokenizer class allows an application to break a string into tokens.

A character stream that collects its output in a string buffer, which can then be used to construct a string.

A Flow.Publisher that asynchronously issues submitted (non-null) items to current subscribers until it is closed.

Indicates that the named compiler warnings should be suppressed in the annotated element (and in all program elements contained in the annotated element).

Signals that a sync operation has failed.

A blocking queue in which each insert operation must wait for a corresponding remove operation by another thread, and vice versa.

The System class contains several useful class fields and methods.

System.Logger instances log messages that will be routed to the underlying logging framework the LoggerFinder uses.

System loggers levels.

The LoggerFinder service is responsible for creating, managing, and configuring loggers to the underlying framework it uses.

The interface for a custom taglet supported by doclets such as the standard doclet.

The kind of location in which a tag may be used.

Indicates the contexts in which an annotation interface is applicable.

A thread is a thread of execution in a program.

A thread state.

Interface for handlers invoked when a Thread abruptly terminates due to an uncaught exception.

An instance of ThreadDeath is thrown in the victim thread when the (deprecated) Thread.stop() method is invoked.

An object that creates new threads on demand.

A thread group represents a set of threads.

This class provides thread-local variables.

A random number generator (with period 2⁶⁴) isolated to the current thread.

An ExecutorService that executes each submitted task using one of possibly several pooled threads, normally configured using Executors factory methods.

A handler for rejected tasks that throws a RejectedExecutionException.

A handler for rejected tasks that runs the rejected task directly in the calling thread of the execute method, unless the executor has been shut down, in which case the task is discarded.

A handler for rejected tasks that discards the oldest unhandled request and then retries execute, unless the executor is shut down, in which case the task is discarded.

A handler for rejected tasks that silently discards the rejected task.

The Throwable class is the superclass of all errors and exceptions in the Java language.

Exception thrown when a blocking operation times out.

A facility for threads to schedule tasks for future execution in a background thread.

A task that can be scheduled for one-time or repeated execution by a Timer.

A TimeUnit represents time durations at a given unit of granularity and provides utility methods to convert across units, and to perform timing and delay operations in these units.

TimeZone represents a time zone offset, and also figures out daylight savings.

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.

A BlockingQueue in which producers may wait for consumers to receive elements.

A Red-Black tree based NavigableMap implementation.

A NavigableSet implementation based on a TreeMap.

Thrown when an application tries to access a type using a string representing the type's name, but no definition for the type with the specified name can be found.

Wraps an IOException with an unchecked exception.

An UndoableEdit represents an edit.

A support class used for managing UndoableEdit listeners.

UndoManager manages a list of UndoableEdits, providing a way to undo or redo the appropriate edits.

Thrown when an unknown but serious exception has occurred in the Java Virtual Machine.

Unchecked exception thrown when an unknown conversion is given.

Unchecked exception thrown when an unknown flag is given.

Thrown if the Java Virtual Machine cannot find an appropriate native-language definition of a method declared native.

Thrown when the Java Virtual Machine attempts to read a class file and determines that the major and minor version numbers in the file are not supported.

The Character Encoding is not supported.

Thrown to indicate that the requested operation is not supported.

Signals that a malformed string in modified UTF-8 format has been read in a data input stream or by any class that implements the data input interface.

A class that represents an immutable universally unique identifier (UUID).

The Vector class implements a growable array of objects.

Thrown when the "verifier" detects that a class file, though well formed, contains some sort of internal inconsistency or security problem.

Thrown to indicate that the Java Virtual Machine is broken or has run out of resources necessary for it to continue operating.

The Void class is an uninstantiable placeholder class to hold a reference to the Class object representing the Java keyword void.

Hash table based implementation of the Map interface, with weak keys.

Signals that one of the ObjectStreamExceptions was thrown during a write operation.

Abstract class for writing to character streams.