| Interface | Description | 
|---|---|
| Closeable | A  Closeableis a source or destination of data that can be closed. | 
| DataInput | The  DataInputinterface provides
 for reading bytes from a binary stream and
 reconstructing from them data in any of
 the Java primitive types. | 
| DataOutput | The  DataOutputinterface 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 | Description | 
|---|---|
| BufferedInputStream | A  BufferedInputStreamadds
 functionality to another input stream-namely,
 the ability to buffer the input and to
 support themarkandresetmethods. | 
| 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  ByteArrayInputStreamcontains
 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  FileInputStreamobtains input bytes
 from a file in a file system. | 
| FileOutputStream | A file output stream is an output stream for writing data to a
  Fileor to aFileDescriptor. | 
| 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  FilterInputStreamcontains
 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  PrintStreamadds 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  PushbackInputStreamadds
 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  SequenceInputStreamrepresents
 the logical concatenation of other input
 streams. | 
| SerializablePermission | This class is for Serializable permissions. | 
| StreamTokenizer | The  StreamTokenizerclass 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 | 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  IOExceptionwith 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 | Description | 
|---|---|
| IOError | Thrown when a serious I/O error has occurred. | 
| 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  charvalues. | 
| Cloneable | A class implements the  Cloneableinterface to
 indicate to theObject.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  Runnableinterface 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 | Description | 
|---|---|
| Boolean | The Boolean class wraps a value of the primitive type
  booleanin an object. | 
| Byte | The  Byteclass wraps a value of primitive typebytein an object. | 
| Character | The  Characterclass wraps a value of the primitive
 typecharin 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  Classrepresent 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  Compilerclass is provided to support Java-to-native-code
 compilers and related services. | 
| Double | The  Doubleclass wraps a value of the primitive typedoublein an object. | 
| Enum<E extends Enum<E>> | This is the common base class of all Java language enumeration types. | 
| Float | The  Floatclass wraps a value of primitive typefloatin 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  Integerclass wraps a value of the primitive typeintin an object. | 
| Long | The  Longclass wraps a value of the primitive typelongin an object. | 
| Math | The class  Mathcontains methods for performing basic
 numeric operations such as the elementary exponential, logarithm,
 square root, and trigonometric functions. | 
| Number | The abstract class  Numberis the superclass of platform
 classes representing numeric values that are convertible to the
 primitive typesbyte,double,float,int,long, andshort. | 
| Object | Class  Objectis the root of the class hierarchy. | 
| Package | Packageobjects contain version information
 about the implementation and specification of a Java package. | 
| Process | The  ProcessBuilder.start()andRuntime.execmethods create a native process and return an instance of a
 subclass ofProcessthat 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
  Runtimethat 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  Shortclass wraps a value of primitive typeshortin an object. | 
| StackTraceElement | An element in a stack trace, as returned by  Throwable.getStackTrace(). | 
| StrictMath | The class  StrictMathcontains methods for performing basic
 numeric operations such as the elementary exponential, logarithm,
 square root, and trigonometric functions. | 
| String | The  Stringclass represents character strings. | 
| StringBuffer | A thread-safe, mutable sequence of characters. | 
| StringBuilder | A mutable sequence of characters. | 
| System | The  Systemclass 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  Throwableclass is the superclass of all errors and
 exceptions in the Java language. | 
| Void | The  Voidclass is an uninstantiable placeholder class to hold a
 reference to theClassobject representing the Java keyword
 void. | 
| 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 | 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  forNamemethod in classClass. | 
| CloneNotSupportedException | Thrown to indicate that the  clonemethod in classObjecthas been called to clone an object, but that
 the object's class does not implement theCloneableinterface. | 
| 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  Exceptionand its subclasses are a form ofThrowablethat 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  newInstancemethod in classClass, 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  nullin 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 | RuntimeExceptionis 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  Stringmethods 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 | 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  invokedynamicinstruction 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  Erroris a subclass ofThrowablethat 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  newconstruct 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  LinkageErrorindicate 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  ClassLoaderinstance
 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 thenewexpression)
 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  ThreadDeathis 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 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). | 
| Interface | Description | 
|---|---|
| Annotation | The common interface extended by all annotation types. | 
| 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 | 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 | Description | 
|---|---|
| AnnotationFormatError | Thrown when the annotation parser attempts to read an annotation
 from a class file and determines that the annotation is malformed. | 
| 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.Repeatableis
 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. | 
| Interface | Description | 
|---|---|
| MethodHandleInfo | A symbolic reference obtained by cracking a direct method handle
 into its consitutent symbolic parts. | 
| Class | Description | 
|---|---|
| CallSite | |
| ConstantCallSite | A  ConstantCallSiteis aCallSitewhose 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  MutableCallSiteis aCallSitewhose target variable
 behaves like an ordinary field. | 
| SerializedLambda | Serialized form of a lambda expression. | 
| SwitchPoint | 
 A  SwitchPointis an object which can publish state transitions to other threads. | 
| VolatileCallSite | A  VolatileCallSiteis aCallSitewhose target acts like a volatile variable. | 
| Exception | Description | 
|---|---|
| LambdaConversionException | LambdaConversionException | 
| WrongMethodTypeException | Thrown to indicate that code has attempted to call a method handle
 via the wrong method type. | 
| 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. | 
| Interface | Description | 
|---|---|
| AnnotatedArrayType | AnnotatedArrayTyperepresents 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 | AnnotatedParameterizedTyperepresents the potentially annotated use
 of a parameterized type, whose type arguments may themselves represent
 annotated uses of types. | 
| AnnotatedType | AnnotatedTyperepresents the potentially annotated use of a type in
 the program currently running in this VM. | 
| AnnotatedTypeVariable | AnnotatedTypeVariablerepresents the potentially annotated use of a
 type variable, whose declaration may have bounds which themselves represent
 annotated uses of types. | 
| AnnotatedWildcardType | AnnotatedWildcardTyperepresents the potentially annotated use of a
 wildcard type argument, whose upper or lower bounds may themselves represent
 annotated uses of types. | 
| GenericArrayType | GenericArrayTyperepresents 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 | InvocationHandleris 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 | Description | 
|---|---|
| AccessibleObject | The AccessibleObject class is the base class for Field, Method and
 Constructor objects. | 
| Array | The  Arrayclass provides static methods to dynamically create and
 access Java arrays. | 
| Constructor<T> | Constructorprovides information about, and access to, a single
 constructor for a class. | 
| Executable | A shared superclass for the common functionality of  MethodandConstructor. | 
| Field | A  Fieldprovides information about, and dynamic access to, a
 single field of a class or an interface. | 
| Method | A  Methodprovides information about, and access to, a single method
 on a class or interface. | 
| Modifier | The Modifier class provides  staticmethods and
 constants to decode class and member access modifiers. | 
| Parameter | Information about method parameters. | 
| Proxy | Proxyprovides 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 | 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 packageattempts 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  invokemethod throws a
 checked exception (aThrowablethat is not assignable
 toRuntimeExceptionorError) that
 is not assignable to any of the exception types declared in thethrowsclause of the method that was invoked on the
 proxy instance and dispatched to the invocation handler. | 
| 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. | 
| 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  BigDecimalclass. | 
| Enum | Description | 
|---|---|
| RoundingMode | Specifies a rounding behavior for numerical operations
 capable of discarding precision. | 
| 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  URLstream
 protocol handlers. | 
| 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  ContentHandleris the superclass
 of all classes that read anObjectfrom aURLConnection. | 
| 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  SocketImplis 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  URLrepresents 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  URLConnectionis 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  URLStreamHandleris the common
 superclass for all stream protocol handlers. | 
