Java Profile compact2（JDK8）

153 阅读 0 评论 0 点赞

Java™ Platform
Standard Ed. 8

All Classes

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

Interface Summary
Interface	Description
Remote	The `Remote` interface serves to identify interfaces whose methods may be invoked from a non-local virtual machine.

Class Summary
Class	Description
MarshalledObject<T>	A `MarshalledObject` contains a byte stream with the serialized representation of an object given to its constructor.
Naming	The `Naming` class provides methods for storing and obtaining references to remote objects in a remote object registry.
RMISecurityManager	Deprecated Use `SecurityManager` instead.

Exception Summary
Exception	Description
AccessException	An `AccessException` is thrown by certain methods of the `java.rmi.Naming` class (specifically `bind`, `rebind`, and `unbind`) and methods of the `java.rmi.activation.ActivationSystem` interface to indicate that the caller does not have permission to perform the action requested by the method call.
AlreadyBoundException	An `AlreadyBoundException` is thrown if an attempt is made to bind an object in the registry to a name that already has an associated binding.
ConnectException	A `ConnectException` is thrown if a connection is refused to the remote host for a remote method call.
ConnectIOException	A `ConnectIOException` is thrown if an `IOException` occurs while making a connection to the remote host for a remote method call.
MarshalException	A `MarshalException` is thrown if a `java.io.IOException` occurs while marshalling the remote call header, arguments or return value for a remote method call.
NoSuchObjectException	A `NoSuchObjectException` is thrown if an attempt is made to invoke a method on an object that no longer exists in the remote virtual machine.
NotBoundException	A `NotBoundException` is thrown if an attempt is made to lookup or unbind in the registry a name that has no associated binding.
RemoteException	A `RemoteException` is the common superclass for a number of communication-related exceptions that may occur during the execution of a remote method call.
RMISecurityException	Deprecated Use `SecurityException` instead.
ServerError	A `ServerError` is thrown as a result of a remote method invocation when an `Error` is thrown while processing the invocation on the server, either while unmarshalling the arguments, executing the remote method itself, or marshalling the return value.
ServerException	A `ServerException` is thrown as a result of a remote method invocation when a `RemoteException` is thrown while processing the invocation on the server, either while unmarshalling the arguments or executing the remote method itself.
ServerRuntimeException	Deprecated no replacement
StubNotFoundException	A `StubNotFoundException` is thrown if a valid stub class could not be found for a remote object when it is exported.
UnexpectedException	An `UnexpectedException` is thrown if the client of a remote method call receives, as a result of the call, a checked exception that is not among the checked exception types declared in the `throws` clause of the method in the remote interface.
UnknownHostException	An `UnknownHostException` is thrown if a `java.net.UnknownHostException` occurs while creating a connection to the remote host for a remote method call.
UnmarshalException	An `UnmarshalException` can be thrown while unmarshalling the parameters or results of a remote method call if any of the following conditions occur: if an exception occurs while unmarshalling the call header if the protocol for the return value is invalid if a `java.io.IOException` occurs unmarshalling parameters (on the server side) or the return value (on the client side).

java.rmi.activation

Interface Summary
Interface	Description
ActivationInstantiator	An `ActivationInstantiator` is responsible for creating instances of "activatable" objects.
ActivationMonitor	An `ActivationMonitor` is specific to an `ActivationGroup` and is obtained when a group is reported active via a call to `ActivationSystem.activeGroup` (this is done internally).
ActivationSystem	The `ActivationSystem` provides a means for registering groups and "activatable" objects to be activated within those groups.
Activator	The `Activator` facilitates remote object activation.

Class Summary
Class	Description
Activatable	The `Activatable` class provides support for remote objects that require persistent access over time and that can be activated by the system.
ActivationDesc	An activation descriptor contains the information necessary to activate an object: the object's group identifier, the object's fully-qualified class name, the object's code location (the location of the class), a codebase URL path, the object's restart "mode", and, a "marshalled" object that can contain object specific initialization data.
ActivationGroup	An `ActivationGroup` is responsible for creating new instances of "activatable" objects in its group, informing its `ActivationMonitor` when either: its object's become active or inactive, or the group as a whole becomes inactive.
ActivationGroup_Stub	`ActivationGroup_Stub` is a stub class for the subclasses of `java.rmi.activation.ActivationGroup` that are exported as a `java.rmi.server.UnicastRemoteObject`.
ActivationGroupDesc	An activation group descriptor contains the information necessary to create/recreate an activation group in which to activate objects.
ActivationGroupDesc.CommandEnvironment	Startup options for ActivationGroup implementations.
ActivationGroupID	The identifier for a registered activation group serves several purposes: identifies the group uniquely within the activation system, and contains a reference to the group's activation system so that the group can contact its activation system when necessary.
ActivationID	Activation makes use of special identifiers to denote remote objects that can be activated over time.

