compact1 (Java Platform SE 8 )
Keywords: compact1 profile
Date: 2026-03-16

# Profile compact1

- - ### java.io

    Interface Summary
    Interface | Description
    --- | ---
    Closeable | A `Closeable` is a source or destination of data that can be closed.
    DataInput | The `DataInput` interface provides for reading bytes from a binary stream and reconstructing from them data in any of the Java primitive types.
    DataOutput | 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.
    Externalizable | 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.
    FileFilter | A filter for abstract pathnames.
    FilenameFilter | Instances of classes that implement this interface are used to filter filenames.
    Flushable | A `Flushable` is a destination of data that can be flushed.
    ObjectInput | ObjectInput extends the DataInput interface to include the reading of objects.
    ObjectInputValidation | Callback interface to allow validation of objects within a graph.
    ObjectOutput | ObjectOutput extends the DataOutput interface to include writing of objects.
    ObjectStreamConstants | Constants written into the Object Serialization Stream.
    Serializable | Serializability of a class is enabled by the class implementing the java.io.Serializable interface.

    Class Summary
    Class | Description
    --- | ---
    BufferedInputStream | A `BufferedInputStream` adds functionality to another input stream-namely, the ability to buffer the input and to support the `mark` and `reset` methods.
    BufferedOutputStream | The class implements a buffered output stream.
    BufferedReader | Reads text from a character-input stream, buffering characters so as to provide for the efficient reading of characters, arrays, and lines.
    BufferedWriter | Writes text to a character-output stream, buffering characters so as to provide for the efficient writing of single characters, arrays, and strings.
    ByteArrayInputStream | A `ByteArrayInputStream` contains an internal buffer that contains bytes that may be read from the stream.
    ByteArrayOutputStream | This class implements an output stream in which the data is written into a byte array.
    CharArrayReader | This class implements a character buffer that can be used as a character-input stream.
    CharArrayWriter | This class implements a character buffer that can be used as an Writer.
    Console | Methods to access the character-based console device, if any, associated with the current Java virtual machine.
    DataInputStream | A data input stream lets an application read primitive Java data types from an underlying input stream in a machine-independent way.
    DataOutputStream | A data output stream lets an application write primitive Java data types to an output stream in a portable way.
    File | An abstract representation of file and directory pathnames.
    FileDescriptor | 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.
    FileInputStream | A `FileInputStream` obtains input bytes from a file in a file system.
    FileOutputStream | A file output stream is an output stream for writing data to a `File` or to a `FileDescriptor`.
    FilePermission | This class represents access to a file or directory.
    FileReader | Convenience class for reading character files.
    FileWriter | Convenience class for writing character files.
    FilterInputStream | 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.
    FilterOutputStream | This class is the superclass of all classes that filter output streams.
    FilterReader | Abstract class for reading filtered character streams.
    FilterWriter | Abstract class for writing filtered character streams.
    InputStream | This abstract class is the superclass of all classes representing an input stream of bytes.
    InputStreamReader | An InputStreamReader is a bridge from byte streams to character streams: It reads bytes and decodes them into characters using a specified `charset`.
    LineNumberInputStream | Deprecated This class incorrectly assumes that bytes adequately represent characters.
    LineNumberReader | A buffered character-input stream that keeps track of line numbers.
    ObjectInputStream | An ObjectInputStream deserializes primitive data and objects previously written using an ObjectOutputStream.
    ObjectInputStream.GetField | Provide access to the persistent fields read from the input stream.
    ObjectOutputStream | An ObjectOutputStream writes primitive data types and graphs of Java objects to an OutputStream.
    ObjectOutputStream.PutField | Provide programmatic access to the persistent fields to be written to ObjectOutput.
    ObjectStreamClass | Serialization's descriptor for classes.
    ObjectStreamField | A description of a Serializable field from a Serializable class.
    OutputStream | This abstract class is the superclass of all classes representing an output stream of bytes.
    OutputStreamWriter | An OutputStreamWriter is a bridge from character streams to byte streams: Characters written to it are encoded into bytes using a specified `charset`.
    PipedInputStream | 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.
    PipedOutputStream | A piped output stream can be connected to a piped input stream to create a communications pipe.
    PipedReader | Piped character-input streams.
    PipedWriter | Piped character-output streams.
    PrintStream | A `PrintStream` adds functionality to another output stream, namely the ability to print representations of various data values conveniently.
    PrintWriter | Prints formatted representations of objects to a text-output stream.
    PushbackInputStream | A `PushbackInputStream` adds functionality to another input stream, namely the ability to "push back" or "unread" one byte.
    PushbackReader | A character-stream reader that allows characters to be pushed back into the stream.
    RandomAccessFile | Instances of this class support both reading and writing to a random access file.
    Reader | Abstract class for reading character streams.
    SequenceInputStream | A `SequenceInputStream` represents the logical concatenation of other input streams.
    SerializablePermission | This class is for Serializable permissions.
    StreamTokenizer | The `StreamTokenizer` class takes an input stream and parses it into "tokens", allowing the tokens to be read one at a time.
    StringBufferInputStream | Deprecated This class does not properly convert characters into bytes.
    StringReader | A character stream whose source is a string.
    StringWriter | A character stream that collects its output in a string buffer, which can then be used to construct a string.
    Writer | Abstract class for writing to character streams.

    Exception Summary
    Exception | Description
    --- | ---
    CharConversionException | Base class for character conversion exceptions.
    EOFException | Signals that an end of file or end of stream has been reached unexpectedly during input.
    FileNotFoundException | Signals that an attempt to open the file denoted by a specified pathname has failed.
    InterruptedIOException | Signals that an I/O operation has been interrupted.
    InvalidClassException | Thrown when the Serialization runtime detects one of the following problems with a Class.
    InvalidObjectException | Indicates that one or more deserialized objects failed validation tests.
    IOException | Signals that an I/O exception of some sort has occurred.
    NotActiveException | Thrown when serialization or deserialization is not active.
    NotSerializableException | Thrown when an instance is required to have a Serializable interface.
    ObjectStreamException | Superclass of all exceptions specific to Object Stream classes.
    OptionalDataException | 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.
    StreamCorruptedException | Thrown when control information that was read from an object stream violates internal consistency checks.
    SyncFailedException | Signals that a sync operation has failed.
    UncheckedIOException | Wraps an `IOException` with an unchecked exception.
    UnsupportedEncodingException | The Character Encoding is not supported.
    UTFDataFormatException | 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.
    WriteAbortedException | Signals that one of the ObjectStreamExceptions was thrown during a write operation.

    Error Summary
    Error | Description
    --- | ---
    IOError | Thrown when a serious I/O error has occurred.

  - ### java.lang

    Interface Summary
    Interface | Description
    --- | ---
    Appendable | An object to which `char` sequences and values can be appended.
    AutoCloseable | An object that may hold resources (such as file or socket handles) until it is closed.
    CharSequence | A `CharSequence` is a readable sequence of `char` values.
    Cloneable | 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.
    Comparable<T> | This interface imposes a total ordering on the objects of each class that implements it.
    Iterable<T> | Implementing this interface allows an object to be the target of the "for-each loop" statement.
    Readable | A `Readable` is a source of characters.
    Runnable | The `Runnable` interface should be implemented by any class whose instances are intended to be executed by a thread.
    Thread.UncaughtExceptionHandler | Interface for handlers invoked when a `Thread` abruptly terminates due to an uncaught exception.

    Class Summary
    Class | Description
    --- | ---
    Boolean | The Boolean class wraps a value of the primitive type `boolean` in an object.
    Byte | The `Byte` class wraps a value of primitive type `byte` in an object.
    Character | The `Character` class wraps a value of the primitive type `char` in an object.
    Character.Subset | Instances of this class represent particular subsets of the Unicode character set.
    Character.UnicodeBlock | A family of character subsets representing the character blocks in the Unicode specification.
    Class<T> | Instances of the class `Class` represent classes and interfaces in a running Java application.
    ClassLoader | A class loader is an object that is responsible for loading classes.
    ClassValue<T> | Lazily associate a computed value with (potentially) every type.
    Compiler | The `Compiler` class is provided to support Java-to-native-code compilers and related services.
    Double | The `Double` class wraps a value of the primitive type `double` in an object.
    Enum<E extends Enum<E>> | This is the common base class of all Java language enumeration types.
    Float | The `Float` class wraps a value of primitive type `float` in an object.
    InheritableThreadLocal<T> | 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.
    Integer | The `Integer` class wraps a value of the primitive type `int` in an object.
    Long | The `Long` class wraps a value of the primitive type `long` in an object.
    Math | The class `Math` contains methods for performing basic numeric operations such as the elementary exponential, logarithm, square root, and trigonometric functions.
    Number | 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`.
    Object | Class `Object` is the root of the class hierarchy.
    Package | `Package` objects contain version information about the implementation and specification of a Java package.
    Process | The `ProcessBuilder.start()` and `Runtime.exec` methods create a native process and return an instance of a subclass of `Process` that can be used to control the process and obtain information about it.
    ProcessBuilder | This class is used to create operating system processes.
    ProcessBuilder.Redirect | Represents a source of subprocess input or a destination of subprocess output.
    Runtime | 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.
    RuntimePermission | This class is for runtime permissions.
    SecurityManager | The security manager is a class that allows applications to implement a security policy.
    Short | The `Short` class wraps a value of primitive type `short` in an object.
    StackTraceElement | An element in a stack trace, as returned by `Throwable.getStackTrace()`.
    StrictMath | The class `StrictMath` contains methods for performing basic numeric operations such as the elementary exponential, logarithm, square root, and trigonometric functions.
    String | The `String` class represents character strings.
    StringBuffer | A thread-safe, mutable sequence of characters.
    StringBuilder | A mutable sequence of characters.
    System | The `System` class contains several useful class fields and methods.
    Thread | A thread is a thread of execution in a program.
    ThreadGroup | A thread group represents a set of threads.
    ThreadLocal<T> | This class provides thread-local variables.
    Throwable | The `Throwable` class is the superclass of all errors and exceptions in the Java language.
    Void | The `Void` class is an uninstantiable placeholder class to hold a reference to the `Class` object representing the Java keyword void.

    Enum Summary
    Enum | Description
    --- | ---
    Character.UnicodeScript | A family of character subsets representing the character scripts defined in the Unicode Standard Annex #24: Script Names.
    ProcessBuilder.Redirect.Type | The type of a `ProcessBuilder.Redirect`.
    Thread.State | A thread state.

    Exception Summary
    Exception | Description
    --- | ---
    ArithmeticException | Thrown when an exceptional arithmetic condition has occurred.
    ArrayIndexOutOfBoundsException | Thrown to indicate that an array has been accessed with an illegal index.
    ArrayStoreException | Thrown to indicate that an attempt has been made to store the wrong type of object into an array of objects.
    ClassCastException | Thrown to indicate that the code has attempted to cast an object to a subclass of which it is not an instance.
    ClassNotFoundException | Thrown when an application tries to load in a class through its string name using: The `forName` method in class `Class`.
    CloneNotSupportedException | 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.
    EnumConstantNotPresentException | Thrown when an application tries to access an enum constant by name and the enum type contains no constant with the specified name.
    Exception | The class `Exception` and its subclasses are a form of `Throwable` that indicates conditions that a reasonable application might want to catch.
    IllegalAccessException | 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.
    IllegalArgumentException | Thrown to indicate that a method has been passed an illegal or inappropriate argument.
    IllegalMonitorStateException | 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.
    IllegalStateException | Signals that a method has been invoked at an illegal or inappropriate time.
    IllegalThreadStateException | Thrown to indicate that a thread is not in an appropriate state for the requested operation.
    IndexOutOfBoundsException | 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.
    InstantiationException | 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.
    InterruptedException | Thrown when a thread is waiting, sleeping, or otherwise occupied, and the thread is interrupted, either before or during the activity.
    NegativeArraySizeException | Thrown if an application tries to create an array with negative size.
    NoSuchFieldException | Signals that the class doesn't have a field of a specified name.
    NoSuchMethodException | Thrown when a particular method cannot be found.
    NullPointerException | Thrown when an application attempts to use `null` in a case where an object is required.
    NumberFormatException | 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.
    ReflectiveOperationException | Common superclass of exceptions thrown by reflective operations in core reflection.
    RuntimeException | `RuntimeException` is the superclass of those exceptions that can be thrown during the normal operation of the Java Virtual Machine.
    SecurityException | Thrown by the security manager to indicate a security violation.
    StringIndexOutOfBoundsException | Thrown by `String` methods to indicate that an index is either negative or greater than the size of the string.
    TypeNotPresentException | 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.
    UnsupportedOperationException | Thrown to indicate that the requested operation is not supported.

    Error Summary
    Error | Description
    --- | ---
    AbstractMethodError | Thrown when an application tries to call an abstract method.
    AssertionError | Thrown to indicate that an assertion has failed.
    BootstrapMethodError | Thrown to indicate that an `invokedynamic` instruction has failed to find its bootstrap method, or the bootstrap method has failed to provide a call site with a target of the correct method type.
    ClassCircularityError | Thrown when the Java Virtual Machine detects a circularity in the superclass hierarchy of a class being loaded.
    ClassFormatError | 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.
    Error | An `Error` is a subclass of `Throwable` that indicates serious problems that a reasonable application should not try to catch.
    ExceptionInInitializerError | Signals that an unexpected exception has occurred in a static initializer.
    IllegalAccessError | Thrown if an application attempts to access or modify a field, or to call a method that it does not have access to.
    IncompatibleClassChangeError | Thrown when an incompatible class change has occurred to some class definition.
    InstantiationError | Thrown when an application tries to use the Java `new` construct to instantiate an abstract class or an interface.
    InternalError | Thrown to indicate some unexpected internal error has occurred in the Java Virtual Machine.
    LinkageError | 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.
    NoClassDefFoundError | 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.
    NoSuchFieldError | Thrown if an application tries to access or modify a specified field of an object, and that object no longer has that field.
    NoSuchMethodError | 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.
    OutOfMemoryError | 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.
    StackOverflowError | Thrown when a stack overflow occurs because an application recurses too deeply.
    ThreadDeath | An instance of `ThreadDeath` is thrown in the victim thread when the (deprecated) `Thread.stop()` method is invoked.
    UnknownError | Thrown when an unknown but serious exception has occurred in the Java Virtual Machine.
    UnsatisfiedLinkError | Thrown if the Java Virtual Machine cannot find an appropriate native-language definition of a method declared `native`.
    UnsupportedClassVersionError | 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.
    VerifyError | Thrown when the "verifier" detects that a class file, though well formed, contains some sort of internal inconsistency or security problem.
    VirtualMachineError | Thrown to indicate that the Java Virtual Machine is broken or has run out of resources necessary for it to continue operating.

    Annotation Types Summary
    Annotation Type | Description
    --- | ---
    Deprecated | A program element annotated @Deprecated is one that programmers are discouraged from using, typically because it is dangerous, or because a better alternative exists.
    FunctionalInterface | 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.
    Override | Indicates that a method declaration is intended to override a method declaration in a supertype.
    SafeVarargs | A programmer assertion that the body of the annotated method or constructor does not perform potentially unsafe operations on its varargs parameter.
    SuppressWarnings | Indicates that the named compiler warnings should be suppressed in the annotated element (and in all program elements contained in the annotated element).

  - ### java.lang.annotation

    Interface Summary
    Interface | Description
    --- | ---
    Annotation | The common interface extended by all annotation types.

    Enum Summary
    Enum | Description
    --- | ---
    ElementType | The constants of this enumerated type provide a simple classification of the syntactic locations where annotations may appear in a Java program.
    RetentionPolicy | Annotation retention policy.

    Exception Summary
    Exception | Description
    --- | ---
    AnnotationTypeMismatchException | 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).
    IncompleteAnnotationException | Thrown to indicate that a program has attempted to access an element of an annotation type that was added to the annotation type definition after the annotation was compiled (or serialized).

    Error Summary
    Error | Description
    --- | ---
    AnnotationFormatError | Thrown when the annotation parser attempts to read an annotation from a class file and determines that the annotation is malformed.

    Annotation Types Summary
    Annotation Type | Description
    --- | ---
    Documented | Indicates that annotations with a type are to be documented by javadoc and similar tools by default.
    Inherited | Indicates that an annotation type is automatically inherited.
    Native | Indicates that a field defining a constant value may be referenced from native code.
    Repeatable | The annotation type `java.lang.annotation.Repeatable` is used to indicate that the annotation type whose declaration it (meta-)annotates is repeatable.
    Retention | Indicates how long annotations with the annotated type are to be retained.
    Target | Indicates the contexts in which an annotation type is applicable.

  - ### java.lang.invoke

    Interface Summary
    Interface | Description
    --- | ---
    MethodHandleInfo | A symbolic reference obtained by cracking a direct method handle into its consitutent symbolic parts.

    Class Summary
    Class | Description
    --- | ---
    CallSite | A `CallSite` is a holder for a variable `MethodHandle`, which is called its `target`.
    ConstantCallSite | A `ConstantCallSite` is a `CallSite` whose target is permanent, and can never be changed.
    LambdaMetafactory | Methods to facilitate the creation of simple "function objects" that implement one or more interfaces by delegation to a provided `MethodHandle`, possibly after type adaptation and partial evaluation of arguments.
    MethodHandle | A method handle is a typed, directly executable reference to an underlying method, constructor, field, or similar low-level operation, with optional transformations of arguments or return values.
    MethodHandleProxies | This class consists exclusively of static methods that help adapt method handles to other JVM types, such as interfaces.
    MethodHandles | This class consists exclusively of static methods that operate on or return method handles.
    MethodHandles.Lookup | A lookup object is a factory for creating method handles, when the creation requires access checking.
    MethodType | A method type represents the arguments and return type accepted and returned by a method handle, or the arguments and return type passed and expected by a method handle caller.
    MutableCallSite | A `MutableCallSite` is a `CallSite` whose target variable behaves like an ordinary field.
    SerializedLambda | Serialized form of a lambda expression.
    SwitchPoint | A `SwitchPoint` is an object which can publish state transitions to other threads.
    VolatileCallSite | A `VolatileCallSite` is a `CallSite` whose target acts like a volatile variable.

    Exception Summary
    Exception | Description
    --- | ---
    LambdaConversionException | LambdaConversionException
    WrongMethodTypeException | Thrown to indicate that code has attempted to call a method handle via the wrong method type.

  - ### java.lang.ref

    Class Summary
    Class | Description
    --- | ---
    PhantomReference<T> | Phantom reference objects, which are enqueued after the collector determines that their referents may otherwise be reclaimed.
    Reference<T> | Abstract base class for reference objects.
    ReferenceQueue<T> | Reference queues, to which registered reference objects are appended by the garbage collector after the appropriate reachability changes are detected.
    SoftReference<T> | Soft reference objects, which are cleared at the discretion of the garbage collector in response to memory demand.
    WeakReference<T> | Weak reference objects, which do not prevent their referents from being made finalizable, finalized, and then reclaimed.

  - ### java.lang.reflect

    Interface Summary
    Interface | Description
    --- | ---
    AnnotatedArrayType | `AnnotatedArrayType` represents the potentially annotated use of an array type, whose component type may itself represent the annotated use of a type.
    AnnotatedElement | Represents an annotated element of the program currently running in this VM.
    AnnotatedParameterizedType | `AnnotatedParameterizedType` represents the potentially annotated use of a parameterized type, whose type arguments may themselves represent annotated uses of types.
    AnnotatedType | `AnnotatedType` represents the potentially annotated use of a type in the program currently running in this VM.
    AnnotatedTypeVariable | `AnnotatedTypeVariable` represents the potentially annotated use of a type variable, whose declaration may have bounds which themselves represent annotated uses of types.
    AnnotatedWildcardType | `AnnotatedWildcardType` represents the potentially annotated use of a wildcard type argument, whose upper or lower bounds may themselves represent annotated uses of types.
    GenericArrayType | `GenericArrayType` represents an array type whose component type is either a parameterized type or a type variable.
    GenericDeclaration | A common interface for all entities that declare type variables.
    InvocationHandler | `InvocationHandler` is the interface implemented by the invocation handler of a proxy instance.
    Member | Member is an interface that reflects identifying information about a single member (a field or a method) or a constructor.
    ParameterizedType | ParameterizedType represents a parameterized type such as Collection<String>.
    Type | Type is the common superinterface for all types in the Java programming language.
    TypeVariable<D extends GenericDeclaration> | TypeVariable is the common superinterface for type variables of kinds.
    WildcardType | WildcardType represents a wildcard type expression, such as `?`, `? extends Number`, or `? super Integer`.

    Class Summary
    Class | Description
    --- | ---
    AccessibleObject | The AccessibleObject class is the base class for Field, Method and Constructor objects.
    Array | The `Array` class provides static methods to dynamically create and access Java arrays.
    Constructor<T> | `Constructor` provides information about, and access to, a single constructor for a class.
    Executable | A shared superclass for the common functionality of `Method` and `Constructor`.
    Field | A `Field` provides information about, and dynamic access to, a single field of a class or an interface.
    Method | A `Method` provides information about, and access to, a single method on a class or interface.
    Modifier | The Modifier class provides `static` methods and constants to decode class and member access modifiers.
    Parameter | Information about method parameters.
    Proxy | `Proxy` provides static methods for creating dynamic proxy classes and instances, and it is also the superclass of all dynamic proxy classes created by those methods.
    ReflectPermission | The Permission class for reflective operations.

    Exception Summary
    Exception | Description
    --- | ---
    InvocationTargetException | InvocationTargetException is a checked exception that wraps an exception thrown by an invoked method or constructor.
    MalformedParameterizedTypeException | Thrown when a semantically malformed parameterized type is encountered by a reflective method that needs to instantiate it.
    MalformedParametersException | Thrown when `the java.lang.reflect package` attempts to read method parameters from a class file and determines that one or more parameters are malformed.
    UndeclaredThrowableException | Thrown by a method invocation on a proxy instance if its invocation handler's `invoke` method throws a checked exception (a `Throwable` that is not assignable to `RuntimeException` or `Error`) that is not assignable to any of the exception types declared in the `throws` clause of the method that was invoked on the proxy instance and dispatched to the invocation handler.

    Error Summary
    Error | Description
    --- | ---
    GenericSignatureFormatError | Thrown when a syntactically malformed signature attribute is encountered by a reflective method that needs to interpret the generic signature information for a type, method or constructor.

  - ### java.math

    Class Summary
    Class | Description
    --- | ---
    BigDecimal | Immutable, arbitrary-precision signed decimal numbers.
    BigInteger | Immutable arbitrary-precision integers.
    MathContext | Immutable objects which encapsulate the context settings which describe certain rules for numerical operators, such as those implemented by the `BigDecimal` class.

    Enum Summary
    Enum | Description
    --- | ---
    RoundingMode | Specifies a rounding behavior for numerical operations capable of discarding precision.

  - ### java.net

    Interface Summary
    Interface | Description
    --- | ---
    ContentHandlerFactory | This interface defines a factory for content handlers.
    CookiePolicy | CookiePolicy implementations decide which cookies should be accepted and which should be rejected.
    CookieStore | A CookieStore object represents a storage for cookie.
    DatagramSocketImplFactory | This interface defines a factory for datagram socket implementations.
    FileNameMap | A simple interface which provides a mechanism to map between a file name and a MIME type string.
    ProtocolFamily | Represents a family of communication protocols.
    SocketImplFactory | This interface defines a factory for socket implementations.
    SocketOption<T> | A socket option associated with a socket.
    SocketOptions | Interface of methods to get/set socket options.
    URLStreamHandlerFactory | This interface defines a factory for `URL` stream protocol handlers.

    Class Summary
    Class | Description
    --- | ---
    Authenticator | The class Authenticator represents an object that knows how to obtain authentication for a network connection.
    CacheRequest | Represents channels for storing resources in the ResponseCache.
    CacheResponse | Represent channels for retrieving resources from the ResponseCache.
    ContentHandler | The abstract class `ContentHandler` is the superclass of all classes that read an `Object` from a `URLConnection`.
    CookieHandler | A CookieHandler object provides a callback mechanism to hook up a HTTP state management policy implementation into the HTTP protocol handler.
    CookieManager | CookieManager provides a concrete implementation of `CookieHandler`, which separates the storage of cookies from the policy surrounding accepting and rejecting cookies.
    DatagramPacket | This class represents a datagram packet.
    DatagramSocket | This class represents a socket for sending and receiving datagram packets.
    DatagramSocketImpl | Abstract datagram and multicast socket implementation base class.
    HttpCookie | An HttpCookie object represents an HTTP cookie, which carries state information between server and user agent.
    HttpURLConnection | A URLConnection with support for HTTP-specific features.
    IDN | Provides methods to convert internationalized domain names (IDNs) between a normal Unicode representation and an ASCII Compatible Encoding (ACE) representation.
    Inet4Address | This class represents an Internet Protocol version 4 (IPv4) address.
    Inet6Address | This class represents an Internet Protocol version 6 (IPv6) address.
    InetAddress | This class represents an Internet Protocol (IP) address.
    InetSocketAddress | This class implements an IP Socket Address (IP address + port number) It can also be a pair (hostname + port number), in which case an attempt will be made to resolve the hostname.
    InterfaceAddress | This class represents a Network Interface address.
    JarURLConnection | A URL Connection to a Java ARchive (JAR) file or an entry in a JAR file.
    MulticastSocket | The multicast datagram socket class is useful for sending and receiving IP multicast packets.
    NetPermission | This class is for various network permissions.
    NetworkInterface | This class represents a Network Interface made up of a name, and a list of IP addresses assigned to this interface.
    PasswordAuthentication | The class PasswordAuthentication is a data holder that is used by Authenticator.
    Proxy | This class represents a proxy setting, typically a type (http, socks) and a socket address.
    ProxySelector | Selects the proxy server to use, if any, when connecting to the network resource referenced by a URL.
    ResponseCache | Represents implementations of URLConnection caches.
    SecureCacheResponse | Represents a cache response originally retrieved through secure means, such as TLS.
    ServerSocket | This class implements server sockets.
    Socket | This class implements client sockets (also called just "sockets").
    SocketAddress | This class represents a Socket Address with no protocol attachment.
    SocketImpl | The abstract class `SocketImpl` is a common superclass of all classes that actually implement sockets.
    SocketPermission | This class represents access to a network via sockets.
    StandardSocketOptions | Defines the standard socket options.
    URI | Represents a Uniform Resource Identifier (URI) reference.
    URL | Class `URL` represents a Uniform Resource Locator, a pointer to a "resource" on the World Wide Web.
    URLClassLoader | This class loader is used to load classes and resources from a search path of URLs referring to both JAR files and directories.
    URLConnection | The abstract class `URLConnection` is the superclass of all classes that represent a communications link between the application and a URL.
    URLDecoder | Utility class for HTML form decoding.
    URLEncoder | Utility class for HTML form encoding.
    URLPermission | Represents permission to access a resource or set of resources defined by a given url, and for a given set of user-settable request methods and request headers.
    URLStreamHandler | The abstract class `URLStreamHandler` is the common superclass for all stream protocol handlers.

    Enum Summary
    Enum | Description
    --- | ---
    Authenticator.RequestorType | The type of the entity requesting authentication.
    Proxy.Type | Represents the proxy type.
    StandardProtocolFamily | Defines the standard families of communication protocols.

    Exception Summary
    Exception | Description
    --- | ---
    BindException | Signals that an error occurred while attempting to bind a socket to a local address and port.
    ConnectException | Signals that an error occurred while attempting to connect a socket to a remote address and port.
    HttpRetryException | Thrown to indicate that a HTTP request needs to be retried but cannot be retried automatically, due to streaming mode being enabled.
    MalformedURLException | Thrown to indicate that a malformed URL has occurred.
    NoRouteToHostException | Signals that an error occurred while attempting to connect a socket to a remote address and port.
    PortUnreachableException | Signals that an ICMP Port Unreachable message has been received on a connected datagram.
    ProtocolException | Thrown to indicate that there is an error in the underlying protocol, such as a TCP error.
    SocketException | Thrown to indicate that there is an error creating or accessing a Socket.
    SocketTimeoutException | Signals that a timeout has occurred on a socket read or accept.
    UnknownHostException | Thrown to indicate that the IP address of a host could not be determined.
    UnknownServiceException | Thrown to indicate that an unknown service exception has occurred.
    URISyntaxException | Checked exception thrown to indicate that a string could not be parsed as a URI reference.

  - ### java.nio

    Class Summary
    Class | Description
    --- | ---
    Buffer | A container for data of a specific primitive type.
    ByteBuffer | A byte buffer.
    ByteOrder | A typesafe enumeration for byte orders.
    CharBuffer | A char buffer.
    DoubleBuffer | A double buffer.
    FloatBuffer | A float buffer.
    IntBuffer | An int buffer.
    LongBuffer | A long buffer.
    MappedByteBuffer | A direct byte buffer whose content is a memory-mapped region of a file.
    ShortBuffer | A short buffer.

    Exception Summary
    Exception | Description
    --- | ---
    BufferOverflowException | Unchecked exception thrown when a relative put operation reaches the target buffer's limit.
    BufferUnderflowException | Unchecked exception thrown when a relative get operation reaches the source buffer's limit.
    InvalidMarkException | Unchecked exception thrown when an attempt is made to reset a buffer when its mark is not defined.
    ReadOnlyBufferException | Unchecked exception thrown when a content-mutation method such as `put` or `compact` is invoked upon a read-only buffer.

  - ### java.nio.channels

    Interface Summary
    Interface | Description
    --- | ---
    AsynchronousByteChannel | An asynchronous channel that can read and write bytes.
    AsynchronousChannel | A channel that supports asynchronous I/O operations.
    ByteChannel | A channel that can read and write bytes.
    Channel | A nexus for I/O operations.
    CompletionHandler<V,A> | A handler for consuming the result of an asynchronous I/O operation.
    GatheringByteChannel | A channel that can write bytes from a sequence of buffers.
    InterruptibleChannel | A channel that can be asynchronously closed and interrupted.
    MulticastChannel | A network channel that supports Internet Protocol (IP) multicasting.
    NetworkChannel | A channel to a network socket.
    ReadableByteChannel | A channel that can read bytes.
    ScatteringByteChannel | A channel that can read bytes into a sequence of buffers.
    SeekableByteChannel | A byte channel that maintains a current position and allows the position to be changed.
    WritableByteChannel | A channel that can write bytes.

    Class Summary
    Class | Description
    --- | ---
    AsynchronousChannelGroup | A grouping of asynchronous channels for the purpose of resource sharing.
    AsynchronousFileChannel | An asynchronous channel for reading, writing, and manipulating a file.
    AsynchronousServerSocketChannel | An asynchronous channel for stream-oriented listening sockets.
    AsynchronousSocketChannel | An asynchronous channel for stream-oriented connecting sockets.
    Channels | Utility methods for channels and streams.
    DatagramChannel | A selectable channel for datagram-oriented sockets.
    FileChannel | A channel for reading, writing, mapping, and manipulating a file.
    FileChannel.MapMode | A typesafe enumeration for file-mapping modes.
    FileLock | A token representing a lock on a region of a file.
    MembershipKey | A token representing the membership of an Internet Protocol (IP) multicast group.
    Pipe | A pair of channels that implements a unidirectional pipe.
    Pipe.SinkChannel | A channel representing the writable end of a `Pipe`.
    Pipe.SourceChannel | A channel representing the readable end of a `Pipe`.
    SelectableChannel | A channel that can be multiplexed via a `Selector`.
    SelectionKey | A token representing the registration of a `SelectableChannel` with a `Selector`.
    Selector | A multiplexor of `SelectableChannel` objects.
    ServerSocketChannel | A selectable channel for stream-oriented listening sockets.
    SocketChannel | A selectable channel for stream-oriented connecting sockets.

    Exception Summary
    Exception | Description
    --- | ---
    AcceptPendingException | Unchecked exception thrown when an attempt is made to initiate an accept operation on a channel and a previous accept operation has not completed.
    AlreadyBoundException | Unchecked exception thrown when an attempt is made to bind the socket a network oriented channel that is already bound.
    AlreadyConnectedException | Unchecked exception thrown when an attempt is made to connect a `SocketChannel` that is already connected.
    AsynchronousCloseException | Checked exception received by a thread when another thread closes the channel or the part of the channel upon which it is blocked in an I/O operation.
    CancelledKeyException | Unchecked exception thrown when an attempt is made to use a selection key that is no longer valid.
    ClosedByInterruptException | Checked exception received by a thread when another thread interrupts it while it is blocked in an I/O operation upon a channel.
    ClosedChannelException | Checked exception thrown when an attempt is made to invoke or complete an I/O operation upon channel that is closed, or at least closed to that operation.
    ClosedSelectorException | Unchecked exception thrown when an attempt is made to invoke an I/O operation upon a closed selector.
    ConnectionPendingException | Unchecked exception thrown when an attempt is made to connect a `SocketChannel` for which a non-blocking connection operation is already in progress.
    FileLockInterruptionException | Checked exception received by a thread when another thread interrupts it while it is waiting to acquire a file lock.
    IllegalBlockingModeException | Unchecked exception thrown when a blocking-mode-specific operation is invoked upon a channel in the incorrect blocking mode.
    IllegalChannelGroupException | Unchecked exception thrown when an attempt is made to open a channel in a group that was not created by the same provider.
    IllegalSelectorException | Unchecked exception thrown when an attempt is made to register a channel with a selector that was not created by the provider that created the channel.
    InterruptedByTimeoutException | Checked exception received by a thread when a timeout elapses before an asynchronous operation completes.
    NoConnectionPendingException | Unchecked exception thrown when the `finishConnect` method of a `SocketChannel` is invoked without first successfully invoking its `connect` method.
    NonReadableChannelException | Unchecked exception thrown when an attempt is made to read from a channel that was not originally opened for reading.
    NonWritableChannelException | Unchecked exception thrown when an attempt is made to write to a channel that was not originally opened for writing.
    NotYetBoundException | Unchecked exception thrown when an attempt is made to invoke an I/O operation upon a server socket channel that is not yet bound.
    NotYetConnectedException | Unchecked exception thrown when an attempt is made to invoke an I/O operation upon a socket channel that is not yet connected.
    OverlappingFileLockException | Unchecked exception thrown when an attempt is made to acquire a lock on a region of a file that overlaps a region already locked by the same Java virtual machine, or when another thread is already waiting to lock an overlapping region of the same file.
    ReadPendingException | Unchecked exception thrown when an attempt is made to read from an asynchronous socket channel and a previous read has not completed.
    ShutdownChannelGroupException | Unchecked exception thrown when an attempt is made to construct a channel in a group that is shutdown or the completion handler for an I/O operation cannot be invoked because the channel group has terminated.
    UnresolvedAddressException | Unchecked exception thrown when an attempt is made to invoke a network operation upon an unresolved socket address.
    UnsupportedAddressTypeException | Unchecked exception thrown when an attempt is made to bind or connect to a socket address of a type that is not supported.
    WritePendingException | Unchecked exception thrown when an attempt is made to write to an asynchronous socket channel and a previous write has not completed.

  - ### java.nio.channels.spi

    Class Summary
    Class | Description
    --- | ---
    AbstractInterruptibleChannel | Base implementation class for interruptible channels.
    AbstractSelectableChannel | Base implementation class for selectable channels.
    AbstractSelectionKey | Base implementation class for selection keys.
    AbstractSelector | Base implementation class for selectors.
    AsynchronousChannelProvider | Service-provider class for asynchronous channels.
    SelectorProvider | Service-provider class for selectors and selectable channels.

  - ### java.nio.charset

    Class Summary
    Class | Description
    --- | ---
    Charset | A named mapping between sequences of sixteen-bit Unicode code units and sequences of bytes.
    CharsetDecoder | An engine that can transform a sequence of bytes in a specific charset into a sequence of sixteen-bit Unicode characters.
    CharsetEncoder | An engine that can transform a sequence of sixteen-bit Unicode characters into a sequence of bytes in a specific charset.
    CoderResult | A description of the result state of a coder.
    CodingErrorAction | A typesafe enumeration for coding-error actions.
    StandardCharsets | Constant definitions for the standard `Charsets`.

    Exception Summary
    Exception | Description
    --- | ---
    CharacterCodingException | Checked exception thrown when a character encoding or decoding error occurs.
    IllegalCharsetNameException | Unchecked exception thrown when a string that is not a legal charset name is used as such.
    MalformedInputException | Checked exception thrown when an input byte sequence is not legal for given charset, or an input character sequence is not a legal sixteen-bit Unicode sequence.
    UnmappableCharacterException | Checked exception thrown when an input character (or byte) sequence is valid but cannot be mapped to an output byte (or character) sequence.
    UnsupportedCharsetException | Unchecked exception thrown when no support is available for a requested charset.

    Error Summary
    Error | Description
    --- | ---
    CoderMalfunctionError | Error thrown when the `decodeLoop` method of a `CharsetDecoder`, or the `encodeLoop` method of a `CharsetEncoder`, throws an unexpected exception.

  - ### java.nio.charset.spi

    Class Summary
    Class | Description
    --- | ---
    CharsetProvider | Charset service-provider class.

  - ### java.nio.file

    Interface Summary
    Interface | Description
    --- | ---
    CopyOption | An object that configures how to copy or move a file.
    DirectoryStream<T> | An object to iterate over the entries in a directory.
    DirectoryStream.Filter<T> | An interface that is implemented by objects that decide if a directory entry should be accepted or filtered.
    FileVisitor<T> | A visitor of files.
    OpenOption | An object that configures how to open or create a file.
    Path | An object that may be used to locate a file in a file system.
    PathMatcher | An interface that is implemented by objects that perform match operations on paths.
    SecureDirectoryStream<T> | A `DirectoryStream` that defines operations on files that are located relative to an open directory.
    Watchable | An object that may be registered with a watch service so that it can be watched for changes and events.
    WatchEvent<T> | An event or a repeated event for an object that is registered with a `WatchService`.
    WatchEvent.Kind<T> | An event kind, for the purposes of identification.
    WatchEvent.Modifier | An event modifier that qualifies how a `Watchable` is registered with a `WatchService`.
    WatchKey | A token representing the registration of a `watchable` object with a `WatchService`.
    WatchService | A watch service that watches registered objects for changes and events.

    Class Summary
    Class | Description
    --- | ---
    Files | This class consists exclusively of static methods that operate on files, directories, or other types of files.
    FileStore | Storage for files.
    FileSystem | Provides an interface to a file system and is the factory for objects to access files and other objects in the file system.
    FileSystems | Factory methods for file systems.
    LinkPermission | The `Permission` class for link creation operations.
    Paths | This class consists exclusively of static methods that return a `Path` by converting a path string or `URI`.
    SimpleFileVisitor<T> | A simple visitor of files with default behavior to visit all files and to re-throw I/O errors.
    StandardWatchEventKinds | Defines the standard event kinds.

    Enum Summary
    Enum | Description
    --- | ---
    AccessMode | Defines access modes used to test the accessibility of a file.
    FileVisitOption | Defines the file tree traversal options.
    FileVisitResult | The result type of a `FileVisitor`.
    LinkOption | Defines the options as to how symbolic links are handled.
    StandardCopyOption | Defines the standard copy options.
    StandardOpenOption | Defines the standard open options.

    Exception Summary
    Exception | Description
    --- | ---
    AccessDeniedException | Checked exception thrown when a file system operation is denied, typically due to a file permission or other access check.
    AtomicMoveNotSupportedException | Checked exception thrown when a file cannot be moved as an atomic file system operation.
    ClosedDirectoryStreamException | Unchecked exception thrown when an attempt is made to invoke an operation on a directory stream that is closed.
    ClosedFileSystemException | Unchecked exception thrown when an attempt is made to invoke an operation on a file and the file system is closed.
    ClosedWatchServiceException | Unchecked exception thrown when an attempt is made to invoke an operation on a watch service that is closed.
    DirectoryIteratorException | Runtime exception thrown if an I/O error is encountered when iterating over the entries in a directory.
    DirectoryNotEmptyException | Checked exception thrown when a file system operation fails because a directory is not empty.
    FileAlreadyExistsException | Checked exception thrown when an attempt is made to create a file or directory and a file of that name already exists.
    FileSystemAlreadyExistsException | Runtime exception thrown when an attempt is made to create a file system that already exists.
    FileSystemException | Thrown when a file system operation fails on one or two files.
    FileSystemLoopException | Checked exception thrown when a file system loop, or cycle, is encountered.
    FileSystemNotFoundException | Runtime exception thrown when a file system cannot be found.
    InvalidPathException | Unchecked exception thrown when path string cannot be converted into a `Path` because the path string contains invalid characters, or the path string is invalid for other file system specific reasons.
    NoSuchFileException | Checked exception thrown when an attempt is made to access a file that does not exist.
    NotDirectoryException | Checked exception thrown when a file system operation, intended for a directory, fails because the file is not a directory.
    NotLinkException | Checked exception thrown when a file system operation fails because a file is not a symbolic link.
    ProviderMismatchException | Unchecked exception thrown when an attempt is made to invoke a method on an object created by one file system provider with a parameter created by a different file system provider.
    ProviderNotFoundException | Runtime exception thrown when a provider of the required type cannot be found.
    ReadOnlyFileSystemException | Unchecked exception thrown when an attempt is made to update an object associated with a `read-only` `FileSystem`.

  - ### java.nio.file.attribute

    Interface Summary
    Interface | Description
    --- | ---
    AclFileAttributeView | A file attribute view that supports reading or updating a file's Access Control Lists (ACL) or file owner attributes.
    AttributeView | An object that provides a read-only or updatable view of non-opaque values associated with an object in a filesystem.
    BasicFileAttributes | Basic attributes associated with a file in a file system.
    BasicFileAttributeView | A file attribute view that provides a view of a basic set of file attributes common to many file systems.
    DosFileAttributes | File attributes associated with a file in a file system that supports legacy "DOS" attributes.
    DosFileAttributeView | A file attribute view that provides a view of the legacy "DOS" file attributes.
    FileAttribute<T> | An object that encapsulates the value of a file attribute that can be set atomically when creating a new file or directory by invoking the `createFile` or `createDirectory` methods.
    FileAttributeView | An attribute view that is a read-only or updatable view of non-opaque values associated with a file in a filesystem.
    FileOwnerAttributeView | A file attribute view that supports reading or updating the owner of a file.
    FileStoreAttributeView | An attribute view that is a read-only or updatable view of the attributes of a `FileStore`.
    GroupPrincipal | A `UserPrincipal` representing a group identity, used to determine access rights to objects in a file system.
    PosixFileAttributes | File attributes associated with files on file systems used by operating systems that implement the Portable Operating System Interface (POSIX) family of standards.
    PosixFileAttributeView | A file attribute view that provides a view of the file attributes commonly associated with files on file systems used by operating systems that implement the Portable Operating System Interface (POSIX) family of standards.
    UserDefinedFileAttributeView | A file attribute view that provides a view of a file's user-defined attributes, sometimes known as extended attributes.
    UserPrincipal | A `Principal` representing an identity used to determine access rights to objects in a file system.

    Class Summary
    Class | Description
    --- | ---
    AclEntry | An entry in an access control list (ACL).
    AclEntry.Builder | A builder of `AclEntry` objects.
    FileTime | Represents the value of a file's time stamp attribute.
    PosixFilePermissions | This class consists exclusively of static methods that operate on sets of `PosixFilePermission` objects.
    UserPrincipalLookupService | An object to lookup user and group principals by name.

    Enum Summary
    Enum | Description
    --- | ---
    AclEntryFlag | Defines the flags for used by the flags component of an ACL `entry`.
    AclEntryPermission | Defines the permissions for use with the permissions component of an ACL `entry`.
    AclEntryType | A typesafe enumeration of the access control entry types.
    PosixFilePermission | Defines the bits for use with the `permissions` attribute.

    Exception Summary
    Exception | Description
    --- | ---
    UserPrincipalNotFoundException | Checked exception thrown when a lookup of `UserPrincipal` fails because the principal does not exist.

  - ### java.nio.file.spi

    Class Summary
    Class | Description
    --- | ---
    FileSystemProvider | Service-provider class for file systems.
    FileTypeDetector | A file type detector for probing a file to guess its file type.

  - ### java.security

    Interface Summary
    Interface | Description
    --- | ---
    AlgorithmConstraints | This interface specifies constraints for cryptographic algorithms, keys (key sizes), and other algorithm parameters.
    Certificate | Deprecated A new certificate handling package is created in the Java platform.
    DomainCombiner | A `DomainCombiner` provides a means to dynamically update the ProtectionDomains associated with the current `AccessControlContext`.
    Guard | This interface represents a guard, which is an object that is used to protect access to another object.
    Key | The Key interface is the top-level interface for all keys.
    KeyStore.Entry | A marker interface for `KeyStore` entry types.
    KeyStore.Entry.Attribute | An attribute associated with a keystore entry.
    KeyStore.LoadStoreParameter | A marker interface for `KeyStore` `load` and `store` parameters.
    KeyStore.ProtectionParameter | A marker interface for keystore protection parameters.
    Policy.Parameters | This represents a marker interface for Policy parameters.
    Principal | This interface represents the abstract notion of a principal, which can be used to represent any entity, such as an individual, a corporation, and a login id.
    PrivateKey | A private key.
    PrivilegedAction<T> | A computation to be performed with privileges enabled.
    PrivilegedExceptionAction<T> | A computation to be performed with privileges enabled, that throws one or more checked exceptions.
    PublicKey | A public key.

    Class Summary
    Class | Description
    --- | ---
    AccessControlContext | An AccessControlContext is used to make system resource access decisions based on the context it encapsulates.
    AccessController | The AccessController class is used for access control operations and decisions.
    AlgorithmParameterGenerator | The `AlgorithmParameterGenerator` class is used to generate a set of parameters to be used with a certain algorithm.
    AlgorithmParameterGeneratorSpi | This class defines the Service Provider Interface (SPI) for the `AlgorithmParameterGenerator` class, which is used to generate a set of parameters to be used with a certain algorithm.
    AlgorithmParameters | This class is used as an opaque representation of cryptographic parameters.
    AlgorithmParametersSpi | This class defines the Service Provider Interface (SPI) for the `AlgorithmParameters` class, which is used to manage algorithm parameters.
    AllPermission | The AllPermission is a permission that implies all other permissions.
    AuthProvider | This class defines login and logout methods for a provider.
    BasicPermission | The BasicPermission class extends the Permission class, and can be used as the base class for permissions that want to follow the same naming convention as BasicPermission.
    CodeSigner | This class encapsulates information about a code signer.
    CodeSource | This class extends the concept of a codebase to encapsulate not only the location (URL) but also the certificate chains that were used to verify signed code originating from that location.
    DigestInputStream | A transparent stream that updates the associated message digest using the bits going through the stream.
    DigestOutputStream | A transparent stream that updates the associated message digest using the bits going through the stream.
    DomainLoadStoreParameter | Configuration data that specifies the keystores in a keystore domain.
    GuardedObject | A GuardedObject is an object that is used to protect access to another object.
    Identity | Deprecated This class is no longer used.
    IdentityScope | Deprecated This class is no longer used.
    KeyFactory | Key factories are used to convert keys (opaque cryptographic keys of type `Key`) into key specifications (transparent representations of the underlying key material), and vice versa.
    KeyFactorySpi | This class defines the Service Provider Interface (SPI) for the `KeyFactory` class.
    KeyPair | This class is a simple holder for a key pair (a public key and a private key).
    KeyPairGenerator | The KeyPairGenerator class is used to generate pairs of public and private keys.
    KeyPairGeneratorSpi | This class defines the Service Provider Interface (SPI) for the `KeyPairGenerator` class, which is used to generate pairs of public and private keys.
    KeyRep | Standardized representation for serialized Key objects.
    KeyStore | This class represents a storage facility for cryptographic keys and certificates.
    KeyStore.Builder | A description of a to-be-instantiated KeyStore object.
    KeyStore.CallbackHandlerProtection | A ProtectionParameter encapsulating a CallbackHandler.
    KeyStore.PasswordProtection | A password-based implementation of `ProtectionParameter`.
    KeyStore.PrivateKeyEntry | A `KeyStore` entry that holds a `PrivateKey` and corresponding certificate chain.
    KeyStore.SecretKeyEntry | A `KeyStore` entry that holds a `SecretKey`.
    KeyStore.TrustedCertificateEntry | A `KeyStore` entry that holds a trusted `Certificate`.
    KeyStoreSpi | This class defines the Service Provider Interface (SPI) for the `KeyStore` class.
    MessageDigest | This MessageDigest class provides applications the functionality of a message digest algorithm, such as SHA-1 or SHA-256.
    MessageDigestSpi | This class defines the Service Provider Interface (SPI) for the `MessageDigest` class, which provides the functionality of a message digest algorithm, such as MD5 or SHA.
    Permission | Abstract class for representing access to a system resource.
    PermissionCollection | Abstract class representing a collection of Permission objects.
    Permissions | This class represents a heterogeneous collection of Permissions.
    PKCS12Attribute | An attribute associated with a PKCS12 keystore entry.
    Policy | A Policy object is responsible for determining whether code executing in the Java runtime environment has permission to perform a security-sensitive operation.
    PolicySpi | This class defines the Service Provider Interface (SPI) for the `Policy` class.
    ProtectionDomain | The ProtectionDomain class encapsulates the characteristics of a domain, which encloses a set of classes whose instances are granted a set of permissions when being executed on behalf of a given set of Principals.
    Provider | This class represents a "provider" for the Java Security API, where a provider implements some or all parts of Java Security.
    Provider.Service | The description of a security service.
    SecureClassLoader | This class extends ClassLoader with additional support for defining classes with an associated code source and permissions which are retrieved by the system policy by default.
    SecureRandom | This class provides a cryptographically strong random number generator (RNG).
    SecureRandomSpi | This class defines the Service Provider Interface (SPI) for the `SecureRandom` class.
    Security | This class centralizes all security properties and common security methods.
    SecurityPermission | This class is for security permissions.
    Signature | The Signature class is used to provide applications the functionality of a digital signature algorithm.
    SignatureSpi | This class defines the Service Provider Interface (SPI) for the `Signature` class, which is used to provide the functionality of a digital signature algorithm.
    SignedObject | SignedObject is a class for the purpose of creating authentic runtime objects whose integrity cannot be compromised without being detected.
    Signer | Deprecated This class is no longer used.
    Timestamp | This class encapsulates information about a signed timestamp.
    UnresolvedPermission | The UnresolvedPermission class is used to hold Permissions that were "unresolved" when the Policy was initialized.
    URIParameter | A parameter that contains a URI pointing to data intended for a PolicySpi or ConfigurationSpi implementation.

    Enum Summary
    Enum | Description
    --- | ---
    CryptoPrimitive | An enumeration of cryptographic primitives.
    KeyRep.Type | Key type.

    Exception Summary
    Exception | Description
    --- | ---
    AccessControlException | This exception is thrown by the AccessController to indicate that a requested access (to a critical system resource such as the file system or the network) is denied.
    DigestException | This is the generic Message Digest exception.
    GeneralSecurityException | The `GeneralSecurityException` class is a generic security exception class that provides type safety for all the security-related exception classes that extend from it.
    InvalidAlgorithmParameterException | This is the exception for invalid or inappropriate algorithm parameters.
    InvalidKeyException | This is the exception for invalid Keys (invalid encoding, wrong length, uninitialized, etc).
    InvalidParameterException | This exception, designed for use by the JCA/JCE engine classes, is thrown when an invalid parameter is passed to a method.
    KeyException | This is the basic key exception.
    KeyManagementException | This is the general key management exception for all operations dealing with key management.
    KeyStoreException | This is the generic KeyStore exception.
    NoSuchAlgorithmException | This exception is thrown when a particular cryptographic algorithm is requested but is not available in the environment.
    NoSuchProviderException | This exception is thrown when a particular security provider is requested but is not available in the environment.
    PrivilegedActionException | This exception is thrown by `doPrivileged(PrivilegedExceptionAction)` and `doPrivileged(PrivilegedExceptionAction, AccessControlContext context)` to indicate that the action being performed threw a checked exception.
    ProviderException | A runtime exception for Provider exceptions (such as misconfiguration errors or unrecoverable internal errors), which may be subclassed by Providers to throw specialized, provider-specific runtime errors.
    SignatureException | This is the generic Signature exception.
    UnrecoverableEntryException | This exception is thrown if an entry in the keystore cannot be recovered.
    UnrecoverableKeyException | This exception is thrown if a key in the keystore cannot be recovered.

  - ### java.security.cert

    Interface Summary
    Interface | Description
    --- | ---
    CertPathBuilderResult | A specification of the result of a certification path builder algorithm.
    CertPathChecker | Performs one or more checks on each `Certificate` of a `CertPath`.
    CertPathParameters | A specification of certification path algorithm parameters.
    CertPathValidatorException.Reason | The reason the validation algorithm failed.
    CertPathValidatorResult | A specification of the result of a certification path validator algorithm.
    CertSelector | A selector that defines a set of criteria for selecting `Certificate`s.
    CertStoreParameters | A specification of `CertStore` parameters.
    CRLSelector | A selector that defines a set of criteria for selecting `CRL`s.
    Extension | This interface represents an X.509 extension.
    PolicyNode | An immutable valid policy tree node as defined by the PKIX certification path validation algorithm.
    X509Extension | Interface for an X.509 extension.

    Class Summary
    Class | Description
    --- | ---
    Certificate | Abstract class for managing a variety of identity certificates.
    Certificate.CertificateRep | Alternate Certificate class for serialization.
    CertificateFactory | This class defines the functionality of a certificate factory, which is used to generate certificate, certification path (`CertPath`) and certificate revocation list (CRL) objects from their encodings.
    CertificateFactorySpi | This class defines the Service Provider Interface (SPI) for the `CertificateFactory` class.
    CertPath | An immutable sequence of certificates (a certification path).
    CertPath.CertPathRep | Alternate `CertPath` class for serialization.
    CertPathBuilder | A class for building certification paths (also known as certificate chains).
    CertPathBuilderSpi | The Service Provider Interface (SPI) for the `CertPathBuilder` class.
    CertPathValidator | A class for validating certification paths (also known as certificate chains).
    CertPathValidatorSpi | The Service Provider Interface (SPI) for the `CertPathValidator` class.
    CertStore | A class for retrieving `Certificate`s and `CRL`s from a repository.
    CertStoreSpi | The Service Provider Interface (SPI) for the `CertStore` class.
    CollectionCertStoreParameters | Parameters used as input for the Collection `CertStore` algorithm.
    CRL | This class is an abstraction of certificate revocation lists (CRLs) that have different formats but important common uses.
    LDAPCertStoreParameters | Parameters used as input for the LDAP `CertStore` algorithm.
    PKIXBuilderParameters | Parameters used as input for the PKIX `CertPathBuilder` algorithm.
    PKIXCertPathBuilderResult | This class represents the successful result of the PKIX certification path builder algorithm.
    PKIXCertPathChecker | An abstract class that performs one or more checks on an `X509Certificate`.
    PKIXCertPathValidatorResult | This class represents the successful result of the PKIX certification path validation algorithm.
    PKIXParameters | Parameters used as input for the PKIX `CertPathValidator` algorithm.
    PKIXRevocationChecker | A `PKIXCertPathChecker` for checking the revocation status of certificates with the PKIX algorithm.
    PolicyQualifierInfo | An immutable policy qualifier represented by the ASN.1 PolicyQualifierInfo structure.
    TrustAnchor | A trust anchor or most-trusted Certification Authority (CA).
    X509Certificate | Abstract class for X.509 certificates.
    X509CertSelector | A `CertSelector` that selects `X509Certificates` that match all specified criteria.
    X509CRL | Abstract class for an X.509 Certificate Revocation List (CRL).
    X509CRLEntry | Abstract class for a revoked certificate in a CRL (Certificate Revocation List).
    X509CRLSelector | A `CRLSelector` that selects `X509CRLs` that match all specified criteria.

    Enum Summary
    Enum | Description
    --- | ---
    CertPathValidatorException.BasicReason | The BasicReason enumerates the potential reasons that a certification path of any type may be invalid.
    CRLReason | The CRLReason enumeration specifies the reason that a certificate is revoked, as defined in RFC 5280: Internet X.509 Public Key Infrastructure Certificate and CRL Profile.
    PKIXReason | The `PKIXReason` enumerates the potential PKIX-specific reasons that an X.509 certification path may be invalid according to the PKIX (RFC 5280) standard.
    PKIXRevocationChecker.Option | Various revocation options that can be specified for the revocation checking mechanism.

    Exception Summary
    Exception | Description
    --- | ---
    CertificateEncodingException | Certificate Encoding Exception.
    CertificateException | This exception indicates one of a variety of certificate problems.
    CertificateExpiredException | Certificate Expired Exception.
    CertificateNotYetValidException | Certificate is not yet valid exception.
    CertificateParsingException | Certificate Parsing Exception.
    CertificateRevokedException | An exception that indicates an X.509 certificate is revoked.
    CertPathBuilderException | An exception indicating one of a variety of problems encountered when building a certification path with a `CertPathBuilder`.
    CertPathValidatorException | An exception indicating one of a variety of problems encountered when validating a certification path.
    CertStoreException | An exception indicating one of a variety of problems retrieving certificates and CRLs from a `CertStore`.
    CRLException | CRL (Certificate Revocation List) Exception.

  - ### java.security.interfaces

    Interface Summary
    Interface | Description
    --- | ---
    DSAKey | The interface to a DSA public or private key.
    DSAKeyPairGenerator | An interface to an object capable of generating DSA key pairs.
    DSAParams | Interface to a DSA-specific set of key parameters, which defines a DSA key family.
    DSAPrivateKey | The standard interface to a DSA private key.
    DSAPublicKey | The interface to a DSA public key.
    ECKey | The interface to an elliptic curve (EC) key.
    ECPrivateKey | The interface to an elliptic curve (EC) private key.
    ECPublicKey | The interface to an elliptic curve (EC) public key.
    RSAKey | The interface to a public or private key in PKCS#1 v2.2 standard, such as those for RSA, or RSASSA-PSS algorithms.
    RSAMultiPrimePrivateCrtKey | The interface to an RSA multi-prime private key, as defined in the PKCS#1 v2.2 standard, using the Chinese Remainder Theorem (CRT) information values.
    RSAPrivateCrtKey | The interface to an RSA private key, as defined in the PKCS#1 v2.2 standard, using the Chinese Remainder Theorem (CRT) information values.
    RSAPrivateKey | The interface to an RSA private key.
    RSAPublicKey | The interface to an RSA public key.

  - ### java.security.spec

    Interface Summary
    Interface | Description
    --- | ---
    AlgorithmParameterSpec | A (transparent) specification of cryptographic parameters.
    ECField | This interface represents an elliptic curve (EC) finite field.
    KeySpec | A (transparent) specification of the key material that constitutes a cryptographic key.

    Class Summary
    Class | Description
    --- | ---
    DSAGenParameterSpec | This immutable class specifies the set of parameters used for generating DSA parameters as specified in FIPS 186-3 Digital Signature Standard (DSS).
    DSAParameterSpec | This class specifies the set of parameters used with the DSA algorithm.
    DSAPrivateKeySpec | This class specifies a DSA private key with its associated parameters.
    DSAPublicKeySpec | This class specifies a DSA public key with its associated parameters.
    ECFieldF2m | This immutable class defines an elliptic curve (EC) characteristic 2 finite field.
    ECFieldFp | This immutable class defines an elliptic curve (EC) prime finite field.
    ECGenParameterSpec | This immutable class specifies the set of parameters used for generating elliptic curve (EC) domain parameters.
    ECParameterSpec | This immutable class specifies the set of domain parameters used with elliptic curve cryptography (ECC).
    ECPoint | This immutable class represents a point on an elliptic curve (EC) in affine coordinates.
    ECPrivateKeySpec | This immutable class specifies an elliptic curve private key with its associated parameters.
    ECPublicKeySpec | This immutable class specifies an elliptic curve public key with its associated parameters.
    EllipticCurve | This immutable class holds the necessary values needed to represent an elliptic curve.
    EncodedKeySpec | This class represents a public or private key in encoded format.
    MGF1ParameterSpec | This class specifies the set of parameters used with mask generation function MGF1 in OAEP Padding and RSASSA-PSS signature scheme, as defined in the PKCS#1 v2.2 standard.
    PKCS8EncodedKeySpec | This class represents the ASN.1 encoding of a private key, encoded according to the ASN.1 type `PrivateKeyInfo`.
    PSSParameterSpec | This class specifies a parameter spec for RSASSA-PSS signature scheme, as defined in the PKCS#1 v2.2 standard.
    RSAKeyGenParameterSpec | This class specifies the set of parameters used to generate an RSA key pair.
    RSAMultiPrimePrivateCrtKeySpec | This class specifies an RSA multi-prime private key, as defined in the PKCS#1 v2.2 standard using the Chinese Remainder Theorem (CRT) information values for efficiency.
    RSAOtherPrimeInfo | This class represents the triplet (prime, exponent, and coefficient) inside RSA's OtherPrimeInfo structure, as defined in the PKCS#1 v2.2 standard.
    RSAPrivateCrtKeySpec | This class specifies an RSA private key, as defined in the PKCS#1 v2.2 standard, using the Chinese Remainder Theorem (CRT) information values for efficiency.
    RSAPrivateKeySpec | This class specifies an RSA private key.
    RSAPublicKeySpec | This class specifies an RSA public key.
    X509EncodedKeySpec | This class represents the ASN.1 encoding of a public key, encoded according to the ASN.1 type `SubjectPublicKeyInfo`.

    Exception Summary
    Exception | Description
    --- | ---
    InvalidKeySpecException | This is the exception for invalid key specifications.
    InvalidParameterSpecException | This is the exception for invalid parameter specifications.

  - ### java.text

    Interface Summary
    Interface | Description
    --- | ---
    AttributedCharacterIterator | An `AttributedCharacterIterator` allows iteration through both text and related attribute information.
    CharacterIterator | This interface defines a protocol for bidirectional iteration over text.

    Class Summary
    Class | Description
    --- | ---
    Annotation | An Annotation object is used as a wrapper for a text attribute value if the attribute has annotation characteristics.
    AttributedCharacterIterator.Attribute | Defines attribute keys that are used to identify text attributes.
    AttributedString | An AttributedString holds text and related attribute information.
    Bidi | This class implements the Unicode Bidirectional Algorithm.
    BreakIterator | The `BreakIterator` class implements methods for finding the location of boundaries in text.
    ChoiceFormat | A `ChoiceFormat` allows you to attach a format to a range of numbers.
    CollationElementIterator | The `CollationElementIterator` class is used as an iterator to walk through each character of an international string.
    CollationKey | A `CollationKey` represents a `String` under the rules of a specific `Collator` object.
    Collator | The `Collator` class performs locale-sensitive `String` comparison.
    DateFormat | `DateFormat` is an abstract class for date/time formatting subclasses which formats and parses dates or time in a language-independent manner.
    DateFormat.Field | Defines constants that are used as attribute keys in the `AttributedCharacterIterator` returned from `DateFormat.formatToCharacterIterator` and as field identifiers in `FieldPosition`.
    DateFormatSymbols | `DateFormatSymbols` is a public class for encapsulating localizable date-time formatting data, such as the names of the months, the names of the days of the week, and the time zone data.
    DecimalFormat | `DecimalFormat` is a concrete subclass of `NumberFormat` that formats decimal numbers.
    DecimalFormatSymbols | This class represents the set of symbols (such as the decimal separator, the grouping separator, and so on) needed by `DecimalFormat` to format numbers.
    FieldPosition | `FieldPosition` is a simple class used by `Format` and its subclasses to identify fields in formatted output.
    Format | `Format` is an abstract base class for formatting locale-sensitive information such as dates, messages, and numbers.
    Format.Field | Defines constants that are used as attribute keys in the `AttributedCharacterIterator` returned from `Format.formatToCharacterIterator` and as field identifiers in `FieldPosition`.
    MessageFormat | `MessageFormat` provides a means to produce concatenated messages in a language-neutral way.
    MessageFormat.Field | Defines constants that are used as attribute keys in the `AttributedCharacterIterator` returned from `MessageFormat.formatToCharacterIterator`.
    Normalizer | This class provides the method `normalize` which transforms Unicode text into an equivalent composed or decomposed form, allowing for easier sorting and searching of text.
    NumberFormat | `NumberFormat` is the abstract base class for all number formats.
    NumberFormat.Field | Defines constants that are used as attribute keys in the `AttributedCharacterIterator` returned from `NumberFormat.formatToCharacterIterator` and as field identifiers in `FieldPosition`.
    ParsePosition | `ParsePosition` is a simple class used by `Format` and its subclasses to keep track of the current position during parsing.
    RuleBasedCollator | The `RuleBasedCollator` class is a concrete subclass of `Collator` that provides a simple, data-driven, table collator.
    SimpleDateFormat | `SimpleDateFormat` is a concrete class for formatting and parsing dates in a locale-sensitive manner.
    StringCharacterIterator | `StringCharacterIterator` implements the `CharacterIterator` protocol for a `String`.

    Enum Summary
    Enum | Description
    --- | ---
    Normalizer.Form | This enum provides constants of the four Unicode normalization forms that are described in Unicode Standard Annex #15 — Unicode Normalization Forms and two methods to access them.

    Exception Summary
    Exception | Description
    --- | ---
    ParseException | Signals that an error has been reached unexpectedly while parsing.

  - ### java.text.spi

    Class Summary
    Class | Description
    --- | ---
    BreakIteratorProvider | An abstract class for service providers that provide concrete implementations of the `BreakIterator` class.
    CollatorProvider | An abstract class for service providers that provide concrete implementations of the `Collator` class.
    DateFormatProvider | An abstract class for service providers that provide concrete implementations of the `DateFormat` class.
    DateFormatSymbolsProvider | An abstract class for service providers that provide instances of the `DateFormatSymbols` class.
    DecimalFormatSymbolsProvider | An abstract class for service providers that provide instances of the `DecimalFormatSymbols` class.
    NumberFormatProvider | An abstract class for service providers that provide concrete implementations of the `NumberFormat` class.

  - ### java.time

    Class Summary
    Class | Description
    --- | ---
    Clock | A clock providing access to the current instant, date and time using a time-zone.
    Duration | A time-based amount of time, such as '34.5 seconds'.
    Instant | An instantaneous point on the time-line.
    LocalDate | A date without a time-zone in the ISO-8601 calendar system, such as `2007-12-03`.
    LocalDateTime | A date-time without a time-zone in the ISO-8601 calendar system, such as `2007-12-03T10:15:30`.
    LocalTime | A time without a time-zone in the ISO-8601 calendar system, such as `10:15:30`.
    MonthDay | A month-day in the ISO-8601 calendar system, such as `--12-03`.
    OffsetDateTime | A date-time with an offset from UTC/Greenwich in the ISO-8601 calendar system, such as `2007-12-03T10:15:30+01:00`.
    OffsetTime | A time with an offset from UTC/Greenwich in the ISO-8601 calendar system, such as `10:15:30+01:00`.
    Period | A date-based amount of time in the ISO-8601 calendar system, such as '2 years, 3 months and 4 days'.
    Year | A year in the ISO-8601 calendar system, such as `2007`.
    YearMonth | A year-month in the ISO-8601 calendar system, such as `2007-12`.
    ZonedDateTime | A date-time with a time-zone in the ISO-8601 calendar system, such as `2007-12-03T10:15:30+01:00 Europe/Paris`.
    ZoneId | A time-zone ID, such as `Europe/Paris`.
    ZoneOffset | A time-zone offset from Greenwich/UTC, such as `+02:00`.

    Enum Summary
    Enum | Description
    --- | ---
    DayOfWeek | A day-of-week, such as 'Tuesday'.
    Month | A month-of-year, such as 'July'.

    Exception Summary
    Exception | Description
    --- | ---
    DateTimeException | Exception used to indicate a problem while calculating a date-time.

  - ### java.time.chrono

    Interface Summary
    Interface | Description
    --- | ---
    ChronoLocalDate | A date without time-of-day or time-zone in an arbitrary chronology, intended for advanced globalization use cases.
    ChronoLocalDateTime<D extends ChronoLocalDate> | A date-time without a time-zone in an arbitrary chronology, intended for advanced globalization use cases.
    Chronology | A calendar system, used to organize and identify dates.
    ChronoPeriod | A date-based amount of time, such as '3 years, 4 months and 5 days' in an arbitrary chronology, intended for advanced globalization use cases.
    ChronoZonedDateTime<D extends ChronoLocalDate> | A date-time with a time-zone in an arbitrary chronology, intended for advanced globalization use cases.
    Era | An era of the time-line.

    Class Summary
    Class | Description
    --- | ---
    AbstractChronology | An abstract implementation of a calendar system, used to organize and identify dates.
    HijrahChronology | The Hijrah calendar is a lunar calendar supporting Islamic calendars.
    HijrahDate | A date in the Hijrah calendar system.
    IsoChronology | The ISO calendar system.
    JapaneseChronology | The Japanese Imperial calendar system.
    JapaneseDate | A date in the Japanese Imperial calendar system.
    JapaneseEra | An era in the Japanese Imperial calendar system.
    MinguoChronology | The Minguo calendar system.
    MinguoDate | A date in the Minguo calendar system.
    ThaiBuddhistChronology | The Thai Buddhist calendar system.
    ThaiBuddhistDate | A date in the Thai Buddhist calendar system.

    Enum Summary
    Enum | Description
    --- | ---
    HijrahEra | An era in the Hijrah calendar system.
    IsoEra | An era in the ISO calendar system.
    MinguoEra | An era in the Minguo calendar system.
    ThaiBuddhistEra | An era in the Thai Buddhist calendar system.

  - ### java.time.format

    Class Summary
    Class | Description
    --- | ---
    DateTimeFormatter | Formatter for printing and parsing date-time objects.
    DateTimeFormatterBuilder | Builder to create date-time formatters.
    DecimalStyle | Localized decimal style used in date and time formatting.

    Enum Summary
    Enum | Description
    --- | ---
    FormatStyle | Enumeration of the style of a localized date, time or date-time formatter.
    ResolverStyle | Enumeration of different ways to resolve dates and times.
    SignStyle | Enumeration of ways to handle the positive/negative sign.
    TextStyle | Enumeration of the style of text formatting and parsing.

    Exception Summary
    Exception | Description
    --- | ---
    DateTimeParseException | An exception thrown when an error occurs during parsing.

  - ### java.time.temporal

    Interface Summary
    Interface | Description
    --- | ---
    Temporal | Framework-level interface defining read-write access to a temporal object, such as a date, time, offset or some combination of these.
    TemporalAccessor | Framework-level interface defining read-only access to a temporal object, such as a date, time, offset or some combination of these.
    TemporalAdjuster | Strategy for adjusting a temporal object.
    TemporalAmount | Framework-level interface defining an amount of time, such as "6 hours", "8 days" or "2 years and 3 months".
    TemporalField | A field of date-time, such as month-of-year or hour-of-minute.
    TemporalQuery<R> | Strategy for querying a temporal object.
    TemporalUnit | A unit of date-time, such as Days or Hours.

    Class Summary
    Class | Description
    --- | ---
    IsoFields | Fields and units specific to the ISO-8601 calendar system, including quarter-of-year and week-based-year.
    JulianFields | A set of date fields that provide access to Julian Days.
    TemporalAdjusters | Common and useful TemporalAdjusters.
    TemporalQueries | Common implementations of `TemporalQuery`.
    ValueRange | The range of valid values for a date-time field.
    WeekFields | Localized definitions of the day-of-week, week-of-month and week-of-year fields.

    Enum Summary
    Enum | Description
    --- | ---
    ChronoField | A standard set of fields.
    ChronoUnit | A standard set of date periods units.

    Exception Summary
    Exception | Description
    --- | ---
    UnsupportedTemporalTypeException | UnsupportedTemporalTypeException indicates that a ChronoField or ChronoUnit is not supported for a Temporal class.

  - ### java.time.zone

    Class Summary
    Class | Description
    --- | ---
    ZoneOffsetTransition | A transition between two offsets caused by a discontinuity in the local time-line.
    ZoneOffsetTransitionRule | A rule expressing how to create a transition.
    ZoneRules | The rules defining how the zone offset varies for a single time-zone.
    ZoneRulesProvider | Provider of time-zone rules to the system.

    Enum Summary
    Enum | Description
    --- | ---
    ZoneOffsetTransitionRule.TimeDefinition | A definition of the way a local time can be converted to the actual transition date-time.

    Exception Summary
    Exception | Description
    --- | ---
    ZoneRulesException | Thrown to indicate a problem with time-zone configuration.

  - ### java.util

    Interface Summary
    Interface | Description
    --- | ---
    Collection<E> | The root interface in the collection hierarchy.
    Comparator<T> | A comparison function, which imposes a total ordering on some collection of objects.
    Deque<E> | A linear collection that supports element insertion and removal at both ends.
    Enumeration<E> | An object that implements the Enumeration interface generates a series of elements, one at a time.
    EventListener | A tagging interface that all event listener interfaces must extend.
    Formattable | The `Formattable` interface must be implemented by any class that needs to perform custom formatting using the `'s'` conversion specifier of `Formatter`.
    Iterator<E> | An iterator over a collection.
    List<E> | An ordered collection (also known as a sequence).
    ListIterator<E> | An iterator for lists that allows the programmer to traverse the list in either direction, modify the list during iteration, and obtain the iterator's current position in the list.
    Map<K,V> | An object that maps keys to values.
    Map.Entry<K,V> | A map entry (key-value pair).
    NavigableMap<K,V> | A `SortedMap` extended with navigation methods returning the closest matches for given search targets.
    NavigableSet<E> | A `SortedSet` extended with navigation methods reporting closest matches for given search targets.
    Observer | A class can implement the `Observer` interface when it wants to be informed of changes in observable objects.
    PrimitiveIterator<T,T_CONS> | A base type for primitive specializations of `Iterator`.
    PrimitiveIterator.OfDouble | An Iterator specialized for `double` values.
    PrimitiveIterator.OfInt | An Iterator specialized for `int` values.
    PrimitiveIterator.OfLong | An Iterator specialized for `long` values.
    Queue<E> | A collection designed for holding elements prior to processing.
    RandomAccess | Marker interface used by `List` implementations to indicate that they support fast (generally constant time) random access.
    Set<E> | A collection that contains no duplicate elements.
    SortedMap<K,V> | A `Map` that further provides a total ordering on its keys.
    SortedSet<E> | A `Set` that further provides a total ordering on its elements.
    Spliterator<T> | An object for traversing and partitioning elements of a source.
    Spliterator.OfDouble | A Spliterator specialized for `double` values.
    Spliterator.OfInt | A Spliterator specialized for `int` values.
    Spliterator.OfLong | A Spliterator specialized for `long` values.
    Spliterator.OfPrimitive<T,T_CONS,T_SPLITR extends Spliterator.OfPrimitive<T,T_CONS,T_SPLITR>> | A Spliterator specialized for primitive values.

    Class Summary
    Class | Description
    --- | ---
    AbstractCollection<E> | This class provides a skeletal implementation of the `Collection` interface, to minimize the effort required to implement this interface.
    AbstractList<E> | This class provides a skeletal implementation of the `List` interface to minimize the effort required to implement this interface backed by a "random access" data store (such as an array).
    AbstractMap<K,V> | This class provides a skeletal implementation of the `Map` interface, to minimize the effort required to implement this interface.
    AbstractMap.SimpleEntry<K,V> | An Entry maintaining a key and a value.
    AbstractMap.SimpleImmutableEntry<K,V> | An Entry maintaining an immutable key and value.
    AbstractQueue<E> | This class provides skeletal implementations of some `Queue` operations.
    AbstractSequentialList<E> | This class provides a skeletal implementation of the `List` interface to minimize the effort required to implement this interface backed by a "sequential access" data store (such as a linked list).
    AbstractSet<E> | This class provides a skeletal implementation of the `Set` interface to minimize the effort required to implement this interface.
    ArrayDeque<E> | Resizable-array implementation of the `Deque` interface.
    ArrayList<E> | Resizable-array implementation of the `List` interface.
    Arrays | This class contains various methods for manipulating arrays (such as sorting and searching).
    Base64 | This class consists exclusively of static methods for obtaining encoders and decoders for the Base64 encoding scheme.
    Base64.Decoder | This class implements a decoder for decoding byte data using the Base64 encoding scheme as specified in RFC 4648 and RFC 2045.
    Base64.Encoder | This class implements an encoder for encoding byte data using the Base64 encoding scheme as specified in RFC 4648 and RFC 2045.
    BitSet | This class implements a vector of bits that grows as needed.
    Calendar | The `Calendar` class is an abstract class that provides methods for converting between a specific instant in time and a set of `calendar fields` such as `YEAR`, `MONTH`, `DAY_OF_MONTH`, `HOUR`, and so on, and for manipulating the calendar fields, such as getting the date of the next week.
    Calendar.Builder | `Calendar.Builder` is used for creating a `Calendar` from various date-time parameters.
    Collections | This class consists exclusively of static methods that operate on or return collections.
    Currency | Represents a currency.
    Date | The class `Date` represents a specific instant in time, with millisecond precision.
    Dictionary<K,V> | The `Dictionary` class is the abstract parent of any class, such as `Hashtable`, which maps keys to values.
    DoubleSummaryStatistics | A state object for collecting statistics such as count, min, max, sum, and average.
    EnumMap<K extends Enum<K>,V> | A specialized `Map` implementation for use with enum type keys.
    EnumSet<E extends Enum<E>> | A specialized `Set` implementation for use with enum types.
    EventListenerProxy<T extends EventListener> | An abstract wrapper class for an `EventListener` class which associates a set of additional parameters with the listener.
    EventObject | The root class from which all event state objects shall be derived.
    FormattableFlags | FomattableFlags are passed to the `Formattable.formatTo()` method and modify the output format for Formattables.
    Formatter | An interpreter for printf-style format strings.
    GregorianCalendar | `GregorianCalendar` is a concrete subclass of `Calendar` and provides the standard calendar system used by most of the world.
    HashMap<K,V> | Hash table based implementation of the `Map` interface.
    HashSet<E> | This class implements the `Set` interface, backed by a hash table (actually a `HashMap` instance).
    Hashtable<K,V> | This class implements a hash table, which maps keys to values.
    IdentityHashMap<K,V> | This class implements the `Map` interface with a hash table, using reference-equality in place of object-equality when comparing keys (and values).
    IntSummaryStatistics | A state object for collecting statistics such as count, min, max, sum, and average.
    LinkedHashMap<K,V> | Hash table and linked list implementation of the `Map` interface, with predictable iteration order.
    LinkedHashSet<E> | Hash table and linked list implementation of the `Set` interface, with predictable iteration order.
    LinkedList<E> | Doubly-linked list implementation of the `List` and `Deque` interfaces.
    ListResourceBundle | `ListResourceBundle` is an abstract subclass of `ResourceBundle` that manages resources for a locale in a convenient and easy to use list.
    Locale | A `Locale` object represents a specific geographical, political, or cultural region.
    Locale.Builder | `Builder` is used to build instances of `Locale` from values configured by the setters.
    Locale.LanguageRange | This class expresses a Language Range defined in RFC 4647 Matching of Language Tags.
    LongSummaryStatistics | A state object for collecting statistics such as count, min, max, sum, and average.
    Objects | This class consists of `static` utility methods for operating on objects.
    Observable | This class represents an observable object, or "data" in the model-view paradigm.
    Optional<T> | A container object which may or may not contain a non-null value.
    OptionalDouble | A container object which may or may not contain a `double` value.
    OptionalInt | A container object which may or may not contain a `int` value.
    OptionalLong | A container object which may or may not contain a `long` value.
    PriorityQueue<E> | An unbounded priority queue based on a priority heap.
    Properties | The `Properties` class represents a persistent set of properties.
    PropertyPermission | This class is for property permissions.
    PropertyResourceBundle | `PropertyResourceBundle` is a concrete subclass of `ResourceBundle` that manages resources for a locale using a set of static strings from a property file.
    Random | An instance of this class is used to generate a stream of pseudorandom numbers.
    ResourceBundle | Resource bundles contain locale-specific objects.
    ResourceBundle.Control | `ResourceBundle.Control` defines a set of callback methods that are invoked by the `ResourceBundle.getBundle` factory methods during the bundle loading process.
    Scanner | A simple text scanner which can parse primitive types and strings using regular expressions.
    ServiceLoader<S> | A simple service-provider loading facility.
    SimpleTimeZone | `SimpleTimeZone` is a concrete subclass of `TimeZone` that represents a time zone for use with a Gregorian calendar.
    Spliterators | Static classes and methods for operating on or creating instances of `Spliterator` and its primitive specializations `Spliterator.OfInt`, `Spliterator.OfLong`, and `Spliterator.OfDouble`.
    Spliterators.AbstractDoubleSpliterator | An abstract `Spliterator.OfDouble` that implements `trySplit` to permit limited parallelism.
    Spliterators.AbstractIntSpliterator | An abstract `Spliterator.OfInt` that implements `trySplit` to permit limited parallelism.
    Spliterators.AbstractLongSpliterator | An abstract `Spliterator.OfLong` that implements `trySplit` to permit limited parallelism.
    Spliterators.AbstractSpliterator<T> | An abstract `Spliterator` that implements `trySplit` to permit limited parallelism.
    SplittableRandom | A generator of uniform pseudorandom values applicable for use in (among other contexts) isolated parallel computations that may generate subtasks.
    Stack<E> | The `Stack` class represents a last-in-first-out (LIFO) stack of objects.
    StringJoiner | `StringJoiner` is used to construct a sequence of characters separated by a delimiter and optionally starting with a supplied prefix and ending with a supplied suffix.
    StringTokenizer | The string tokenizer class allows an application to break a string into tokens.
    Timer | A facility for threads to schedule tasks for future execution in a background thread.
    TimerTask | A task that can be scheduled for one-time or repeated execution by a Timer.
    TimeZone | `TimeZone` represents a time zone offset, and also figures out daylight savings.
    TreeMap<K,V> | A Red-Black tree based `NavigableMap` implementation.
    TreeSet<E> | A `NavigableSet` implementation based on a `TreeMap`.
    UUID | A class that represents an immutable universally unique identifier (UUID).
    Vector<E> | The `Vector` class implements a growable array of objects.
    WeakHashMap<K,V> | Hash table based implementation of the `Map` interface, with weak keys.

    Enum Summary
    Enum | Description
    --- | ---
    Formatter.BigDecimalLayoutForm | Enum for `BigDecimal` formatting.
    Locale.Category | Enum for locale categories.
    Locale.FilteringMode | This enum provides constants to select a filtering mode for locale matching.

    Exception Summary
    Exception | Description
    --- | ---
    ConcurrentModificationException | This exception may be thrown by methods that have detected concurrent modification of an object when such modification is not permissible.
    DuplicateFormatFlagsException | Unchecked exception thrown when duplicate flags are provided in the format specifier.
    EmptyStackException | Thrown by methods in the `Stack` class to indicate that the stack is empty.
    FormatFlagsConversionMismatchException | Unchecked exception thrown when a conversion and flag are incompatible.
    FormatterClosedException | Unchecked exception thrown when the formatter has been closed.
    IllegalFormatCodePointException | Unchecked exception thrown when a character with an invalid Unicode code point as defined by `Character.isValidCodePoint(int)` is passed to the `Formatter`.
    IllegalFormatConversionException | Unchecked exception thrown when the argument corresponding to the format specifier is of an incompatible type.
    IllegalFormatException | Unchecked exception thrown when a format string contains an illegal syntax or a format specifier that is incompatible with the given arguments.
    IllegalFormatFlagsException | Unchecked exception thrown when an illegal combination flags is given.
    IllegalFormatPrecisionException | Unchecked exception thrown when the precision is a negative value other than `-1`, the conversion does not support a precision, or the value is otherwise unsupported.
    IllegalFormatWidthException | Unchecked exception thrown when the format width is a negative value other than `-1` or is otherwise unsupported.
    IllformedLocaleException | Thrown by methods in `Locale` and `Locale.Builder` to indicate that an argument is not a well-formed BCP 47 tag.
    InputMismatchException | Thrown by a `Scanner` to indicate that the token retrieved does not match the pattern for the expected type, or that the token is out of range for the expected type.
    InvalidPropertiesFormatException | Thrown to indicate that an operation could not complete because the input did not conform to the appropriate XML document type for a collection of properties, as per the `Properties` specification.
    MissingFormatArgumentException | Unchecked exception thrown when there is a format specifier which does not have a corresponding argument or if an argument index refers to an argument that does not exist.
    MissingFormatWidthException | Unchecked exception thrown when the format width is required.
    MissingResourceException | Signals that a resource is missing.
    NoSuchElementException | Thrown by various accessor methods to indicate that the element being requested does not exist.
    TooManyListenersException | The `TooManyListenersException` Exception is used as part of the Java Event model to annotate and implement a unicast special case of a multicast Event Source.
    UnknownFormatConversionException | Unchecked exception thrown when an unknown conversion is given.
    UnknownFormatFlagsException | Unchecked exception thrown when an unknown flag is given.

    Error Summary
    Error | Description
    --- | ---
    ServiceConfigurationError | Error thrown when something goes wrong while loading a service provider.

  - ### java.util.concurrent

    Interface Summary
    Interface | Description
    --- | ---
    BlockingDeque<E> | 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.
    BlockingQueue<E> | 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.
    Callable<V> | A task that returns a result and may throw an exception.
    CompletableFuture.AsynchronousCompletionTask | A marker interface identifying asynchronous tasks produced by `async` methods.
    CompletionService<V> | A service that decouples the production of new asynchronous tasks from the consumption of the results of completed tasks.
    CompletionStage<T> | A stage of a possibly asynchronous computation, that performs an action or computes a value when another CompletionStage completes.
    ConcurrentMap<K,V> | A `Map` providing thread safety and atomicity guarantees.
    ConcurrentNavigableMap<K,V> | A `ConcurrentMap` supporting `NavigableMap` operations, and recursively so for its navigable sub-maps.
    Delayed | A mix-in style interface for marking objects that should be acted upon after a given delay.
    Executor | An object that executes submitted `Runnable` tasks.
    ExecutorService | An `Executor` that provides methods to manage termination and methods that can produce a `Future` for tracking progress of one or more asynchronous tasks.
    ForkJoinPool.ForkJoinWorkerThreadFactory | Factory for creating new `ForkJoinWorkerThread`s.
    ForkJoinPool.ManagedBlocker | Interface for extending managed parallelism for tasks running in `ForkJoinPool`s.
    Future<V> | A `Future` represents the result of an asynchronous computation.
    RejectedExecutionHandler | A handler for tasks that cannot be executed by a `ThreadPoolExecutor`.
    RunnableFuture<V> | A `Future` that is `Runnable`.
    RunnableScheduledFuture<V> | A `ScheduledFuture` that is `Runnable`.
    ScheduledExecutorService | An `ExecutorService` that can schedule commands to run after a given delay, or to execute periodically.
    ScheduledFuture<V> | A delayed result-bearing action that can be cancelled.
    ThreadFactory | An object that creates new threads on demand.
    TransferQueue<E> | A `BlockingQueue` in which producers may wait for consumers to receive elements.

    Class Summary
    Class | Description
    --- | ---
    AbstractExecutorService | Provides default implementations of `ExecutorService` execution methods.
    ArrayBlockingQueue<E> | A bounded blocking queue backed by an array.
    CompletableFuture<T> | 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.
    ConcurrentHashMap<K,V> | A hash table supporting full concurrency of retrievals and high expected concurrency for updates.
    ConcurrentHashMap.KeySetView<K,V> | A view of a ConcurrentHashMap as a `Set` of keys, in which additions may optionally be enabled by mapping to a common value.
    ConcurrentLinkedDeque<E> | An unbounded concurrent deque based on linked nodes.
    ConcurrentLinkedQueue<E> | An unbounded thread-safe queue based on linked nodes.
    ConcurrentSkipListMap<K,V> | A scalable concurrent `ConcurrentNavigableMap` implementation.
    ConcurrentSkipListSet<E> | A scalable concurrent `NavigableSet` implementation based on a `ConcurrentSkipListMap`.
    CopyOnWriteArrayList<E> | 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.
    CopyOnWriteArraySet<E> | A `Set` that uses an internal `CopyOnWriteArrayList` for all of its operations.
    CountDownLatch | A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.
    CountedCompleter<T> | A `ForkJoinTask` with a completion action performed when triggered and there are no remaining pending actions.
    CyclicBarrier | A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.
    DelayQueue<E extends Delayed> | An unbounded blocking queue of `Delayed` elements, in which an element can only be taken when its delay has expired.
    Exchanger<V> | A synchronization point at which threads can pair and swap elements within pairs.
    ExecutorCompletionService<V> | A `CompletionService` that uses a supplied `Executor` to execute tasks.
    Executors | Factory and utility methods for `Executor`, `ExecutorService`, `ScheduledExecutorService`, `ThreadFactory`, and `Callable` classes defined in this package.
    ForkJoinPool | An `ExecutorService` for running `ForkJoinTask`s.
    ForkJoinTask<V> | Abstract base class for tasks that run within a `ForkJoinPool`.
    ForkJoinWorkerThread | A thread managed by a `ForkJoinPool`, which executes `ForkJoinTask`s.
    FutureTask<V> | A cancellable asynchronous computation.
    LinkedBlockingDeque<E> | An optionally-bounded blocking deque based on linked nodes.
    LinkedBlockingQueue<E> | An optionally-bounded blocking queue based on linked nodes.
    LinkedTransferQueue<E> | An unbounded `TransferQueue` based on linked nodes.
    Phaser | A reusable synchronization barrier, similar in functionality to `CyclicBarrier` and `CountDownLatch` but supporting more flexible usage.
    PriorityBlockingQueue<E> | An unbounded blocking queue that uses the same ordering rules as class `PriorityQueue` and supplies blocking retrieval operations.
    RecursiveAction | A recursive resultless `ForkJoinTask`.
    RecursiveTask<V> | A recursive result-bearing `ForkJoinTask`.
    ScheduledThreadPoolExecutor | A `ThreadPoolExecutor` that can additionally schedule commands to run after a given delay, or to execute periodically.
    Semaphore | A counting semaphore.
    SynchronousQueue<E> | A blocking queue in which each insert operation must wait for a corresponding remove operation by another thread, and vice versa.
    ThreadLocalRandom | A random number generator isolated to the current thread.
    ThreadPoolExecutor | An `ExecutorService` that executes each submitted task using one of possibly several pooled threads, normally configured using `Executors` factory methods.
    ThreadPoolExecutor.AbortPolicy | A handler for rejected tasks that throws a `RejectedExecutionException`.
    ThreadPoolExecutor.CallerRunsPolicy | 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.
    ThreadPoolExecutor.DiscardOldestPolicy | 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.
    ThreadPoolExecutor.DiscardPolicy | A handler for rejected tasks that silently discards the rejected task.

    Enum Summary
    Enum | Description
    --- | ---
    TimeUnit | 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.

    Exception Summary
    Exception | Description
    --- | ---
    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 is waiting.
    CancellationException | Exception indicating that the result of a value-producing task, such as a `FutureTask`, cannot be retrieved because the task was cancelled.
    CompletionException | Exception thrown when an error or other exception is encountered in the course of completing a result or task.
    ExecutionException | Exception thrown when attempting to retrieve the result of a task that aborted by throwing an exception.
    RejectedExecutionException | Exception thrown by an `Executor` when a task cannot be accepted for execution.
    TimeoutException | Exception thrown when a blocking operation times out.

  - ### java.util.concurrent.atomic

    Class Summary
    Class | Description
    --- | ---
    AtomicBoolean | A `boolean` value that may be updated atomically.
    AtomicInteger | An `int` value that may be updated atomically.
    AtomicIntegerArray | An `int` array in which elements may be updated atomically.
    AtomicIntegerFieldUpdater<T> | A reflection-based utility that enables atomic updates to designated `volatile int` fields of designated classes.
    AtomicLong | A `long` value that may be updated atomically.
    AtomicLongArray | A `long` array in which elements may be updated atomically.
    AtomicLongFieldUpdater<T> | A reflection-based utility that enables atomic updates to designated `volatile long` fields of designated classes.
    AtomicMarkableReference<V> | An `AtomicMarkableReference` maintains an object reference along with a mark bit, that can be updated atomically.
    AtomicReference<V> | An object reference that may be updated atomically.
    AtomicReferenceArray<E> | An array of object references in which elements may be updated atomically.
    AtomicReferenceFieldUpdater<T,V> | A reflection-based utility that enables atomic updates to designated `volatile` reference fields of designated classes.
    AtomicStampedReference<V> | An `AtomicStampedReference` maintains an object reference along with an integer "stamp", that can be updated atomically.
    DoubleAccumulator | One or more variables that together maintain a running `double` value updated using a supplied function.
    DoubleAdder | One or more variables that together maintain an initially zero `double` sum.
    LongAccumulator | One or more variables that together maintain a running `long` value updated using a supplied function.
    LongAdder | One or more variables that together maintain an initially zero `long` sum.

  - ### java.util.concurrent.locks

    Interface Summary
    Interface | Description
    --- | ---
    Condition | `Condition` factors out the `Object` monitor methods (`wait`, `notify` and `notifyAll`) into distinct objects to give the effect of having multiple wait-sets per object, by combining them with the use of arbitrary `Lock` implementations.
    Lock | `Lock` implementations provide more extensive locking operations than can be obtained using `synchronized` methods and statements.
    ReadWriteLock | A `ReadWriteLock` maintains a pair of associated `locks`, one for read-only operations and one for writing.

    Class Summary
    Class | Description
    --- | ---
    AbstractOwnableSynchronizer | A synchronizer that may be exclusively owned by a thread.
    AbstractQueuedLongSynchronizer | A version of `AbstractQueuedSynchronizer` in which synchronization state is maintained as a `long`.
    AbstractQueuedSynchronizer | Provides a framework for implementing blocking locks and related synchronizers (semaphores, events, etc) that rely on first-in-first-out (FIFO) wait queues.
    LockSupport | Basic thread blocking primitives for creating locks and other synchronization classes.
    ReentrantLock | A reentrant mutual exclusion `Lock` with the same basic behavior and semantics as the implicit monitor lock accessed using `synchronized` methods and statements, but with extended capabilities.
    ReentrantReadWriteLock | An implementation of `ReadWriteLock` supporting similar semantics to `ReentrantLock`.
    ReentrantReadWriteLock.ReadLock | The lock returned by method `ReentrantReadWriteLock.readLock()`.
    ReentrantReadWriteLock.WriteLock | The lock returned by method `ReentrantReadWriteLock.writeLock()`.
    StampedLock | A capability-based lock with three modes for controlling read/write access.

  - ### java.util.function

    Interface Summary
    Interface | Description
    --- | ---
    BiConsumer<T,U> | Represents an operation that accepts two input arguments and returns no result.
    BiFunction<T,U,R> | Represents a function that accepts two arguments and produces a result.
    BinaryOperator<T> | Represents an operation upon two operands of the same type, producing a result of the same type as the operands.
    BiPredicate<T,U> | Represents a predicate (boolean-valued function) of two arguments.
    BooleanSupplier | Represents a supplier of `boolean`-valued results.
    Consumer<T> | Represents an operation that accepts a single input argument and returns no result.
    DoubleBinaryOperator | Represents an operation upon two `double`-valued operands and producing a `double`-valued result.
    DoubleConsumer | Represents an operation that accepts a single `double`-valued argument and returns no result.
    DoubleFunction<R> | Represents a function that accepts a double-valued argument and produces a result.
    DoublePredicate | Represents a predicate (boolean-valued function) of one `double`-valued argument.
    DoubleSupplier | Represents a supplier of `double`-valued results.
    DoubleToIntFunction | Represents a function that accepts a double-valued argument and produces an int-valued result.
    DoubleToLongFunction | Represents a function that accepts a double-valued argument and produces a long-valued result.
    DoubleUnaryOperator | Represents an operation on a single `double`-valued operand that produces a `double`-valued result.
    Function<T,R> | Represents a function that accepts one argument and produces a result.
    IntBinaryOperator | Represents an operation upon two `int`-valued operands and producing an `int`-valued result.
    IntConsumer | Represents an operation that accepts a single `int`-valued argument and returns no result.
    IntFunction<R> | Represents a function that accepts an int-valued argument and produces a result.
    IntPredicate | Represents a predicate (boolean-valued function) of one `int`-valued argument.
    IntSupplier | Represents a supplier of `int`-valued results.
    IntToDoubleFunction | Represents a function that accepts an int-valued argument and produces a double-valued result.
    IntToLongFunction | Represents a function that accepts an int-valued argument and produces a long-valued result.
    IntUnaryOperator | Represents an operation on a single `int`-valued operand that produces an `int`-valued result.
    LongBinaryOperator | Represents an operation upon two `long`-valued operands and producing a `long`-valued result.
    LongConsumer | Represents an operation that accepts a single `long`-valued argument and returns no result.
    LongFunction<R> | Represents a function that accepts a long-valued argument and produces a result.
    LongPredicate | Represents a predicate (boolean-valued function) of one `long`-valued argument.
    LongSupplier | Represents a supplier of `long`-valued results.
    LongToDoubleFunction | Represents a function that accepts a long-valued argument and produces a double-valued result.
    LongToIntFunction | Represents a function that accepts a long-valued argument and produces an int-valued result.
    LongUnaryOperator | Represents an operation on a single `long`-valued operand that produces a `long`-valued result.
    ObjDoubleConsumer<T> | Represents an operation that accepts an object-valued and a `double`-valued argument, and returns no result.
    ObjIntConsumer<T> | Represents an operation that accepts an object-valued and a `int`-valued argument, and returns no result.
    ObjLongConsumer<T> | Represents an operation that accepts an object-valued and a `long`-valued argument, and returns no result.
    Predicate<T> | Represents a predicate (boolean-valued function) of one argument.
    Supplier<T> | Represents a supplier of results.
    ToDoubleBiFunction<T,U> | Represents a function that accepts two arguments and produces a double-valued result.
    ToDoubleFunction<T> | Represents a function that produces a double-valued result.
    ToIntBiFunction<T,U> | Represents a function that accepts two arguments and produces an int-valued result.
    ToIntFunction<T> | Represents a function that produces an int-valued result.
    ToLongBiFunction<T,U> | Represents a function that accepts two arguments and produces a long-valued result.
    ToLongFunction<T> | Represents a function that produces a long-valued result.
    UnaryOperator<T> | Represents an operation on a single operand that produces a result of the same type as its operand.

  - ### java.util.jar

    Interface Summary
    Interface | Description
    --- | ---
    Pack200.Packer | The packer engine applies various transformations to the input JAR file, making the pack stream highly compressible by a compressor such as gzip or zip.
    Pack200.Unpacker | The unpacker engine converts the packed stream to a JAR file.

    Class Summary
    Class | Description
    --- | ---
    Attributes | The Attributes class maps Manifest attribute names to associated string values.
    Attributes.Name | The Attributes.Name class represents an attribute name stored in this Map.
    JarEntry | This class is used to represent a JAR file entry.
    JarFile | The `JarFile` class is used to read the contents of a jar file from any file that can be opened with `java.io.RandomAccessFile`.
    JarInputStream | The `JarInputStream` class is used to read the contents of a JAR file from any input stream.
    JarOutputStream | The `JarOutputStream` class is used to write the contents of a JAR file to any output stream.
    Manifest | The Manifest class is used to maintain Manifest entry names and their associated Attributes.
    Pack200 | Transforms a JAR file to or from a packed stream in Pack200 format.

    Exception Summary
    Exception | Description
    --- | ---
    JarException | Signals that an error of some sort has occurred while reading from or writing to a JAR file.

  - ### java.util.logging

    Interface Summary
    Interface | Description
    --- | ---
    Filter | A Filter can be used to provide fine grain control over what is logged, beyond the control provided by log levels.
    LoggingMXBean | The management interface for the logging facility.

    Class Summary
    Class | Description
    --- | ---
    ConsoleHandler | This `Handler` publishes log records to `System.err`.
    ErrorManager | ErrorManager objects can be attached to Handlers to process any error that occurs on a Handler during Logging.
    FileHandler | Simple file logging `Handler`.
    Formatter | A Formatter provides support for formatting LogRecords.
    Handler | A `Handler` object takes log messages from a `Logger` and exports them.
    Level | The Level class defines a set of standard logging levels that can be used to control logging output.
    Logger | A Logger object is used to log messages for a specific system or application component.
    LoggingPermission | The permission which the SecurityManager will check when code that is running with a SecurityManager calls one of the logging control methods (such as Logger.setLevel).
    LogManager | There is a single global LogManager object that is used to maintain a set of shared state about Loggers and log services.
    LogRecord | LogRecord objects are used to pass logging requests between the logging framework and individual log Handlers.
    MemoryHandler | `Handler` that buffers requests in a circular buffer in memory.
    SimpleFormatter | Print a brief summary of the `LogRecord` in a human readable format.
    SocketHandler | Simple network logging `Handler`.
    StreamHandler | Stream based logging `Handler`.
    XMLFormatter | Format a LogRecord into a standard XML format.

  - ### java.util.regex

    Interface Summary
    Interface | Description
    --- | ---
    MatchResult | The result of a match operation.

    Class Summary
    Class | Description
    --- | ---
    Matcher | An engine that performs match operations on a character sequence by interpreting a `Pattern`.
    Pattern | A compiled representation of a regular expression.

    Exception Summary
    Exception | Description
    --- | ---
    PatternSyntaxException | Unchecked exception thrown to indicate a syntax error in a regular-expression pattern.

  - ### java.util.spi

    Interface Summary
    Interface | Description
    --- | ---
    ResourceBundleControlProvider | An interface for service providers that provide implementations of `ResourceBundle.Control`.

    Class Summary
    Class | Description
    --- | ---
    CalendarDataProvider | An abstract class for service providers that provide locale-dependent `Calendar` parameters.
    CalendarNameProvider | An abstract class for service providers that provide localized string representations (display names) of `Calendar` field values.
    CurrencyNameProvider | An abstract class for service providers that provide localized currency symbols and display names for the `Currency` class.
    LocaleNameProvider | An abstract class for service providers that provide localized names for the `Locale` class.
    LocaleServiceProvider | This is the super class of all the locale sensitive service provider interfaces (SPIs).
    TimeZoneNameProvider | An abstract class for service providers that provide localized time zone names for the `TimeZone` class.

  - ### java.util.stream

    Interface Summary
    Interface | Description
    --- | ---
    BaseStream<T,S extends BaseStream<T,S>> | Base interface for streams, which are sequences of elements supporting sequential and parallel aggregate operations.
    Collector<T,A,R> | A mutable reduction operation that accumulates input elements into a mutable result container, optionally transforming the accumulated result into a final representation after all input elements have been processed.
    DoubleStream | A sequence of primitive double-valued elements supporting sequential and parallel aggregate operations.
    DoubleStream.Builder | A mutable builder for a `DoubleStream`.
    IntStream | A sequence of primitive int-valued elements supporting sequential and parallel aggregate operations.
    IntStream.Builder | A mutable builder for an `IntStream`.
    LongStream | A sequence of primitive long-valued elements supporting sequential and parallel aggregate operations.
    LongStream.Builder | A mutable builder for a `LongStream`.
    Stream<T> | A sequence of elements supporting sequential and parallel aggregate operations.
    Stream.Builder<T> | A mutable builder for a `Stream`.

    Class Summary
    Class | Description
    --- | ---
    Collectors | Implementations of `Collector` that implement various useful reduction operations, such as accumulating elements into collections, summarizing elements according to various criteria, etc.
    StreamSupport | Low-level utility methods for creating and manipulating streams.

    Enum Summary
    Enum | Description
    --- | ---
    Collector.Characteristics | Characteristics indicating properties of a `Collector`, which can be used to optimize reduction implementations.

  - ### java.util.zip

    Interface Summary
    Interface | Description
    --- | ---
    Checksum | An interface representing a data checksum.

    Class Summary
    Class | Description
    --- | ---
    Adler32 | A class that can be used to compute the Adler-32 checksum of a data stream.
    CheckedInputStream | An input stream that also maintains a checksum of the data being read.
    CheckedOutputStream | An output stream that also maintains a checksum of the data being written.
    CRC32 | A class that can be used to compute the CRC-32 of a data stream.
    Deflater | This class provides support for general purpose compression using the popular ZLIB compression library.
    DeflaterInputStream | Implements an input stream filter for compressing data in the "deflate" compression format.
    DeflaterOutputStream | This class implements an output stream filter for compressing data in the "deflate" compression format.
    GZIPInputStream | This class implements a stream filter for reading compressed data in the GZIP file format.
    GZIPOutputStream | This class implements a stream filter for writing compressed data in the GZIP file format.
    Inflater | This class provides support for general purpose decompression using the popular ZLIB compression library.
    InflaterInputStream | This class implements a stream filter for uncompressing data in the "deflate" compression format.
    InflaterOutputStream | Implements an output stream filter for uncompressing data stored in the "deflate" compression format.
    ZipEntry | This class is used to represent a ZIP file entry.
    ZipFile | This class is used to read entries from a zip file.
    ZipInputStream | This class implements an input stream filter for reading files in the ZIP file format.
    ZipOutputStream | This class implements an output stream filter for writing files in the ZIP file format.

    Exception Summary
    Exception | Description
    --- | ---
    DataFormatException | Signals that a data format error has occurred.
    ZipException | Signals that a Zip exception of some sort has occurred.

    Error Summary
    Error | Description
    --- | ---
    ZipError | Signals that an unrecoverable error has occurred.

  - ### javax.crypto

    Interface Summary
    Interface | Description
    --- | ---
    SecretKey | A secret (symmetric) key.

    Class Summary
    Class | Description
    --- | ---
    Cipher | This class provides the functionality of a cryptographic cipher for encryption and decryption.
    CipherInputStream | A CipherInputStream is composed of an InputStream and a Cipher so that read() methods return data that are read in from the underlying InputStream but have been additionally processed by the Cipher.
    CipherOutputStream | A CipherOutputStream is composed of an OutputStream and a Cipher so that write() methods first process the data before writing them out to the underlying OutputStream.
    CipherSpi | This class defines the Service Provider Interface (SPI) for the `Cipher` class.
    EncryptedPrivateKeyInfo | This class implements the `EncryptedPrivateKeyInfo` type as defined in PKCS #8.
    ExemptionMechanism | This class provides the functionality of an exemption mechanism, examples of which are key recovery, key weakening, and key escrow.
    ExemptionMechanismSpi | This class defines the Service Provider Interface (SPI) for the `ExemptionMechanism` class.
    KeyAgreement | This class provides the functionality of a key agreement (or key exchange) protocol.
    KeyAgreementSpi | This class defines the Service Provider Interface (SPI) for the `KeyAgreement` class.
    KeyGenerator | This class provides the functionality of a secret (symmetric) key generator.
    KeyGeneratorSpi | This class defines the Service Provider Interface (SPI) for the `KeyGenerator` class.
    Mac | This class provides the functionality of a "Message Authentication Code" (MAC) algorithm.
    MacSpi | This class defines the Service Provider Interface (SPI) for the `Mac` class.
    NullCipher | The NullCipher class is a class that provides an "identity cipher" -- one that does not transform the plain text.
    SealedObject | This class enables a programmer to create an object and protect its confidentiality with a cryptographic algorithm.
    SecretKeyFactory | This class represents a factory for secret keys.
    SecretKeyFactorySpi | This class defines the Service Provider Interface (SPI) for the `SecretKeyFactory` class.

    Exception Summary
    Exception | Description
    --- | ---
    AEADBadTagException | This exception is thrown when a `Cipher` operating in an AEAD mode (such as GCM/CCM) is unable to verify the supplied authentication tag.
    BadPaddingException | This exception is thrown when a particular padding mechanism is expected for the input data but the data is not padded properly.
    ExemptionMechanismException | This is the generic ExemptionMechanism exception.
    IllegalBlockSizeException | This exception is thrown when the length of data provided to a block cipher is incorrect, i.e., does not match the block size of the cipher.
    NoSuchPaddingException | This exception is thrown when a particular padding mechanism is requested but is not available in the environment.
    ShortBufferException | This exception is thrown when an output buffer provided by the user is too short to hold the operation result.

  - ### javax.crypto.interfaces

    Interface Summary
    Interface | Description
    --- | ---
    DHKey | The interface to a Diffie-Hellman key.
    DHPrivateKey | The interface to a Diffie-Hellman private key.
    DHPublicKey | The interface to a Diffie-Hellman public key.
    PBEKey | The interface to a PBE key.

  - ### javax.crypto.spec

    Class Summary
    Class | Description
    --- | ---
    DESedeKeySpec | This class specifies a DES-EDE ("triple-DES") key.
    DESKeySpec | This class specifies a DES key.
    DHGenParameterSpec | This class specifies the set of parameters used for generating Diffie-Hellman (system) parameters for use in Diffie-Hellman key agreement.
    DHParameterSpec | This class specifies the set of parameters used with the Diffie-Hellman algorithm, as specified in PKCS #3: Diffie-Hellman Key-Agreement Standard.
    DHPrivateKeySpec | This class specifies a Diffie-Hellman private key with its associated parameters.
    DHPublicKeySpec | This class specifies a Diffie-Hellman public key with its associated parameters.
    GCMParameterSpec | Specifies the set of parameters required by a `Cipher` using the Galois/Counter Mode (GCM) mode.
    IvParameterSpec | This class specifies an initialization vector (IV).
    OAEPParameterSpec | This class specifies the set of parameters used with OAEP Padding, as defined in the PKCS#1 v2.2 standard.
    PBEKeySpec | A user-chosen password that can be used with password-based encryption (PBE).
    PBEParameterSpec | This class specifies the set of parameters used with password-based encryption (PBE), as defined in the PKCS #5 standard.
    PSource | This class specifies the source for encoding input P in OAEP Padding, as defined in the PKCS#1 v2.2 standard.
    PSource.PSpecified | This class is used to explicitly specify the value for encoding input P in OAEP Padding.
    RC2ParameterSpec | This class specifies the parameters used with the RC2 algorithm.
    RC5ParameterSpec | This class specifies the parameters used with the RC5 algorithm.
    SecretKeySpec | This class specifies a secret key in a provider-independent fashion.

  - ### javax.net

    Class Summary
    Class | Description
    --- | ---
    ServerSocketFactory | This class creates server sockets.
    SocketFactory | This class creates sockets.

  - ### javax.net.ssl

    Interface Summary
    Interface | Description
    --- | ---
    HandshakeCompletedListener | This interface is implemented by any class which wants to receive notifications about the completion of an SSL protocol handshake on a given SSL connection.
    HostnameVerifier | This class is the base interface for hostname verification.
    KeyManager | This is the base interface for JSSE key managers.
    ManagerFactoryParameters | This class is the base interface for providing algorithm-specific information to a KeyManagerFactory or TrustManagerFactory.
    SSLSession | In SSL, sessions are used to describe an ongoing relationship between two entities.
    SSLSessionBindingListener | This interface is implemented by objects which want to know when they are being bound or unbound from a SSLSession.
    SSLSessionContext | A `SSLSessionContext` represents a set of `SSLSession`s associated with a single entity.
    TrustManager | This is the base interface for JSSE trust managers.
    X509KeyManager | Instances of this interface manage which X509 certificate-based key pairs are used to authenticate the local side of a secure socket.
    X509TrustManager | Instance of this interface manage which X509 certificates may be used to authenticate the remote side of a secure socket.

    Class Summary
    Class | Description
    --- | ---
    CertPathTrustManagerParameters | A wrapper for CertPathParameters.
    ExtendedSSLSession | Extends the `SSLSession` interface to support additional session attributes.
    HandshakeCompletedEvent | This event indicates that an SSL handshake completed on a given SSL connection.
    HttpsURLConnection | `HttpsURLConnection` extends `HttpURLConnection` with support for https-specific features.
    KeyManagerFactory | This class acts as a factory for key managers based on a source of key material.
    KeyManagerFactorySpi | This class defines the Service Provider Interface (SPI) for the `KeyManagerFactory` class.
    KeyStoreBuilderParameters | A parameters object for X509KeyManagers that encapsulates a List of KeyStore.Builders.
    SNIHostName | Instances of this class represent a server name of type `host_name` in a Server Name Indication (SNI) extension.
    SNIMatcher | Instances of this class represent a matcher that performs match operations on an `SNIServerName` instance.
    SNIServerName | Instances of this class represent a server name in a Server Name Indication (SNI) extension.
    SSLContext | Instances of this class represent a secure socket protocol implementation which acts as a factory for secure socket factories or `SSLEngine`s.
    SSLContextSpi | This class defines the Service Provider Interface (SPI) for the `SSLContext` class.
    SSLEngine | A class which enables secure communications using protocols such as the Secure Sockets Layer (SSL) or IETF RFC 2246 "Transport Layer Security" (TLS) protocols, but is transport independent.
    SSLEngineResult | An encapsulation of the result state produced by `SSLEngine` I/O calls.
    SSLParameters | Encapsulates parameters for an SSL/TLS connection.
    SSLPermission | This class is for various network permissions.
    SSLServerSocket | This class extends `ServerSocket`s and provides secure server sockets using protocols such as the Secure Sockets Layer (SSL) or Transport Layer Security (TLS) protocols.
    SSLServerSocketFactory | `SSLServerSocketFactory`s create `SSLServerSocket`s.
    SSLSessionBindingEvent | This event is propagated to a SSLSessionBindingListener.
    SSLSocket | This class extends `Socket`s and provides secure socket using protocols such as the "Secure Sockets Layer" (SSL) or IETF "Transport Layer Security" (TLS) protocols.
    SSLSocketFactory | `SSLSocketFactory`s create `SSLSocket`s.
    StandardConstants | Standard constants definitions
    TrustManagerFactory | This class acts as a factory for trust managers based on a source of trust material.
    TrustManagerFactorySpi | This class defines the Service Provider Interface (SPI) for the `TrustManagerFactory` class.
    X509ExtendedKeyManager | Abstract class that provides for extension of the X509KeyManager interface.
    X509ExtendedTrustManager | Extensions to the `X509TrustManager` interface to support SSL/TLS connection sensitive trust management.

    Enum Summary
    Enum | Description
    --- | ---
    SSLEngineResult.HandshakeStatus | An `SSLEngineResult` enum describing the current handshaking state of this `SSLEngine`.
    SSLEngineResult.Status | An `SSLEngineResult` enum describing the overall result of the `SSLEngine` operation.

    Exception Summary
    Exception | Description
    --- | ---
    SSLException | Indicates some kind of error detected by an SSL subsystem.
    SSLHandshakeException | Indicates that the client and server could not negotiate the desired level of security.
    SSLKeyException | Reports a bad SSL key.
    SSLPeerUnverifiedException | Indicates that the peer's identity has not been verified.
    SSLProtocolException | Reports an error in the operation of the SSL protocol.

  - ### javax.script

    Interface Summary
    Interface | Description
    --- | ---
    Bindings | A mapping of key/value pairs, all of whose keys are `Strings`.
    Compilable | The optional interface implemented by ScriptEngines whose methods compile scripts to a form that can be executed repeatedly without recompilation.
    Invocable | The optional interface implemented by ScriptEngines whose methods allow the invocation of procedures in scripts that have previously been executed.
    ScriptContext | The interface whose implementing classes are used to connect Script Engines with objects, such as scoped Bindings, in hosting applications.
    ScriptEngine | `ScriptEngine` is the fundamental interface whose methods must be fully functional in every implementation of this specification.
    ScriptEngineFactory | `ScriptEngineFactory` is used to describe and instantiate `ScriptEngines`.

    Class Summary
    Class | Description
    --- | ---
    AbstractScriptEngine | Provides a standard implementation for several of the variants of the `eval` method.
    CompiledScript | Extended by classes that store results of compilations.
    ScriptEngineManager | The `ScriptEngineManager` implements a discovery and instantiation mechanism for `ScriptEngine` classes and also maintains a collection of key/value pairs storing state shared by all engines created by the Manager.
    SimpleBindings | A simple implementation of Bindings backed by a `HashMap` or some other specified `Map`.
    SimpleScriptContext | Simple implementation of ScriptContext.

    Exception Summary
    Exception | Description
    --- | ---
    ScriptException | The generic `Exception` class for the Scripting APIs.

  - ### javax.security.auth

    Interface Summary
    Interface | Description
    --- | ---
    Destroyable | Objects such as credentials may optionally implement this interface to provide the capability to destroy its contents.
    Refreshable | Objects such as credentials may optionally implement this interface to provide the capability to refresh itself.

    Class Summary
    Class | Description
    --- | ---
    AuthPermission | This class is for authentication permissions.
    Policy | Deprecated as of JDK version 1.4 -- Replaced by java.security.Policy.
    PrivateCredentialPermission | This class is used to protect access to private Credentials belonging to a particular `Subject`.
    Subject | A `Subject` represents a grouping of related information for a single entity, such as a person.
    SubjectDomainCombiner | A `SubjectDomainCombiner` updates ProtectionDomains with Principals from the `Subject` associated with this `SubjectDomainCombiner`.

    Exception Summary
    Exception | Description
    --- | ---
    DestroyFailedException | Signals that a `destroy` operation failed.
    RefreshFailedException | Signals that a `refresh` operation failed.

  - ### javax.security.auth.callback

    Interface Summary
    Interface | Description
    --- | ---
    Callback | Implementations of this interface are passed to a `CallbackHandler`, allowing underlying security services the ability to interact with a calling application to retrieve specific authentication data such as usernames and passwords, or to display certain information, such as error and warning messages.
    CallbackHandler | An application implements a `CallbackHandler` and passes it to underlying security services so that they may interact with the application to retrieve specific authentication data, such as usernames and passwords, or to display certain information, such as error and warning messages.

    Class Summary
    Class | Description
    --- | ---
    ChoiceCallback | Underlying security services instantiate and pass a `ChoiceCallback` to the `handle` method of a `CallbackHandler` to display a list of choices and to retrieve the selected choice(s).
    ConfirmationCallback | Underlying security services instantiate and pass a `ConfirmationCallback` to the `handle` method of a `CallbackHandler` to ask for YES/NO, OK/CANCEL, YES/NO/CANCEL or other similar confirmations.
    LanguageCallback | Underlying security services instantiate and pass a `LanguageCallback` to the `handle` method of a `CallbackHandler` to retrieve the `Locale` used for localizing text.
    NameCallback | Underlying security services instantiate and pass a `NameCallback` to the `handle` method of a `CallbackHandler` to retrieve name information.
    PasswordCallback | Underlying security services instantiate and pass a `PasswordCallback` to the `handle` method of a `CallbackHandler` to retrieve password information.
    TextInputCallback | Underlying security services instantiate and pass a `TextInputCallback` to the `handle` method of a `CallbackHandler` to retrieve generic text information.
    TextOutputCallback | Underlying security services instantiate and pass a `TextOutputCallback` to the `handle` method of a `CallbackHandler` to display information messages, warning messages and error messages.

    Exception Summary
    Exception | Description
    --- | ---
    UnsupportedCallbackException | Signals that a `CallbackHandler` does not recognize a particular `Callback`.

  - ### javax.security.auth.login

    Interface Summary
    Interface | Description
    --- | ---
    Configuration.Parameters | This represents a marker interface for Configuration parameters.

    Class Summary
    Class | Description
    --- | ---
    AppConfigurationEntry | This class represents a single `LoginModule` entry configured for the application specified in the `getAppConfigurationEntry(String appName)` method in the `Configuration` class.
    AppConfigurationEntry.LoginModuleControlFlag | This class represents whether or not a `LoginModule` is REQUIRED, REQUISITE, SUFFICIENT or OPTIONAL.
    Configuration | A Configuration object is responsible for specifying which LoginModules should be used for a particular application, and in what order the LoginModules should be invoked.
    ConfigurationSpi | This class defines the Service Provider Interface (SPI) for the `Configuration` class.
    LoginContext | The `LoginContext` class describes the basic methods used to authenticate Subjects and provides a way to develop an application independent of the underlying authentication technology.

    Exception Summary
    Exception | Description
    --- | ---
    AccountException | A generic account exception.
    AccountExpiredException | Signals that a user account has expired.
    AccountLockedException | Signals that an account was locked.
    AccountNotFoundException | Signals that an account was not found.
    CredentialException | A generic credential exception.
    CredentialExpiredException | Signals that a `Credential` has expired.
    CredentialNotFoundException | Signals that a credential was not found.
    FailedLoginException | Signals that user authentication failed.
    LoginException | This is the basic login exception.

  - ### javax.security.auth.spi

    Interface Summary
    Interface | Description
    --- | ---
    LoginModule | `LoginModule` describes the interface implemented by authentication technology providers.

  - ### javax.security.auth.x500

    Class Summary
    Class | Description
    --- | ---
    X500Principal | This class represents an X.500 `Principal`.
    X500PrivateCredential | This class represents an `X500PrivateCredential`.

  - ### javax.security.cert

    Class Summary
    Class | Description
    --- | ---
    Certificate | Abstract class for managing a variety of identity certificates.
    X509Certificate | Abstract class for X.509 v1 certificates.

    Exception Summary
    Exception | Description
    --- | ---
    CertificateEncodingException | Certificate Encoding Exception.
    CertificateException | This exception indicates one of a variety of certificate problems.
    CertificateExpiredException | Certificate Expired Exception.
    CertificateNotYetValidException | Certificate is not yet valid exception.
    CertificateParsingException | Certificate Parsing Exception.

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2026, Oracle and/or its affiliates. All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.