| 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 | 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. | 
| 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 | 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. | 
| 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 | 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  SelectableChannelwith aSelector. | 
| Selector | A multiplexor of  SelectableChannelobjects. | 
| ServerSocketChannel | A selectable channel for stream-oriented listening sockets. | 
| SocketChannel | A selectable channel for stream-oriented connecting sockets. | 
| 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  SocketChannelthat 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  SocketChannelfor 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  finishConnectmethod of aSocketChannelis invoked without first
 successfully invoking itsconnectmethod. | 
| 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. | 
| 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. | 
| 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 | 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 | Description | 
|---|---|
| CoderMalfunctionError | Error thrown when the  decodeLoopmethod of
 aCharsetDecoder, or theencodeLoopmethod of aCharsetEncoder, throws an unexpected
 exception. | 
| Class | Description | 
|---|---|
| CharsetProvider | Charset service-provider class. | 
| 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  DirectoryStreamthat 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  Watchableis registered
 with aWatchService. | 
| WatchKey | A token representing the registration of a  watchableobject
 with aWatchService. | 
| WatchService | A watch service that watches registered objects for changes and
 events. | 
| 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  Permissionclass for link creation operations. | 
| Paths | |
| 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 | 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 | 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
  Pathbecause 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-onlyFileSystem. | 
| 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  createFileorcreateDirectorymethods. | 
| 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  UserPrincipalrepresenting 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  Principalrepresenting an identity used to determine access rights
 to objects in a file system. | 
| Class | Description | 
|---|---|
| AclEntry | An entry in an access control list (ACL). | 
| AclEntry.Builder | A builder of  AclEntryobjects. | 
| FileTime | Represents the value of a file's time stamp attribute. | 
| PosixFilePermissions | This class consists exclusively of static methods that operate on sets of
  PosixFilePermissionobjects. | 
| UserPrincipalLookupService | An object to lookup user and group principals by name. | 
| 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  permissionsattribute. | 
| Exception | Description | 
|---|---|
| UserPrincipalNotFoundException | Checked exception thrown when a lookup of  UserPrincipalfails because
 the principal does not exist. | 
| Class | Description | 
|---|---|
| FileSystemProvider | Service-provider class for file systems. | 
| FileTypeDetector | A file type detector for probing a file to guess its file type. | 
| Interface | Description | 
|---|---|
| Remote | The  Remoteinterface serves to identify interfaces whose
 methods may be invoked from a non-local virtual machine. | 
| Class | Description | 
|---|---|
| MarshalledObject<T> | A  MarshalledObjectcontains a byte stream with the serialized
 representation of an object given to its constructor. | 
| Naming | The  Namingclass provides methods for storing and obtaining
 references to remote objects in a remote object registry. | 
| RMISecurityManager | Deprecated Use  SecurityManagerinstead. | 
| Exception | Description | 
|---|---|
| AccessException | An  AccessExceptionis thrown by certain methods of thejava.rmi.Namingclass (specificallybind,rebind, andunbind) and methods of thejava.rmi.activation.ActivationSysteminterface to
 indicate that the caller does not have permission to perform the action
 requested by the method call. | 
| AlreadyBoundException | An  AlreadyBoundExceptionis thrown if an attempt
 is made to bind an object in the registry to a name that already
 has an associated binding. | 
| ConnectException | A  ConnectExceptionis thrown if a connection is refused
 to the remote host for a remote method call. | 
| ConnectIOException | A  ConnectIOExceptionis thrown if anIOExceptionoccurs while making a connection
 to the remote host for a remote method call. | 
| MarshalException | A  MarshalExceptionis thrown if ajava.io.IOExceptionoccurs while marshalling the remote call
 header, arguments or return value for a remote method call. | 
| NoSuchObjectException | A  NoSuchObjectExceptionis thrown if an attempt is made to
 invoke a method on an object that no longer exists in the remote virtual
 machine. | 
| NotBoundException | A  NotBoundExceptionis thrown if an attempt
 is made to lookup or unbind in the registry a name that has
 no associated binding. | 
| RemoteException | A  RemoteExceptionis the common superclass for a number of
 communication-related exceptions that may occur during the execution of a
 remote method call. | 
| RMISecurityException | Deprecated Use  SecurityExceptioninstead. | 
| ServerError | A  ServerErroris thrown as a result of a remote method
 invocation when anErroris 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  ServerExceptionis thrown as a result of a remote method
 invocation when aRemoteExceptionis 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  StubNotFoundExceptionis thrown if a valid stub class
 could not be found for a remote object when it is exported. | 
| UnexpectedException | An  UnexpectedExceptionis 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 thethrowsclause of the method in the remote interface. | 
| UnknownHostException | An  UnknownHostExceptionis thrown if ajava.net.UnknownHostExceptionoccurs while creating
 a connection to the remote host for a remote method call. | 
| UnmarshalException | An  UnmarshalExceptioncan 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 ajava.io.IOExceptionoccurs unmarshalling
 parameters (on the server side) or the return value (on the client side). | 
| Interface | Description | 
|---|---|
| ActivationInstantiator | An  ActivationInstantiatoris responsible for creating
 instances of "activatable" objects. | 
| ActivationMonitor | An  ActivationMonitoris specific to anActivationGroupand is obtained when a group is
 reported active via a call toActivationSystem.activeGroup(this is done
 internally). | 
| ActivationSystem | The  ActivationSystemprovides a means for registering
 groups and "activatable" objects to be activated within those groups. | 
| Activator | The  Activatorfacilitates remote object activation. | 
| Class | Description | 
|---|---|
| Activatable | The  Activatableclass 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  ActivationGroupis responsible for creating new
 instances of "activatable" objects in its group, informing itsActivationMonitorwhen either: its object's become
 active or inactive, or the group as a whole becomes inactive. | 
| ActivationGroup_Stub | ActivationGroup_Stubis a stub class
 for the subclasses ofjava.rmi.activation.ActivationGroupthat are exported as ajava.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 | 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  UnknownGroupExceptionis thrown by methods of classes and
 interfaces in thejava.rmi.activationpackage when theActivationGroupIDparameter to the method is determined to be
 invalid, i.e., not known by theActivationSystem. | 
| UnknownObjectException | An  UnknownObjectExceptionis thrown by methods of classes and
 interfaces in thejava.rmi.activationpackage when theActivationIDparameter to the method is determined to be
 invalid. | 
| Interface | Description | 
|---|---|
| DGC | The DGC abstraction is used for the server side of the distributed
 garbage collection algorithm. | 
| 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. | 
| Interface | Description | 
|---|---|
| Registry | Registryis 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 | Description | 
|---|---|
| LocateRegistry | LocateRegistryis 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. | 
| Interface | Description | 
|---|---|
| LoaderHandler | Deprecated no replacement | 
| RemoteCall | Deprecated no replacement. | 
| RemoteRef | RemoteRefrepresents the handle for a remote object. | 
| RMIClientSocketFactory | An  RMIClientSocketFactoryinstance is used by the RMI runtime
 in order to obtain client sockets for RMI calls. | 
| RMIFailureHandler | An  RMIFailureHandlercan be registered via theRMISocketFactory.setFailureHandlercall. | 
| RMIServerSocketFactory | An  RMIServerSocketFactoryinstance 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
  Unreferencedinterface to receive notification when there are
 no more clients that reference that remote object. | 
| Class | Description | 
|---|---|
| LogStream | Deprecated no replacement | 
| ObjID | An  ObjIDis used to identify a remote object exported
 to an RMI runtime. | 