Exception Summary
Exception	Description
ActivateFailedException	This exception is thrown by the RMI runtime when activation fails during a remote call to an activatable object.
ActivationException	General exception used by the activation interfaces.
UnknownGroupException	An `UnknownGroupException` is thrown by methods of classes and interfaces in the `java.rmi.activation` package when the `ActivationGroupID` parameter to the method is determined to be invalid, i.e., not known by the `ActivationSystem`.
UnknownObjectException	An `UnknownObjectException` is thrown by methods of classes and interfaces in the `java.rmi.activation` package when the `ActivationID` parameter to the method is determined to be invalid.

java.rmi.dgc

Interface Summary
Interface	Description
DGC	The DGC abstraction is used for the server side of the distributed garbage collection algorithm.

Class Summary
Class	Description
Lease	A lease contains a unique VM identifier and a lease duration.
VMID	A VMID is a identifier that is unique across all Java virtual machines.

java.rmi.registry

Interface Summary
Interface	Description
Registry	`Registry` is a remote interface to a simple remote object registry that provides methods for storing and retrieving remote object references bound with arbitrary string names.
RegistryHandler	Deprecated no replacement

Class Summary
Class	Description
LocateRegistry	`LocateRegistry` is used to obtain a reference to a bootstrap remote object registry on a particular host (including the local host), or to create a remote object registry that accepts calls on a specific port.

java.rmi.server

Interface Summary
Interface	Description
LoaderHandler	Deprecated no replacement
RemoteCall	Deprecated no replacement.
RemoteRef	`RemoteRef` represents the handle for a remote object.
RMIClientSocketFactory	An `RMIClientSocketFactory` instance is used by the RMI runtime in order to obtain client sockets for RMI calls.
RMIFailureHandler	An `RMIFailureHandler` can be registered via the `RMISocketFactory.setFailureHandler` call.
RMIServerSocketFactory	An `RMIServerSocketFactory` instance is used by the RMI runtime in order to obtain server sockets for RMI calls.
ServerRef	Deprecated No replacement.
Skeleton	Deprecated no replacement.
Unreferenced	A remote object implementation should implement the `Unreferenced` interface to receive notification when there are no more clients that reference that remote object.

Class Summary
Class	Description
LogStream	Deprecated no replacement
ObjID	An `ObjID` is used to identify a remote object exported to an RMI runtime.
Operation	Deprecated no replacement
RemoteObject	The `RemoteObject` class implements the `java.lang.Object` behavior for remote objects.
RemoteObjectInvocationHandler	An implementation of the `InvocationHandler` interface for use with Java Remote Method Invocation (Java RMI).
RemoteServer	The `RemoteServer` class is the common superclass to server implementations and provides the framework to support a wide range of remote reference semantics.
RemoteStub	Deprecated Statically generated stubs are deprecated, since stubs are generated dynamically.
RMIClassLoader	`RMIClassLoader` comprises static methods to support dynamic class loading with RMI.
RMIClassLoaderSpi	`RMIClassLoaderSpi` is the service provider interface for `RMIClassLoader`.
RMISocketFactory	An `RMISocketFactory` instance is used by the RMI runtime in order to obtain client and server sockets for RMI calls.
UID	A `UID` represents an identifier that is unique over time with respect to the host it is generated on, or one of 2¹⁶ "well-known" identifiers.
UnicastRemoteObject	Used for exporting a remote object with JRMP and obtaining a stub that communicates to the remote object.

Exception Summary
Exception	Description
ExportException	An `ExportException` is a `RemoteException` thrown if an attempt to export a remote object fails.
ServerCloneException	A `ServerCloneException` is thrown if a remote exception occurs during the cloning of a `UnicastRemoteObject`.
ServerNotActiveException	An `ServerNotActiveException` is an `Exception` thrown during a call to `RemoteServer.getClientHost` if the getClientHost method is called outside of servicing a remote method call.
SkeletonMismatchException	Deprecated no replacement.
SkeletonNotFoundException	Deprecated no replacement.
SocketSecurityException	Deprecated This class is obsolete.

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 3280: 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 3280) 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.sql

Interface Summary
Interface	Description
Array	The mapping in the Java programming language for the SQL type `ARRAY`.
Blob	The representation (mapping) in the Java™ programming language of an SQL `BLOB` value.
CallableStatement	The interface used to execute SQL stored procedures.
Clob	The mapping in the Java™ programming language for the SQL `CLOB` type.
Connection	A connection (session) with a specific database.
DatabaseMetaData	Comprehensive information about the database as a whole.
Driver	The interface that every driver class must implement.
DriverAction	An interface that must be implemented when a Driver wants to be notified by `DriverManager`.
NClob	The mapping in the Java™ programming language for the SQL `NCLOB` type.
ParameterMetaData	An object that can be used to get information about the types and properties for each parameter marker in a `PreparedStatement` object.
PreparedStatement	An object that represents a precompiled SQL statement.
Ref	The mapping in the Java programming language of an SQL `REF` value, which is a reference to an SQL structured type value in the database.
ResultSet	A table of data representing a database result set, which is usually generated by executing a statement that queries the database.
ResultSetMetaData	An object that can be used to get information about the types and properties of the columns in a `ResultSet` object.
RowId	The representation (mapping) in the Java programming language of an SQL ROWID value.
Savepoint	The representation of a savepoint, which is a point within the current transaction that can be referenced from the `Connection.rollback` method.
SQLData	The interface used for the custom mapping of an SQL user-defined type (UDT) to a class in the Java programming language.
SQLInput	An input stream that contains a stream of values representing an instance of an SQL structured type or an SQL distinct type.
SQLOutput	The output stream for writing the attributes of a user-defined type back to the database.
SQLType	An object that is used to identify a generic SQL type, called a JDBC type or a vendor specific data type.
SQLXML	The mapping in the JavaTM programming language for the SQL XML type.
Statement	The object used for executing a static SQL statement and returning the results it produces.
Struct	The standard mapping in the Java programming language for an SQL structured type.
Wrapper	Interface for JDBC classes which provide the ability to retrieve the delegate instance when the instance in question is in fact a proxy class.

Class Summary
Class	Description
Date	A thin wrapper around a millisecond value that allows JDBC to identify this as an SQL `DATE` value.
DriverManager	The basic service for managing a set of JDBC drivers. NOTE: The `DataSource` interface, new in the JDBC 2.0 API, provides another way to connect to a data source.
DriverPropertyInfo	Driver properties for making a connection.
SQLPermission	The permission for which the `SecurityManager` will check when code that is running an application with a `SecurityManager` enabled, calls the `DriverManager.deregisterDriver` method, `DriverManager.setLogWriter` method, `DriverManager.setLogStream` (deprecated) method, `SyncFactory.setJNDIContext` method, `SyncFactory.setLogger` method, `Connection.setNetworktimeout` method, or the `Connection.abort` method.
Time	A thin wrapper around the `java.util.Date` class that allows the JDBC API to identify this as an SQL `TIME` value.
Timestamp	A thin wrapper around `java.util.Date` that allows the JDBC API to identify this as an SQL `TIMESTAMP` value.
Types	The class that defines the constants that are used to identify generic SQL types, called JDBC types.

Enum Summary
Enum	Description
ClientInfoStatus	Enumeration for status of the reason that a property could not be set via a call to `Connection.setClientInfo`
JDBCType	Defines the constants that are used to identify generic SQL types, called JDBC types.
PseudoColumnUsage	Enumeration for pseudo/hidden column usage.
RowIdLifetime	Enumeration for RowId life-time values.