| Operation | Deprecated no replacement | 
| RemoteObject | The  RemoteObjectclass implements thejava.lang.Objectbehavior for remote objects. | 
| RemoteObjectInvocationHandler | An implementation of the  InvocationHandlerinterface for
 use with Java Remote Method Invocation (Java RMI). | 
| RemoteServer | The  RemoteServerclass 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 | RMIClassLoadercomprises static methods to support
 dynamic class loading with RMI. | 
| RMIClassLoaderSpi | RMIClassLoaderSpiis the service provider interface forRMIClassLoader. | 
| RMISocketFactory | An  RMISocketFactoryinstance is used by the RMI runtime
 in order to obtain client and server sockets for RMI calls. | 
| UID | A  UIDrepresents an identifier that is unique over time
 with respect to the host it is generated on, or one of 216
 "well-known" identifiers. | 
| UnicastRemoteObject | Used for exporting a remote object with JRMP and obtaining a stub
 that communicates to the remote object. | 
| Exception | Description | 
|---|---|
| ExportException | An  ExportExceptionis aRemoteExceptionthrown if an attempt to export a remote object fails. | 
| ServerCloneException | A  ServerCloneExceptionis thrown if a remote exception occurs
 during the cloning of aUnicastRemoteObject. | 
| ServerNotActiveException | An  ServerNotActiveExceptionis anExceptionthrown during a call toRemoteServer.getClientHostif
 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. | 
| 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  DomainCombinerprovides a means to dynamically
 update the ProtectionDomains associated with the currentAccessControlContext. | 
| 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  KeyStoreentry types. | 
| KeyStore.Entry.Attribute | An attribute associated with a keystore entry. | 
| KeyStore.LoadStoreParameter | |
| 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 | 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  AlgorithmParameterGeneratorclass 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  AlgorithmParameterGeneratorclass, 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  AlgorithmParametersclass, 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  KeyFactoryclass. | 
| 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  KeyPairGeneratorclass, 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  KeyStoreentry that holds aPrivateKeyand corresponding certificate chain. | 
| KeyStore.SecretKeyEntry | A  KeyStoreentry that holds aSecretKey. | 
| KeyStore.TrustedCertificateEntry | A  KeyStoreentry that holds a trustedCertificate. | 
| KeyStoreSpi | This class defines the Service Provider Interface (SPI)
 for the  KeyStoreclass. | 