Exception Summary
Exception	Description
BatchUpdateException	The subclass of `SQLException` thrown when an error occurs during a batch update operation.
DataTruncation	An exception thrown as a `DataTruncation` exception (on writes) or reported as a `DataTruncation` warning (on reads) when a data values is unexpectedly truncated for reasons other than its having exceeded `MaxFieldSize`.
SQLClientInfoException	The subclass of `SQLException` is thrown when one or more client info properties could not be set on a `Connection`.
SQLDataException	The subclass of `SQLException` thrown when the SQLState class value is '22', or under vendor-specified conditions.
SQLException	An exception that provides information on a database access error or other errors.
SQLFeatureNotSupportedException	The subclass of `SQLException` thrown when the SQLState class value is '0A' ( the value is 'zero' A).
SQLIntegrityConstraintViolationException	The subclass of `SQLException` thrown when the SQLState class value is '23', or under vendor-specified conditions.
SQLInvalidAuthorizationSpecException	The subclass of `SQLException` thrown when the SQLState class value is '28', or under vendor-specified conditions.
SQLNonTransientConnectionException	The subclass of `SQLException` thrown for the SQLState class value '08', or under vendor-specified conditions.
SQLNonTransientException	The subclass of `SQLException` thrown when an instance where a retry of the same operation would fail unless the cause of the `SQLException` is corrected.
SQLRecoverableException	The subclass of `SQLException` thrown in situations where a previously failed operation might be able to succeed if the application performs some recovery steps and retries the entire transaction or in the case of a distributed transaction, the transaction branch.
SQLSyntaxErrorException	The subclass of `SQLException` thrown when the SQLState class value is '42', or under vendor-specified conditions.
SQLTimeoutException	The subclass of `SQLException` thrown when the timeout specified by `Statement.setQueryTimeout`, `DriverManager.setLoginTimeout`, `DataSource.setLoginTimeout`,`XADataSource.setLoginTimeout` has expired.
SQLTransactionRollbackException	The subclass of `SQLException` thrown when the SQLState class value is '40', or under vendor-specified conditions.
SQLTransientConnectionException	The subclass of `SQLException` for the SQLState class value '08', or under vendor-specified conditions.
SQLTransientException	The subclass of `SQLException` is thrown in situations where a previously failed operation might be able to succeed when the operation is retried without any intervention by application-level functionality.
SQLWarning	An exception that provides information on database access warnings.

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.rmi.ssl

Class Summary
Class	Description
SslRMIClientSocketFactory	An `SslRMIClientSocketFactory` instance is used by the RMI runtime in order to obtain client sockets for RMI calls via SSL.
SslRMIServerSocketFactory	An `SslRMIServerSocketFactory` instance is used by the RMI runtime in order to obtain server sockets for RMI calls via SSL.

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.

javax.sql

Interface Summary
Interface	Description
CommonDataSource	Interface that defines the methods which are common between `DataSource`, `XADataSource` and `ConnectionPoolDataSource`.
ConnectionEventListener	An object that registers to be notified of events generated by a `PooledConnection` object.
ConnectionPoolDataSource	A factory for `PooledConnection` objects.
DataSource	A factory for connections to the physical data source that this `DataSource` object represents.
PooledConnection	An object that provides hooks for connection pool management.
RowSet	The interface that adds support to the JDBC API for the JavaBeans™ component model.
RowSetInternal	The interface that a `RowSet` object implements in order to present itself to a `RowSetReader` or `RowSetWriter` object.
RowSetListener	An interface that must be implemented by a component that wants to be notified when a significant event happens in the life of a `RowSet` object.
RowSetMetaData	An object that contains information about the columns in a `RowSet` object.
RowSetReader	The facility that a disconnected `RowSet` object calls on to populate itself with rows of data.
RowSetWriter	An object that implements the `RowSetWriter` interface, called a writer.
StatementEventListener	An object that registers to be notified of events that occur on PreparedStatements that are in the Statement pool.
XAConnection	An object that provides support for distributed transactions.
XADataSource	A factory for `XAConnection` objects that is used internally.

Class Summary
Class	Description
ConnectionEvent	An `Event` object that provides information about the source of a connection-related event.
RowSetEvent	An `Event` object generated when an event occurs to a `RowSet` object.
StatementEvent	A `StatementEvent` is sent to all `StatementEventListener`s which were registered with a `PooledConnection`.

javax.transaction

Exception Summary
Exception	Description
InvalidTransactionException	This exception indicates that the request carried an invalid transaction context.
TransactionRequiredException	This exception indicates that a request carried a null transaction context, but the target object requires an activate transaction.
TransactionRolledbackException	This exception indicates that the transaction associated with processing of the request has been rolled back, or marked to roll back.

javax.transaction.xa

Interface Summary
Interface	Description
XAResource	The XAResource interface is a Java mapping of the industry standard XA interface based on the X/Open CAE Specification (Distributed Transaction Processing: The XA Specification).
Xid	The Xid interface is a Java mapping of the X/Open transaction identifier XID structure.

Exception Summary
Exception	Description
XAException	The XAException is thrown by the Resource Manager (RM) to inform the Transaction Manager of an error encountered by the involved transaction.

javax.xml

Class Summary
Class	Description
XMLConstants	Utility class to contain basic XML values as constants.

javax.xml.datatype

Class Summary
Class	Description
DatatypeConstants	Utility class to contain basic Datatype values as constants.
DatatypeConstants.Field	Type-safe enum class that represents six fields of the `Duration` class.
DatatypeFactory	Factory that creates new `javax.xml.datatype` `Object`s that map XML to/from Java `Object`s.
Duration	Immutable representation of a time span as defined in the W3C XML Schema 1.0 specification.
XMLGregorianCalendar	Representation for W3C XML Schema 1.0 date/time datatypes.

Exception Summary
Exception	Description
DatatypeConfigurationException	Indicates a serious configuration error.

javax.xml.namespace

Interface Summary
Interface	Description
NamespaceContext	Interface for read only XML Namespace context processing.

Class Summary
Class	Description
QName	`QName` represents a qualified name as defined in the XML specifications: XML Schema Part2: Datatypes specification, Namespaces in XML, Namespaces in XML Errata.

javax.xml.parsers

Class Summary
Class	Description
DocumentBuilder	Defines the API to obtain DOM Document instances from an XML document.
DocumentBuilderFactory	Defines a factory API that enables applications to obtain a parser that produces DOM object trees from XML documents.
SAXParser	Defines the API that wraps an `XMLReader` implementation class.
SAXParserFactory	Defines a factory API that enables applications to configure and obtain a SAX based parser to parse XML documents.

Exception Summary
Exception	Description
ParserConfigurationException	Indicates a serious configuration error.

Error Summary
Error	Description
FactoryConfigurationError	Thrown when a problem with configuration with the Parser Factories exists.

javax.xml.stream

Interface Summary
Interface	Description
EventFilter	This interface declares a simple filter interface that one can create to filter XMLEventReaders
Location	Provides information on the location of an event.
StreamFilter	This interface declares a simple filter interface that one can create to filter XMLStreamReaders
XMLEventReader	This is the top level interface for parsing XML Events.
XMLEventWriter	This is the top level interface for writing XML documents.
XMLReporter	This interface is used to report non-fatal errors.
XMLResolver	This interface is used to resolve resources during an XML parse.
XMLStreamConstants	This interface declares the constants used in this API.
XMLStreamReader	The XMLStreamReader interface allows forward, read-only access to XML.
XMLStreamWriter	The XMLStreamWriter interface specifies how to write XML.

Class Summary
Class	Description
XMLEventFactory	This interface defines a utility class for creating instances of XMLEvents
XMLInputFactory	Defines an abstract implementation of a factory for getting streams.
XMLOutputFactory	Defines an abstract implementation of a factory for getting XMLEventWriters and XMLStreamWriters.

Exception Summary
Exception	Description
XMLStreamException	The base exception for unexpected processing errors.

Error Summary
Error	Description
FactoryConfigurationError	An error class for reporting factory configuration errors.

javax.xml.stream.events

Interface Summary
Interface	Description
Attribute	An interface that contains information about an attribute.
Characters	This describes the interface to Characters events.
Comment	An interface for comment events
DTD	This is the top level interface for events dealing with DTDs
EndDocument	A marker interface for the end of the document
EndElement	An interface for the end element event.
EntityDeclaration	An interface for handling Entity Declarations This interface is used to record and report unparsed entity declarations.
EntityReference	An interface for handling Entity events.
Namespace	An interface that contains information about a namespace.
NotationDeclaration	An interface for handling Notation Declarations Receive notification of a notation declaration event.
ProcessingInstruction	An interface that describes the data found in processing instructions
StartDocument	An interface for the start document event
StartElement	The StartElement interface provides access to information about start elements.
XMLEvent	This is the base event interface for handling markup events.

javax.xml.stream.util

Interface Summary
Interface	Description
XMLEventAllocator	This interface defines a class that allows a user to register a way to allocate events given an XMLStreamReader.
XMLEventConsumer	This interface defines an event consumer interface.

Class Summary
Class	Description
EventReaderDelegate	This is the base class for deriving an XMLEventReader filter.
StreamReaderDelegate	This is the base class for deriving an XMLStreamReader filter This class is designed to sit between an XMLStreamReader and an application's XMLStreamReader.