| 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  MessageDigestclass, 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  Policyclass. | 
| 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  SecureRandomclass. | 
| 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  Signatureclass, 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 | Description | 
|---|---|
| CryptoPrimitive | An enumeration of cryptographic primitives. | 
| KeyRep.Type | Key type. | 
| 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  GeneralSecurityExceptionclass 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)anddoPrivileged(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. | 
| Interface | Description | 
|---|---|
| CertPathBuilderResult | A specification of the result of a certification path builder algorithm. | 
| CertPathChecker | Performs one or more checks on each  Certificateof aCertPath. | 
| 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
  Certificates. | 
| CertStoreParameters | A specification of  CertStoreparameters. | 
| CRLSelector | A selector that defines a set of criteria for selecting  CRLs. | 
| 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 | 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  CertificateFactoryclass. | 
| CertPath | An immutable sequence of certificates (a certification path). | 
| CertPath.CertPathRep | Alternate  CertPathclass for serialization. | 
| CertPathBuilder | A class for building certification paths (also known as certificate chains). | 
| CertPathBuilderSpi | The Service Provider Interface (SPI)
 for the  CertPathBuilderclass. | 
| CertPathValidator | A class for validating certification paths (also known as certificate
 chains). | 
| CertPathValidatorSpi | The Service Provider Interface (SPI)
 for the  CertPathValidatorclass. | 
| CertStore | A class for retrieving  Certificates andCRLs
 from a repository. | 
| CertStoreSpi | The Service Provider Interface (SPI)
 for the  CertStoreclass. | 
| CollectionCertStoreParameters | Parameters used as input for the Collection  CertStorealgorithm. | 
| 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  CertStorealgorithm. | 
| PKIXBuilderParameters | Parameters used as input for the PKIX  CertPathBuilderalgorithm. | 
| 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  CertPathValidatoralgorithm. | 
| PKIXRevocationChecker | A  PKIXCertPathCheckerfor 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  CertSelectorthat selectsX509Certificatesthat
 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  CRLSelectorthat selectsX509CRLsthat
 match all specified criteria. | 
| Enum | Description | 
|---|---|
| CertPathValidatorException.BasicReason | The BasicReason enumerates the potential reasons that a certification
 path of any type may be invalid. | 
| CRLReason | The CRLReason enumeration specifies the reason that a certificate
 is revoked, as defined in 
 RFC 5280: Internet X.509 Public Key Infrastructure Certificate and CRL
 Profile. | 
| PKIXReason | The  PKIXReasonenumerates the potential PKIX-specific reasons
 that an X.509 certification path may be invalid according to the PKIX
 (RFC 5280) standard. | 
| PKIXRevocationChecker.Option | Various revocation options that can be specified for the revocation
 checking mechanism. | 
| Exception | 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. | 
| 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. | 
| 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 | 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 | Description | 
|---|---|
| InvalidKeySpecException | This is the exception for invalid key specifications. | 
| InvalidParameterSpecException | This is the exception for invalid parameter specifications. | 
| 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
  BLOBvalue. | 
| CallableStatement | The interface used to execute SQL stored procedures. | 
| Clob | The mapping in the Java™ programming language
 for the SQL  CLOBtype. | 
| 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  NCLOBtype. | 
| ParameterMetaData | An object that can be used to get information about the types
 and properties for each parameter marker in a
  PreparedStatementobject. | 
| PreparedStatement | An object that represents a precompiled SQL statement. | 
| Ref | The mapping in the Java programming language of an SQL  REFvalue, 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  ResultSetobject. | 
| 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.rollbackmethod. | 
| 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 | Description | 
|---|---|
| Date | A thin wrapper around a millisecond value that allows
 JDBC to identify this as an SQL  DATEvalue. | 
| DriverManager | The basic service for managing a set of JDBC drivers. NOTE: The DataSourceinterface, 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  SecurityManagerwill check
 when code that is running an application with aSecurityManagerenabled, calls theDriverManager.deregisterDrivermethod,DriverManager.setLogWritermethod,DriverManager.setLogStream(deprecated) method,SyncFactory.setJNDIContextmethod,SyncFactory.setLoggermethod,Connection.setNetworktimeoutmethod,
 or theConnection.abortmethod. | 
| Time | A thin wrapper around the  java.util.Dateclass that allows the JDBC
 API to identify this as an SQLTIMEvalue. | 
| Timestamp | A thin wrapper around  java.util.Datethat allows
 the JDBC API to identify this as an SQLTIMESTAMPvalue. | 
| Types | The class that defines the constants that are used to identify generic
 SQL types, called JDBC types. | 
| 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 | Description | 
|---|---|
| BatchUpdateException | The subclass of  SQLExceptionthrown when an error
 occurs during a batch update operation. | 
| DataTruncation | An exception  thrown as a  DataTruncationexception
 (on writes) or reported as aDataTruncationwarning (on reads)
  when a data values is unexpectedly truncated for reasons other than its having
  exceededMaxFieldSize. | 
| SQLClientInfoException | The subclass of  SQLExceptionis thrown when one or more client info properties
 could not be set on aConnection. | 
| SQLDataException | The subclass of  SQLExceptionthrown 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  SQLExceptionthrown when the SQLState class value is '0A'
 ( the value is 'zero' A). | 
| SQLIntegrityConstraintViolationException | The subclass of  SQLExceptionthrown when the SQLState class value
 is '23', or under vendor-specified conditions. | 
| SQLInvalidAuthorizationSpecException | The subclass of  SQLExceptionthrown when the SQLState class value
 is '28', or under vendor-specified conditions. | 
| SQLNonTransientConnectionException | The subclass of  SQLExceptionthrown for the SQLState
 class value '08', or under vendor-specified conditions. | 
| SQLNonTransientException | The subclass of  SQLExceptionthrown when an instance where a retry
 of the same operation would fail unless the cause of theSQLExceptionis corrected. | 
| SQLRecoverableException | The subclass of  SQLExceptionthrown 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  SQLExceptionthrown when the SQLState class value
 is '42', or under vendor-specified conditions. | 
| SQLTimeoutException | The subclass of  SQLExceptionthrown when the timeout specified byStatement.setQueryTimeout,DriverManager.setLoginTimeout,DataSource.setLoginTimeout,XADataSource.setLoginTimeouthas expired. | 
| SQLTransactionRollbackException | The subclass of  SQLExceptionthrown when the SQLState class value
 is '40', or under vendor-specified conditions. | 
| SQLTransientConnectionException | The subclass of  SQLExceptionfor the SQLState class
 value '08', or under vendor-specified conditions. | 
| SQLTransientException | The subclass of  SQLExceptionis 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. | 
| Interface | Description | 
|---|---|
| AttributedCharacterIterator | An  AttributedCharacterIteratorallows iteration through both text and
 related attribute information. | 
| CharacterIterator | This interface defines a protocol for bidirectional iteration over text. | 
| 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  BreakIteratorclass implements methods for finding
 the location of boundaries in text. | 
| ChoiceFormat | A  ChoiceFormatallows you to attach a format to a range of numbers. | 
| CollationElementIterator | The  CollationElementIteratorclass is used as an iterator
 to walk through each character of an international string. | 
| CollationKey | A  CollationKeyrepresents aStringunder the
 rules of a specificCollatorobject. | 
| Collator | The  Collatorclass performs locale-sensitiveStringcomparison. | 
| DateFormat | DateFormatis 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
  AttributedCharacterIteratorreturned
 fromDateFormat.formatToCharacterIteratorand as
 field identifiers inFieldPosition. | 
| DateFormatSymbols | DateFormatSymbolsis 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 | DecimalFormatis a concrete subclass ofNumberFormatthat formats decimal numbers. | 
| DecimalFormatSymbols | This class represents the set of symbols (such as the decimal separator,
 the grouping separator, and so on) needed by  DecimalFormatto format numbers. | 
| FieldPosition | FieldPositionis a simple class used byFormatand its subclasses to identify fields in formatted output. | 
| Format | Formatis 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
  AttributedCharacterIteratorreturned
 fromFormat.formatToCharacterIteratorand as
 field identifiers inFieldPosition. | 
| MessageFormat | MessageFormatprovides a means to produce concatenated
 messages in a language-neutral way. | 
| MessageFormat.Field | Defines constants that are used as attribute keys in the
  AttributedCharacterIteratorreturned
 fromMessageFormat.formatToCharacterIterator. | 
| Normalizer | This class provides the method  normalizewhich transforms Unicode
 text into an equivalent composed or decomposed form, allowing for easier
 sorting and searching of text. | 
| NumberFormat | NumberFormatis the abstract base class for all number
 formats. | 
| NumberFormat.Field | Defines constants that are used as attribute keys in the
  AttributedCharacterIteratorreturned
 fromNumberFormat.formatToCharacterIteratorand as
 field identifiers inFieldPosition. | 
| ParsePosition | ParsePositionis a simple class used byFormatand its subclasses to keep track of the current position during parsing. | 
| RuleBasedCollator | The  RuleBasedCollatorclass is a concrete subclass ofCollatorthat provides a simple, data-driven, table
 collator. | 
| SimpleDateFormat | SimpleDateFormatis a concrete class for formatting and
 parsing dates in a locale-sensitive manner. | 
| StringCharacterIterator | StringCharacterIteratorimplements theCharacterIteratorprotocol for aString. | 
| 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 | Description | 
|---|---|
| ParseException | Signals that an error has been reached unexpectedly
 while parsing. | 
| Class | Description | 
|---|---|
| BreakIteratorProvider | An abstract class for service providers that
 provide concrete implementations of the
  BreakIteratorclass. | 
| CollatorProvider | An abstract class for service providers that
 provide concrete implementations of the
  Collatorclass. | 
| DateFormatProvider | An abstract class for service providers that
 provide concrete implementations of the
  DateFormatclass. | 
| DateFormatSymbolsProvider | An abstract class for service providers that
 provide instances of the
  DateFormatSymbolsclass. | 
| DecimalFormatSymbolsProvider | An abstract class for service providers that
 provide instances of the
  DecimalFormatSymbolsclass. | 
| NumberFormatProvider | An abstract class for service providers that
 provide concrete implementations of the
  NumberFormatclass. | 
| 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 | Description | 
|---|---|
| DayOfWeek | A day-of-week, such as 'Tuesday'. | 
| Month | A month-of-year, such as 'July'. | 
| Exception | Description | 
|---|---|
| DateTimeException | Exception used to indicate a problem while calculating a date-time. | 
| 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 | 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 | 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. | 
| 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 | 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 | Description | 
|---|---|
| DateTimeParseException | An exception thrown when an error occurs during parsing. | 
| 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 | 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 | Description | 
|---|---|
| ChronoField | A standard set of fields. | 
| ChronoUnit | A standard set of date periods units. | 
| Exception | Description | 
|---|---|
| UnsupportedTemporalTypeException | UnsupportedTemporalTypeException indicates that a ChronoField or ChronoUnit is
 not supported for a Temporal class. | 
| 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 | Description | 
|---|---|
| ZoneOffsetTransitionRule.TimeDefinition | A definition of the way a local time can be converted to the actual
 transition date-time. | 
| Exception | Description | 
|---|---|
| ZoneRulesException | Thrown to indicate a problem with time-zone configuration. | 
| 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  SortedMapextended with navigation methods returning the
 closest matches for given search targets. | 
| NavigableSet<E> | A  SortedSetextended with navigation methods reporting
 closest matches for given search targets. | 
| Observer | A class can implement the  Observerinterface 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  doublevalues. | 
| PrimitiveIterator.OfInt | An Iterator specialized for  intvalues. | 
| PrimitiveIterator.OfLong | An Iterator specialized for  longvalues. | 
| 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  Mapthat further provides a total ordering on its keys. | 
| SortedSet<E> | A  Setthat 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  doublevalues. | 
| Spliterator.OfInt | A Spliterator specialized for  intvalues. | 
| Spliterator.OfLong | A Spliterator specialized for  longvalues. | 
| Spliterator.OfPrimitive<T,T_CONS,T_SPLITR extends Spliterator.OfPrimitive<T,T_CONS,T_SPLITR>> | A Spliterator specialized for primitive values. | 
| 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  Listinterface 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  Queueoperations. | 
| 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  Dequeinterface. | 
| 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  Calendarclass is an abstract class that provides methods
 for converting between a specific instant in time and a set ofcalendar fieldssuch asYEAR,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.Builderis used for creating aCalendarfrom
 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  Daterepresents a specific instant
 in time, with millisecond precision. | 
| Dictionary<K,V> | The  Dictionaryclass is the abstract parent of any
 class, such asHashtable, 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  Mapimplementation for use with enum type keys. | 
| EnumSet<E extends Enum<E>> | A specialized  Setimplementation for use with enum types. | 
| EventListenerProxy<T extends EventListener> | An abstract wrapper class for an  EventListenerclass
 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 | GregorianCalendaris a concrete subclass ofCalendarand 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  ListandDequeinterfaces. | 
| ListResourceBundle | ListResourceBundleis an abstract subclass ofResourceBundlethat manages resources for a locale
 in a convenient and easy to use list. | 
| Locale | A  Localeobject represents a specific geographical, political,
 or cultural region. | 
| Locale.Builder | Builderis used to build instances ofLocalefrom 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  staticutility 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  doublevalue. | 
| OptionalInt | A container object which may or may not contain a  intvalue. | 
| OptionalLong | A container object which may or may not contain a  longvalue. | 
| PriorityQueue<E> | An unbounded priority queue based on a priority heap. | 
| Properties | The  Propertiesclass represents a persistent set of
 properties. | 
| PropertyPermission | This class is for property permissions. | 
| PropertyResourceBundle | PropertyResourceBundleis a concrete subclass ofResourceBundlethat 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.Controldefines a set of callback methods
 that are invoked by theResourceBundle.getBundlefactory
 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 | SimpleTimeZoneis a concrete subclass ofTimeZonethat represents a time zone for use with a Gregorian calendar. | 
| Spliterators | Static classes and methods for operating on or creating instances of
  Spliteratorand its primitive specializationsSpliterator.OfInt,Spliterator.OfLong, andSpliterator.OfDouble. | 
| Spliterators.AbstractDoubleSpliterator | An abstract  Spliterator.OfDoublethat implementstrySplitto permit limited parallelism. | 
| Spliterators.AbstractIntSpliterator | An abstract  Spliterator.OfIntthat implementstrySplitto
 permit limited parallelism. | 
| Spliterators.AbstractLongSpliterator | An abstract  Spliterator.OfLongthat implementstrySplitto permit limited parallelism. | 
| Spliterators.AbstractSpliterator<T> | An abstract  Spliteratorthat implementstrySplitto
 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  Stackclass represents a last-in-first-out
 (LIFO) stack of objects. | 
| StringJoiner | StringJoineris 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 | TimeZonerepresents a time zone offset, and also figures out daylight
 savings. | 
| TreeMap<K,V> | A Red-Black tree based  NavigableMapimplementation. | 
| TreeSet<E> | A  NavigableSetimplementation based on aTreeMap. | 
| UUID | A class that represents an immutable universally unique identifier (UUID). | 
| Vector<E> | The  Vectorclass implements a growable array of
 objects. | 
| WeakHashMap<K,V> | Hash table based implementation of the Map interface, with
 weak keys. | 
| Enum | Description | 
|---|---|
| Formatter.BigDecimalLayoutForm | Enum for  BigDecimalformatting. | 
| Locale.Category | Enum for locale categories. | 
| Locale.FilteringMode | This enum provides constants to select a filtering mode for locale
 matching. | 
| 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  Stackclass 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 theFormatter. | 
| 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  LocaleandLocale.Builderto
 indicate that an argument is not a well-formed BCP 47 tag. | 
| InputMismatchException | Thrown by a  Scannerto 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  Propertiesspecification. | 
| 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 | Description | 
|---|---|
| ServiceConfigurationError | Error thrown when something goes wrong while loading a service provider. | 
| Interface | Description | 
|---|---|
| BlockingDeque<E> | A  Dequethat 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  Queuethat 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
  asyncmethods. | 
| 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  Mapproviding thread safety and atomicity
 guarantees. | 
| ConcurrentNavigableMap<K,V> | A  ConcurrentMapsupportingNavigableMapoperations,
 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  Runnabletasks. | 
| ExecutorService | |
| ForkJoinPool.ForkJoinWorkerThreadFactory | Factory for creating new  ForkJoinWorkerThreads. | 
| ForkJoinPool.ManagedBlocker | Interface for extending managed parallelism for tasks running
 in  ForkJoinPools. | 
| Future<V> | A  Futurerepresents the result of an asynchronous
 computation. | 
| RejectedExecutionHandler | A handler for tasks that cannot be executed by a  ThreadPoolExecutor. | 
| RunnableFuture<V> | |
| RunnableScheduledFuture<V> | A  ScheduledFuturethat isRunnable. | 
| ScheduledExecutorService | An  ExecutorServicethat 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  BlockingQueuein which producers may wait for consumers
 to receive elements. | 
| Class | Description | 
|---|---|
| AbstractExecutorService | Provides default implementations of  ExecutorServiceexecution methods. | 
| ArrayBlockingQueue<E> | A bounded blocking queue backed by an
 array. | 
| CompletableFuture<T> | A  Futurethat may be explicitly completed (setting its
 value and status), and may be used as aCompletionStage,
 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  Setof 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  ConcurrentNavigableMapimplementation. | 
| ConcurrentSkipListSet<E> | A scalable concurrent  NavigableSetimplementation based on
 aConcurrentSkipListMap. | 
| CopyOnWriteArrayList<E> | A thread-safe variant of  ArrayListin which all mutative
 operations (add,set, and so on) are implemented by
 making a fresh copy of the underlying array. | 
| CopyOnWriteArraySet<E> | A  Setthat uses an internalCopyOnWriteArrayListfor 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  ForkJoinTaskwith 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
  Delayedelements, 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  CompletionServicethat uses a suppliedExecutorto execute tasks. | 
| Executors | Factory and utility methods for  Executor,ExecutorService,ScheduledExecutorService,ThreadFactory, andCallableclasses defined in this
 package. | 
| ForkJoinPool | An  ExecutorServicefor runningForkJoinTasks. | 
| ForkJoinTask<V> | Abstract base class for tasks that run within a  ForkJoinPool. | 
| ForkJoinWorkerThread | A thread managed by a  ForkJoinPool, which executesForkJoinTasks. | 
| 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  TransferQueuebased on linked nodes. | 
| Phaser | A reusable synchronization barrier, similar in functionality to
  CyclicBarrierandCountDownLatchbut supporting more flexible usage. | 
| PriorityBlockingQueue<E> | An unbounded blocking queue that uses
 the same ordering rules as class  PriorityQueueand supplies
 blocking retrieval operations. | 
| RecursiveAction | A recursive resultless  ForkJoinTask. | 
| RecursiveTask<V> | A recursive result-bearing  ForkJoinTask. | 
| ScheduledThreadPoolExecutor | A  ThreadPoolExecutorthat 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  ExecutorServicethat executes each submitted task using
 one of possibly several pooled threads, normally configured
 usingExecutorsfactory 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  executemethod,
 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 | Description | 
|---|---|
| TimeUnit | A  TimeUnitrepresents 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 | 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  Executorwhen a task cannot be
 accepted for execution. | 
| TimeoutException | Exception thrown when a blocking operation times out. | 
| Class | Description | 
|---|---|
| AtomicBoolean | A  booleanvalue that may be updated atomically. | 
| AtomicInteger | An  intvalue that may be updated atomically. | 
| AtomicIntegerArray | An  intarray in which elements may be updated atomically. | 
| AtomicIntegerFieldUpdater<T> | A reflection-based utility that enables atomic updates to
 designated  volatile intfields of designated classes. | 
| AtomicLong | A  longvalue that may be updated atomically. | 
| AtomicLongArray | A  longarray in which elements may be updated atomically. | 
| AtomicLongFieldUpdater<T> | A reflection-based utility that enables atomic updates to
 designated  volatile longfields of designated classes. | 
| AtomicMarkableReference<V> | An  AtomicMarkableReferencemaintains 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  volatilereference fields of designated
 classes. | 
| AtomicStampedReference<V> | An  AtomicStampedReferencemaintains an object reference
 along with an integer "stamp", that can be updated atomically. | 
| DoubleAccumulator | One or more variables that together maintain a running  doublevalue updated using a supplied function. | 
| DoubleAdder | One or more variables that together maintain an initially zero
  doublesum. | 
| LongAccumulator | One or more variables that together maintain a running  longvalue updated using a supplied function. | 
| LongAdder | One or more variables that together maintain an initially zero
  longsum. | 
| Interface | Description | 
|---|---|
| Condition | |
| Lock | Lockimplementations provide more extensive locking
 operations than can be obtained usingsynchronizedmethods
 and statements. | 
| ReadWriteLock | A  ReadWriteLockmaintains a pair of associatedlocks, one for read-only operations and one for writing. | 
| Class | Description | 
|---|---|
| AbstractOwnableSynchronizer | A synchronizer that may be exclusively owned by a thread. | 
| AbstractQueuedLongSynchronizer | A version of  AbstractQueuedSynchronizerin
 which synchronization state is maintained as along. | 
| 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  Lockwith the same basic
 behavior and semantics as the implicit monitor lock accessed usingsynchronizedmethods and statements, but with extended
 capabilities. | 
| ReentrantReadWriteLock | An implementation of  ReadWriteLocksupporting similar
 semantics toReentrantLock. | 
| 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. | 
| 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 adouble-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
 adouble-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 anint-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
 anint-valued result. | 
| LongBinaryOperator | Represents an operation upon two  long-valued operands and producing along-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
 along-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. | 
| 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 | 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  JarFileclass is used to read the contents of a jar file
 from any file that can be opened withjava.io.RandomAccessFile. | 
| JarInputStream | The  JarInputStreamclass is used to read the contents of
 a JAR file from any input stream. | 
| JarOutputStream | The  JarOutputStreamclass 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 | Description | 
|---|---|
| JarException | Signals that an error of some sort has occurred while reading from
 or writing to a JAR file. | 
| 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 | 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  LogRecordin a human readable
 format. | 
| SocketHandler | Simple network logging Handler. | 
| StreamHandler | Stream based logging Handler. | 
| XMLFormatter | Format a LogRecord into a standard XML format. | 
| Interface | Description | 
|---|---|
| MatchResult | The result of a match operation. | 
| 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 | Description | 
|---|---|
| PatternSyntaxException | Unchecked exception thrown to indicate a syntax error in a
 regular-expression pattern. | 
| Interface | Description | 
|---|---|
| ResourceBundleControlProvider | An interface for service providers that provide implementations of  ResourceBundle.Control. | 
| Class | Description | 
|---|---|
| CalendarDataProvider | An abstract class for service providers that provide locale-dependent  Calendarparameters. | 
| CalendarNameProvider | An abstract class for service providers that provide localized string
 representations (display names) of  Calendarfield values. | 
| CurrencyNameProvider | An abstract class for service providers that
 provide localized currency symbols and display names for the
  Currencyclass. | 
| LocaleNameProvider | An abstract class for service providers that
 provide localized names for the
  Localeclass. | 
| 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
  TimeZoneclass. | 
| 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 | Description | 
|---|---|
| Collectors | Implementations of  Collectorthat 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 | Description | 
|---|---|
| Collector.Characteristics | Characteristics indicating properties of a  Collector, which can
 be used to optimize reduction implementations. | 
| Interface | Description | 
|---|---|
| Checksum | An interface representing a data checksum. | 
| 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 | Description | 
|---|---|
| DataFormatException | Signals that a data format error has occurred. | 
| ZipException | Signals that a Zip exception of some sort has occurred. | 
| Error | Description | 
|---|---|
| ZipError | Signals that an unrecoverable error has occurred. | 
| Interface | Description | 
|---|---|
| SecretKey | A secret (symmetric) key. | 
| 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  Cipherclass. | 
| EncryptedPrivateKeyInfo | This class implements the  EncryptedPrivateKeyInfotype
 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  ExemptionMechanismclass. | 
| 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  KeyAgreementclass. | 
| KeyGenerator | This class provides the functionality of a secret (symmetric) key generator. | 
| KeyGeneratorSpi | This class defines the Service Provider Interface (SPI)
 for the  KeyGeneratorclass. | 
| Mac | This class provides the functionality of a "Message Authentication Code"
 (MAC) algorithm. | 
| MacSpi | This class defines the Service Provider Interface (SPI)
 for the  Macclass. | 
| 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  SecretKeyFactoryclass. | 
| Exception | Description | 
|---|---|
| AEADBadTagException | This exception is thrown when a  Cipheroperating 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. | 
| 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. | 
| 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  Cipherusing 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. | 
| Class | Description | 
|---|---|
| ServerSocketFactory | This class creates server sockets. | 
| SocketFactory | This class creates sockets. | 
| 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  SSLSessionContextrepresents a set ofSSLSessions 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 | Description | 
|---|---|
| CertPathTrustManagerParameters | A wrapper for CertPathParameters. | 
| ExtendedSSLSession | Extends the  SSLSessioninterface to support additional
 session attributes. | 
| HandshakeCompletedEvent | This event indicates that an SSL handshake completed on a given
 SSL connection. | 
| HttpsURLConnection | HttpsURLConnectionextendsHttpURLConnectionwith 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  KeyManagerFactoryclass. | 
| 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_namein a Server Name
 Indication (SNI) extension. | 
| SNIMatcher | Instances of this class represent a matcher that performs match
 operations on an  SNIServerNameinstance. | 
| 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  SSLEngines. | 
| SSLContextSpi | This class defines the Service Provider Interface (SPI)
 for the  SSLContextclass. | 
| 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
  SSLEngineI/O calls. | 
| SSLParameters | Encapsulates parameters for an SSL/TLS connection. | 
| SSLPermission | This class is for various network permissions. | 
| SSLServerSocket | This class extends  ServerSockets and
 provides secure server sockets using protocols such as the Secure
 Sockets Layer (SSL) or Transport Layer Security (TLS) protocols. | 
| SSLServerSocketFactory | SSLServerSocketFactorys createSSLServerSockets. | 
| SSLSessionBindingEvent | This event is propagated to a SSLSessionBindingListener. | 
| SSLSocket | This class extends  Sockets and provides secure
 socket using protocols such as the "Secure
 Sockets Layer" (SSL) or IETF "Transport Layer Security" (TLS) protocols. | 
| SSLSocketFactory | SSLSocketFactorys createSSLSockets. | 
| 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  TrustManagerFactoryclass. | 
| X509ExtendedKeyManager | Abstract class that provides for extension of the X509KeyManager
 interface. | 
| X509ExtendedTrustManager | Extensions to the  X509TrustManagerinterface to support
 SSL/TLS connection sensitive trust management. | 
| Enum | Description | 
|---|---|
| SSLEngineResult.HandshakeStatus | An  SSLEngineResultenum describing the current
 handshaking state of thisSSLEngine. | 
| SSLEngineResult.Status | An  SSLEngineResultenum describing the overall result
 of theSSLEngineoperation. | 
| 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. | 
| Class | Description | 
|---|---|
| SslRMIClientSocketFactory | An  SslRMIClientSocketFactoryinstance is used by the RMI
 runtime in order to obtain client sockets for RMI calls via SSL. | 
| SslRMIServerSocketFactory | An  SslRMIServerSocketFactoryinstance is used by the RMI
 runtime in order to obtain server sockets for RMI calls via SSL. | 
| 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 | ScriptEngineis the fundamental interface whose methods must be
 fully functional in every implementation of this specification. | 
| ScriptEngineFactory | ScriptEngineFactoryis used to describe and instantiateScriptEngines. | 
| Class | Description | 
|---|---|
| AbstractScriptEngine | Provides a standard implementation for several of the variants of the  evalmethod. | 
| CompiledScript | Extended by classes that store results of compilations. | 
| ScriptEngineManager | The  ScriptEngineManagerimplements a discovery and instantiation
 mechanism forScriptEngineclasses 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  HashMapor some other specifiedMap. | 
| SimpleScriptContext | Simple implementation of ScriptContext. | 
| Exception | Description | 
|---|---|
| ScriptException | The generic  Exceptionclass for the Scripting APIs. | 
| 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 | 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  Subjectrepresents a grouping of related information
 for a single entity, such as a person. | 
| SubjectDomainCombiner | A  SubjectDomainCombinerupdates ProtectionDomains
 with Principals from theSubjectassociated with thisSubjectDomainCombiner. | 
| Exception | Description | 
|---|---|
| DestroyFailedException | Signals that a  destroyoperation failed. | 
| RefreshFailedException | Signals that a  refreshoperation failed. | 
| 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  CallbackHandlerand 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 | Description | 
|---|---|
| ChoiceCallback |  Underlying security services instantiate and pass a
  ChoiceCallbackto thehandlemethod of aCallbackHandlerto display a list of choices
 and to retrieve the selected choice(s). | 
| ConfirmationCallback |  Underlying security services instantiate and pass a
  ConfirmationCallbackto thehandlemethod of aCallbackHandlerto ask for YES/NO,
 OK/CANCEL, YES/NO/CANCEL or other similar confirmations. | 
| LanguageCallback |  Underlying security services instantiate and pass a
  LanguageCallbackto thehandlemethod of aCallbackHandlerto retrieve theLocaleused for localizing text. | 
| NameCallback |  Underlying security services instantiate and pass a
  NameCallbackto thehandlemethod of aCallbackHandlerto retrieve name information. | 
| PasswordCallback |  Underlying security services instantiate and pass a
  PasswordCallbackto thehandlemethod of aCallbackHandlerto retrieve password information. | 
| TextInputCallback |  Underlying security services instantiate and pass a
  TextInputCallbackto thehandlemethod of aCallbackHandlerto retrieve generic text
 information. | 
| TextOutputCallback |  Underlying security services instantiate and pass a
  TextOutputCallbackto thehandlemethod of aCallbackHandlerto display information messages,
 warning messages and error messages. | 
| Exception | Description | 
|---|---|
| UnsupportedCallbackException | Signals that a  CallbackHandlerdoes not
 recognize a particularCallback. | 
| Interface | Description | 
|---|---|
| Configuration.Parameters | This represents a marker interface for Configuration parameters. | 
| Class | Description | 
|---|---|
| AppConfigurationEntry | This class represents a single  LoginModuleentry
 configured for the application specified in thegetAppConfigurationEntry(String appName)method in theConfigurationclass. | 
| AppConfigurationEntry.LoginModuleControlFlag | This class represents whether or not a  LoginModuleis 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  Configurationclass. | 
| LoginContext |  The  LoginContextclass describes the basic methods used
 to authenticate Subjects and provides a way to develop an
 application independent of the underlying authentication technology. | 
| 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  Credentialhas expired. | 
| CredentialNotFoundException | Signals that a credential was not found. | 
| FailedLoginException | Signals that user authentication failed. | 
| LoginException | This is the basic login exception. | 
| Interface | Description | 
|---|---|
| LoginModule | LoginModuledescribes the interface
 implemented by authentication technology providers. | 
| Class | Description | 
|---|---|
| X500Principal |  This class represents an X.500  Principal. | 
| X500PrivateCredential |  This class represents an  X500PrivateCredential. | 
| Class | Description | 
|---|---|
| Certificate | Abstract class for managing a variety of identity certificates. | 
| X509Certificate | Abstract class for X.509 v1 certificates. | 
| 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. | 
| Interface | Description | 
|---|---|
| CommonDataSource | Interface that defines the methods which are common between  DataSource,XADataSourceandConnectionPoolDataSource. | 
| ConnectionEventListener | 
 An object that registers to be notified of events generated by a
  PooledConnectionobject. | 
| ConnectionPoolDataSource | A factory for  PooledConnectionobjects. | 
| DataSource | A factory for connections to the physical data source that this
  DataSourceobject 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  RowSetobject implements in order to
 present itself to aRowSetReaderorRowSetWriterobject. | 
| 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  RowSetobject. | 
| RowSetMetaData | An object that contains information about the columns in a
  RowSetobject. | 
| RowSetReader | The facility that a disconnected  RowSetobject calls on
 to populate itself with rows of data. | 
| RowSetWriter | An object that implements the  RowSetWriterinterface,
 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  XAConnectionobjects that is used internally. | 
| Class | Description | 
|---|---|
| ConnectionEvent | An  Eventobject that provides information about the
 source of a connection-related event. | 
| RowSetEvent | An  Eventobject generated when an event occurs to aRowSetobject. | 
| StatementEvent | A  StatementEventis sent to allStatementEventListeners which were
 registered with aPooledConnection. | 
| 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. | 
| 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 | Description | 
|---|---|
| XAException | The XAException is thrown by the Resource Manager (RM) to inform the
 Transaction Manager of an error encountered by the involved transaction. | 
| Class | Description | 
|---|---|
| XMLConstants | Utility class to contain basic XML values as constants. | 
| Class | Description | 
|---|---|
| DatatypeConstants | Utility class to contain basic Datatype values as constants. | 
| DatatypeConstants.Field | Type-safe enum class that represents six fields
 of the  Durationclass. | 
| DatatypeFactory | Factory that creates new  javax.xml.datatypeObjects that map XML to/from JavaObjects. | 
| 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 | Description | 
|---|---|
| DatatypeConfigurationException | Indicates a serious configuration error. | 
| Interface | Description | 
|---|---|
| NamespaceContext | Interface for read only XML Namespace context processing. | 
| Class | Description | 
|---|---|
| QName | QNamerepresents a qualified name
 as defined in the XML specifications: XML Schema Part2:
 Datatypes specification, Namespaces
 in XML, Namespaces
 in XML Errata. | 
| 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  XMLReaderimplementation class. | 
| SAXParserFactory | Defines a factory API that enables applications to configure and
 obtain a SAX based parser to parse XML documents. | 
| Exception | Description | 
|---|---|
| ParserConfigurationException | Indicates a serious configuration error. | 
| Error | Description | 
|---|---|
| FactoryConfigurationError | Thrown when a problem with configuration with the Parser Factories
 exists. | 
| 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 | 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 | Description | 
|---|---|
| XMLStreamException | The base exception for unexpected processing errors. | 
| Error | Description | 
|---|---|
| FactoryConfigurationError | An error class for reporting factory configuration errors. | 
| 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. | 
| 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 | 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. | 
| Interface | Description | 
|---|---|
| ErrorListener | To provide customized error handling, implement this interface and
 use the  setErrorListenermethod to register an instance of the
 implmentation with theTransformer. | 
| 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 | 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
  TransformerandTemplatesobjects. | 
| Exception | Description | 
|---|---|
| TransformerConfigurationException | Indicates a serious configuration error. | 
| TransformerException | This class specifies an exceptional condition that occurred
 during the transformation process. | 
| Error | Description | 
|---|---|
| TransformerFactoryConfigurationError | Thrown when a problem with configuration with the Transformer Factories
 exists. | 
| Interface | Description | 
|---|---|
| DOMLocator | Indicates the position of a node in a source DOM, intended
 primarily for error reporting. | 
| 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. | 
| 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 | 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. | 
| Class | Description | 
|---|---|
| StAXResult | Acts as a holder for an XML  Resultin the
 form of a StAX writer,i.e. | 
| StAXSource | Acts as a holder for an XML  Sourcein the
 form of a StAX reader,i.e. | 
| 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. | 
| Class | Description | 
|---|---|
| Schema | Immutable in-memory representation of grammar. | 
| SchemaFactory | Factory that creates  Schemaobjects. 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 | Description | 
|---|---|
| SchemaFactoryConfigurationError | Thrown when a problem with configuration with the Schema Factories
 exists. | 
| Interface | Description | 
|---|---|
| XPath | XPathprovides access to the XPath evaluation environment and expressions. | 
| XPathExpression | XPathExpressionprovides access to compiled XPath expressions. | 
| XPathFunction | XPathFunctionprovides access to XPath functions. | 
| XPathFunctionResolver | XPathFunctionResolverprovides access to the set of user definedXPathFunctions. | 
| XPathVariableResolver | XPathVariableResolverprovides access to the set of user defined XPath variables. | 
| Class | Description | 
|---|---|
| XPathConstants | XPath constants. | 
| XPathFactory | An  XPathFactoryinstance can be used to createXPathobjects. | 
| Exception | Description | 
|---|---|
| XPathException | XPathExceptionrepresents a generic XPath exception. | 
| XPathExpressionException | XPathExpressionExceptionrepresents an error in an XPath expression. | 
| XPathFactoryConfigurationException | XPathFactoryConfigurationExceptionrepresents a configuration error in aXPathFactoryenvironment. | 
| XPathFunctionException | XPathFunctionExceptionrepresents an error with an XPath function. | 
| Interface | Description | 
|---|---|
| Attr | The  Attrinterface represents an attribute in anElementobject. | 
| CDATASection | CDATA sections are used to escape blocks of text containing characters that
 would otherwise be regarded as markup. | 
| CharacterData | The  CharacterDatainterface extends Node with a set of
 attributes and methods for accessing character data in the DOM. | 
| Comment | This interface inherits from  CharacterDataand represents the
 content of a comment, i.e., all the characters between the starting '<!--' and ending '-->'. | 
| Document | The  Documentinterface represents the entire HTML or XML
 document. | 
| DocumentFragment | DocumentFragmentis a "lightweight" or "minimal"Documentobject. | 
| DocumentType | Each  Documenthas adoctypeattribute whose value
 is eithernullor aDocumentTypeobject. | 
| DOMConfiguration | The  DOMConfigurationinterface represents the configuration
 of a document and maintains a table of recognized parameters. | 
| DOMError | DOMErroris an interface that describes an error. | 
| DOMErrorHandler | DOMErrorHandleris 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  DOMImplementationinterface provides a number of methods
 for performing operations that are independent of any particular instance
 of the document object model. | 
| DOMImplementationList | The  DOMImplementationListinterface 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 | DOMLocatoris an interface that describes a location (e.g. | 
| DOMStringList | The  DOMStringListinterface provides the abstraction of an
 ordered collection ofDOMStringvalues, without defining or
 constraining how this collection is implemented. | 
| Element | The  Elementinterface 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 | EntityReferencenodes may be used to represent an entity
 reference in the tree. | 
| NamedNodeMap | Objects implementing the  NamedNodeMapinterface are used to
 represent collections of nodes that can be accessed by name. | 
| NameList | The  NameListinterface 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  Nodeinterface is the primary datatype for the entire
 Document Object Model. | 
| NodeList | The  NodeListinterface 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  ProcessingInstructioninterface represents a "processing
 instruction", used in XML as a way to keep processor-specific information
 in the text of the document. | 
| Text | The  Textinterface inherits fromCharacterDataand represents the textual content (termed character data in XML) of anElementorAttr. | 
| TypeInfo | The  TypeInfointerface represents a type referenced fromElementorAttrnodes, 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 | 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). | 
| Class | Description | 
|---|---|
| DOMImplementationRegistry | A factory that enables applications to obtain instances of
  DOMImplementation. | 
| Interface | Description | 
|---|---|
| DocumentEvent | The  DocumentEventinterface provides a mechanism by which the
 user can create an Event of a type supported by the implementation. | 
| Event | The  Eventinterface is used to provide contextual information
 about an event to the handler processing the event. | 
| EventListener | The  EventListenerinterface is the primary method for
 handling events. | 
| EventTarget | The  EventTargetinterface is implemented by allNodesin an implementation which supports the DOM Event
 Model. | 
| MouseEvent | The  MouseEventinterface provides specific contextual
 information associated with Mouse events. | 
| MutationEvent | The  MutationEventinterface provides specific contextual
 information associated with Mutation events. | 
| UIEvent | The  UIEventinterface provides specific contextual information
 associated with User Interface events. | 
| Exception | Description | 
|---|---|
| EventException | Event operations may throw an  EventExceptionas specified in
 their method descriptions. | 
| Interface | Description | 
|---|---|
| DOMImplementationLS | DOMImplementationLScontains 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 | LSParserFilters 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 | LSResourceResolverprovides a way for applications to
 redirect references to external resources. | 
| LSSerializer | A  LSSerializerprovides an API for serializing (writing) a
 DOM document out into XML. | 
| LSSerializerFilter | LSSerializerFilters provide applications the ability to
 examine nodes as they are being serialized and decide what nodes should
 be serialized or not. | 
| Exception | Description | 
|---|---|
| LSException | Parser or write operations may throw an  LSExceptionif the
 processing is stopped. | 
| Interface | Description | 
|---|---|
| AbstractView | A base interface that all views shall derive from. | 
| DocumentView | The  DocumentViewinterface is implemented byDocumentobjects in DOM implementations supporting DOM
 Views. | 
| Interface | Description | 
|---|---|
| AttributeList | Deprecated This interface has been replaced by the SAX2
              Attributesinterface, 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
              ContentHandlerinterface, 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
              XMLReaderinterface, which includes Namespace support. | 
| XMLFilter | Interface for an XML filter. | 
| XMLReader | Interface for reading an XML document using callbacks. | 
| Class | Description | 
|---|---|
| HandlerBase | Deprecated This class works with the deprecated
              DocumentHandlerinterface. | 
| InputSource | A single input source for an XML entity. | 
| 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. | 
| 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 | Description | 
|---|---|
| Attributes2Impl | SAX2 extension helper for additional Attributes information,
 implementing the  Attributes2interface. | 
| DefaultHandler2 | This class extends the SAX2 base handler class to support the
 SAX2  LexicalHandler,DeclHandler, andEntityResolver2extensions. | 
| Locator2Impl | SAX2 extension helper for holding additional Entity information,
 implementing the  Locator2interface. | 
| Class | Description | 
|---|---|
| AttributeListImpl | Deprecated This class implements a deprecated interface,
              AttributeList;
             that interface has been replaced byAttributes,
             which is implemented in theAttributesImplhelper 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
              Parserinterface. | 
| XMLFilterImpl | Base class for deriving an XML filter. | 
| XMLReaderAdapter | Adapt a SAX2 XMLReader as a SAX1 Parser. | 
| XMLReaderFactory | Factory for creating an XML reader. | 
 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, 2025, Oracle and/or its affiliates.  All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.