javax.xml.transform

Interface Summary
Interface	Description
ErrorListener	To provide customized error handling, implement this interface and use the `setErrorListener` method to register an instance of the implmentation with the `Transformer`.
Result	An object that implements this interface contains the information needed to build a transformation result tree.
Source	An object that implements this interface contains the information needed to act as source input (XML source or transformation instructions).
SourceLocator	This interface is primarily for the purposes of reporting where an error occurred in the XML source or transformation instructions.
Templates	An object that implements this interface is the runtime representation of processed transformation instructions.
URIResolver	An object that implements this interface that can be called by the processor to turn a URI used in document(), xsl:import, or xsl:include into a Source object.

Class Summary
Class	Description
OutputKeys	Provides string constants that can be used to set output properties for a Transformer, or to retrieve output properties from a Transformer or Templates object.
Transformer	An instance of this abstract class can transform a source tree into a result tree.
TransformerFactory	A TransformerFactory instance can be used to create `Transformer` and `Templates` objects.

Exception Summary
Exception	Description
TransformerConfigurationException	Indicates a serious configuration error.
TransformerException	This class specifies an exceptional condition that occurred during the transformation process.

Error Summary
Error	Description
TransformerFactoryConfigurationError	Thrown when a problem with configuration with the Transformer Factories exists.

javax.xml.transform.dom

Interface Summary
Interface	Description
DOMLocator	Indicates the position of a node in a source DOM, intended primarily for error reporting.

Class Summary
Class	Description
DOMResult	Acts as a holder for a transformation result tree in the form of a Document Object Model (DOM) tree.
DOMSource	Acts as a holder for a transformation Source tree in the form of a Document Object Model (DOM) tree.

javax.xml.transform.sax

Interface Summary
Interface	Description
TemplatesHandler	A SAX ContentHandler that may be used to process SAX parse events (parsing transformation instructions) into a Templates object.
TransformerHandler	A TransformerHandler listens for SAX ContentHandler parse events and transforms them to a Result.

Class Summary
Class	Description
SAXResult	Acts as an holder for a transformation Result.
SAXSource	Acts as an holder for SAX-style Source.
SAXTransformerFactory	This class extends TransformerFactory to provide SAX-specific factory methods.

javax.xml.transform.stax

Class Summary
Class	Description
StAXResult	Acts as a holder for an XML `Result` in the form of a StAX writer,i.e.
StAXSource	Acts as a holder for an XML `Source` in the form of a StAX reader,i.e.

javax.xml.transform.stream

Class Summary
Class	Description
StreamResult	Acts as an holder for a transformation result, which may be XML, plain Text, HTML, or some other form of markup.
StreamSource	Acts as an holder for a transformation Source in the form of a stream of XML markup.

javax.xml.validation

Class Summary
Class	Description
Schema	Immutable in-memory representation of grammar.
SchemaFactory	Factory that creates `Schema` objects. Entry-point to the validation API.
SchemaFactoryLoader	Factory that creates `SchemaFactory`.
TypeInfoProvider	This class provides access to the type information determined by `ValidatorHandler`.
Validator	A processor that checks an XML document against `Schema`.
ValidatorHandler	Streaming validator that works on SAX stream.

Error Summary
Error	Description
SchemaFactoryConfigurationError	Thrown when a problem with configuration with the Schema Factories exists.

javax.xml.xpath

Interface Summary
Interface	Description
XPath	`XPath` provides access to the XPath evaluation environment and expressions.
XPathExpression	`XPathExpression` provides access to compiled XPath expressions.
XPathFunction	`XPathFunction` provides access to XPath functions.
XPathFunctionResolver	`XPathFunctionResolver` provides access to the set of user defined `XPathFunction`s.
XPathVariableResolver	`XPathVariableResolver` provides access to the set of user defined XPath variables.

Class Summary
Class	Description
XPathConstants	XPath constants.
XPathFactory	An `XPathFactory` instance can be used to create `XPath` objects.

Exception Summary
Exception	Description
XPathException	`XPathException` represents a generic XPath exception.
XPathExpressionException	`XPathExpressionException` represents an error in an XPath expression.
XPathFactoryConfigurationException	`XPathFactoryConfigurationException` represents a configuration error in a `XPathFactory` environment.
XPathFunctionException	`XPathFunctionException` represents an error with an XPath function.

org.w3c.dom

Interface Summary
Interface	Description
Attr	The `Attr` interface represents an attribute in an `Element` object.
CDATASection	CDATA sections are used to escape blocks of text containing characters that would otherwise be regarded as markup.
CharacterData	The `CharacterData` interface extends Node with a set of attributes and methods for accessing character data in the DOM.
Comment	This interface inherits from `CharacterData` and represents the content of a comment, i.e., all the characters between the starting ' `<!--`' and ending '`-->`'.
Document	The `Document` interface represents the entire HTML or XML document.
DocumentFragment	`DocumentFragment` is a "lightweight" or "minimal" `Document` object.
DocumentType	Each `Document` has a `doctype` attribute whose value is either `null` or a `DocumentType` object.
DOMConfiguration	The `DOMConfiguration` interface represents the configuration of a document and maintains a table of recognized parameters.
DOMError	`DOMError` is an interface that describes an error.
DOMErrorHandler	`DOMErrorHandler` is a callback interface that the DOM implementation can call when reporting errors that happens while processing XML data, or when doing some other processing (e.g.
DOMImplementation	The `DOMImplementation` interface provides a number of methods for performing operations that are independent of any particular instance of the document object model.
DOMImplementationList	The `DOMImplementationList` interface provides the abstraction of an ordered collection of DOM implementations, without defining or constraining how this collection is implemented.
DOMImplementationSource	This interface permits a DOM implementer to supply one or more implementations, based upon requested features and versions, as specified in DOM Features.
DOMLocator	`DOMLocator` is an interface that describes a location (e.g.
DOMStringList	The `DOMStringList` interface provides the abstraction of an ordered collection of `DOMString` values, without defining or constraining how this collection is implemented.
Element	The `Element` interface represents an element in an HTML or XML document.
Entity	This interface represents a known entity, either parsed or unparsed, in an XML document.
EntityReference	`EntityReference` nodes may be used to represent an entity reference in the tree.
NamedNodeMap	Objects implementing the `NamedNodeMap` interface are used to represent collections of nodes that can be accessed by name.
NameList	The `NameList` interface provides the abstraction of an ordered collection of parallel pairs of name and namespace values (which could be null values), without defining or constraining how this collection is implemented.
Node	The `Node` interface is the primary datatype for the entire Document Object Model.
NodeList	The `NodeList` interface provides the abstraction of an ordered collection of nodes, without defining or constraining how this collection is implemented.
Notation	This interface represents a notation declared in the DTD.
ProcessingInstruction	The `ProcessingInstruction` interface represents a "processing instruction", used in XML as a way to keep processor-specific information in the text of the document.
Text	The `Text` interface inherits from `CharacterData` and represents the textual content (termed character data in XML) of an `Element` or `Attr`.
TypeInfo	The `TypeInfo` interface represents a type referenced from `Element` or `Attr` nodes, specified in the schemas associated with the document.
UserDataHandler	When associating an object to a key on a node using `Node.setUserData()` the application can provide a handler that gets called when the node the object is associated to is being cloned, imported, or renamed.

Exception Summary
Exception	Description
DOMException	DOM operations only raise exceptions in "exceptional" circumstances, i.e., when an operation is impossible to perform (either for logical reasons, because data is lost, or because the implementation has become unstable).

org.w3c.dom.bootstrap

Class Summary
Class	Description
DOMImplementationRegistry	A factory that enables applications to obtain instances of `DOMImplementation`.

org.w3c.dom.events

Interface Summary
Interface	Description
DocumentEvent	The `DocumentEvent` interface provides a mechanism by which the user can create an Event of a type supported by the implementation.
Event	The `Event` interface is used to provide contextual information about an event to the handler processing the event.
EventListener	The `EventListener` interface is the primary method for handling events.
EventTarget	The `EventTarget` interface is implemented by all `Nodes` in an implementation which supports the DOM Event Model.
MouseEvent	The `MouseEvent` interface provides specific contextual information associated with Mouse events.
MutationEvent	The `MutationEvent` interface provides specific contextual information associated with Mutation events.
UIEvent	The `UIEvent` interface provides specific contextual information associated with User Interface events.

Exception Summary
Exception	Description
EventException	Event operations may throw an `EventException` as specified in their method descriptions.

org.w3c.dom.ls

Interface Summary
Interface	Description
DOMImplementationLS	`DOMImplementationLS` contains the factory methods for creating Load and Save objects.
LSInput	This interface represents an input source for data.
LSLoadEvent	This interface represents a load event object that signals the completion of a document load.
LSOutput	This interface represents an output destination for data.
LSParser	An interface to an object that is able to build, or augment, a DOM tree from various input sources.
LSParserFilter	`LSParserFilter`s provide applications the ability to examine nodes as they are being constructed while parsing.
LSProgressEvent	This interface represents a progress event object that notifies the application about progress as a document is parsed.
LSResourceResolver	`LSResourceResolver` provides a way for applications to redirect references to external resources.
LSSerializer	A `LSSerializer` provides an API for serializing (writing) a DOM document out into XML.
LSSerializerFilter	`LSSerializerFilter`s provide applications the ability to examine nodes as they are being serialized and decide what nodes should be serialized or not.

Exception Summary
Exception	Description
LSException	Parser or write operations may throw an `LSException` if the processing is stopped.

org.w3c.dom.views

Interface Summary
Interface	Description
AbstractView	A base interface that all views shall derive from.
DocumentView	The `DocumentView` interface is implemented by `Document` objects in DOM implementations supporting DOM Views.

org.xml.sax

Interface Summary
Interface	Description
AttributeList	Deprecated This interface has been replaced by the SAX2 `Attributes` interface, which includes Namespace support.
Attributes	Interface for a list of XML attributes.
ContentHandler	Receive notification of the logical content of a document.
DocumentHandler	Deprecated This interface has been replaced by the SAX2 `ContentHandler` interface, which includes Namespace support.
DTDHandler	Receive notification of basic DTD-related events.
EntityResolver	Basic interface for resolving entities.
ErrorHandler	Basic interface for SAX error handlers.
Locator	Interface for associating a SAX event with a document location.
Parser	Deprecated This interface has been replaced by the SAX2 `XMLReader` interface, which includes Namespace support.
XMLFilter	Interface for an XML filter.
XMLReader	Interface for reading an XML document using callbacks.

Class Summary
Class	Description
HandlerBase	Deprecated This class works with the deprecated `DocumentHandler` interface.
InputSource	A single input source for an XML entity.

Exception Summary
Exception	Description
SAXException	Encapsulate a general SAX error or warning.
SAXNotRecognizedException	Exception class for an unrecognized identifier.
SAXNotSupportedException	Exception class for an unsupported operation.
SAXParseException	Encapsulate an XML parse error or warning.

org.xml.sax.ext

Interface Summary
Interface	Description
Attributes2	SAX2 extension to augment the per-attribute information provided though `Attributes`.
DeclHandler	SAX2 extension handler for DTD declaration events.
EntityResolver2	Extended interface for mapping external entity references to input sources, or providing a missing external subset.
LexicalHandler	SAX2 extension handler for lexical events.
Locator2	SAX2 extension to augment the entity information provided though a `Locator`.

Class Summary
Class	Description
Attributes2Impl	SAX2 extension helper for additional Attributes information, implementing the `Attributes2` interface.
DefaultHandler2	This class extends the SAX2 base handler class to support the SAX2 `LexicalHandler`, `DeclHandler`, and `EntityResolver2` extensions.
Locator2Impl	SAX2 extension helper for holding additional Entity information, implementing the `Locator2` interface.

org.xml.sax.helpers

Class Summary
Class	Description
AttributeListImpl	Deprecated This class implements a deprecated interface, `AttributeList`; that interface has been replaced by `Attributes`, which is implemented in the `AttributesImpl` helper class.
AttributesImpl	Default implementation of the Attributes interface.
DefaultHandler	Default base class for SAX2 event handlers.
LocatorImpl	Provide an optional convenience implementation of Locator.
NamespaceSupport	Encapsulate Namespace logic for use by applications using SAX, or internally by SAX drivers.
ParserAdapter	Adapt a SAX1 Parser as a SAX2 XMLReader.
ParserFactory	Deprecated This class works with the deprecated `Parser` interface.
XMLFilterImpl	Base class for deriving an XML filter.
XMLReaderAdapter	Adapt a SAX2 XMLReader as a SAX1 Parser.
XMLReaderFactory	Factory for creating an XML reader.

Skip navigation links

Java™ Platform
Standard Ed. 8

All Classes

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, 2022, Oracle and/or its affiliates. All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.