| Interface | Description |
|---|---|
| Closeable |
A
Closeable is a source or destination of data that can be closed. |
| DataInput |
The
DataInput interface provides
for reading bytes from a binary stream and
reconstructing from them data in any of
the Java primitive types. |
| DataOutput |
The
DataOutput interface provides
for converting data from any of the Java
primitive types to a series of bytes and
writing these bytes to a binary stream. |
| Externalizable |
Only the identity of the class of an Externalizable instance is
written in the serialization stream and it is the responsibility
of the class to save and restore the contents of its instances.
|
| FileFilter |
A filter for abstract pathnames.
|
| FilenameFilter |
Instances of classes that implement this interface are used to
filter filenames.
|
| Flushable |
A Flushable is a destination of data that can be flushed.
|
| ObjectInput |
ObjectInput extends the DataInput interface to include the reading of
objects.
|
| ObjectInputValidation |
Callback interface to allow validation of objects within a graph.
|
| ObjectOutput |
ObjectOutput extends the DataOutput interface to include writing of objects.
|
| ObjectStreamConstants |
Constants written into the Object Serialization Stream.
|
| Serializable |
Serializability of a class is enabled by the class implementing the
java.io.Serializable interface.
|
| Class | Description |
|---|---|
| BufferedInputStream |
A
BufferedInputStream adds
functionality to another input stream-namely,
the ability to buffer the input and to
support the mark and reset
methods. |
| BufferedOutputStream |
The class implements a buffered output stream.
|
| BufferedReader |
Reads text from a character-input stream, buffering characters so as to
provide for the efficient reading of characters, arrays, and lines.
|
| BufferedWriter |
Writes text to a character-output stream, buffering characters so as to
provide for the efficient writing of single characters, arrays, and strings.
|
| ByteArrayInputStream |
A
ByteArrayInputStream contains
an internal buffer that contains bytes that
may be read from the stream. |
| ByteArrayOutputStream |
This class implements an output stream in which the data is
written into a byte array.
|
| CharArrayReader |
This class implements a character buffer that can be used as a
character-input stream.
|
| CharArrayWriter |
This class implements a character buffer that can be used as an Writer.
|
| Console |
Methods to access the character-based console device, if any, associated
with the current Java virtual machine.
|
| DataInputStream |
A data input stream lets an application read primitive Java data
types from an underlying input stream in a machine-independent
way.
|
| DataOutputStream |
A data output stream lets an application write primitive Java data
types to an output stream in a portable way.
|
| File |
An abstract representation of file and directory pathnames.
|
| FileDescriptor |
Instances of the file descriptor class serve as an opaque handle
to the underlying machine-specific structure representing an open
file, an open socket, or another source or sink of bytes.
|
| FileInputStream |
A
FileInputStream obtains input bytes
from a file in a file system. |
| FileOutputStream |
A file output stream is an output stream for writing data to a
File or to a FileDescriptor . |
| FilePermission |
This class represents access to a file or directory.
|
| FileReader |
Convenience class for reading character files.
|
| FileWriter |
Convenience class for writing character files.
|
| FilterInputStream |
A
FilterInputStream contains
some other input stream, which it uses as
its basic source of data, possibly transforming
the data along the way or providing additional
functionality. |
| FilterOutputStream |
This class is the superclass of all classes that filter output
streams.
|
| FilterReader |
Abstract class for reading filtered character streams.
|
| FilterWriter |
Abstract class for writing filtered character streams.
|
| InputStream |
This abstract class is the superclass of all classes representing
an input stream of bytes.
|
| InputStreamReader |
An InputStreamReader is a bridge from byte streams to character streams: It
reads bytes and decodes them into characters using a specified
charset . |
| LineNumberInputStream | Deprecated
This class incorrectly assumes that bytes adequately represent
characters.
|
| LineNumberReader |
A buffered character-input stream that keeps track of line numbers.
|
| ObjectInputStream |
An ObjectInputStream deserializes primitive data and objects previously
written using an ObjectOutputStream.
|
| ObjectInputStream.GetField |
Provide access to the persistent fields read from the input stream.
|
| ObjectOutputStream |
An ObjectOutputStream writes primitive data types and graphs of Java objects
to an OutputStream.
|
| ObjectOutputStream.PutField |
Provide programmatic access to the persistent fields to be written
to ObjectOutput.
|
| ObjectStreamClass |
Serialization's descriptor for classes.
|
| ObjectStreamField |
A description of a Serializable field from a Serializable class.
|
| OutputStream |
This abstract class is the superclass of all classes representing
an output stream of bytes.
|
| OutputStreamWriter |
An OutputStreamWriter is a bridge from character streams to byte streams:
Characters written to it are encoded into bytes using a specified
charset . |
| PipedInputStream |
A piped input stream should be connected
to a piped output stream; the piped input
stream then provides whatever data bytes
are written to the piped output stream.
|
| PipedOutputStream |
A piped output stream can be connected to a piped input stream
to create a communications pipe.
|
| PipedReader |
Piped character-input streams.
|
| PipedWriter |
Piped character-output streams.
|
| PrintStream |
A
PrintStream adds functionality to another output stream,
namely the ability to print representations of various data values
conveniently. |
| PrintWriter |
Prints formatted representations of objects to a text-output stream.
|
| PushbackInputStream |
A
PushbackInputStream adds
functionality to another input stream, namely
the ability to "push back" or "unread"
one byte. |
| PushbackReader |
A character-stream reader that allows characters to be pushed back into the
stream.
|
| RandomAccessFile |
Instances of this class support both reading and writing to a
random access file.
|
| Reader |
Abstract class for reading character streams.
|
| SequenceInputStream |
A
SequenceInputStream represents
the logical concatenation of other input
streams. |
| SerializablePermission |
This class is for Serializable permissions.
|
| StreamTokenizer |
The
StreamTokenizer class takes an input stream and
parses it into "tokens", allowing the tokens to be
read one at a time. |
| StringBufferInputStream | Deprecated
This class does not properly convert characters into bytes.
|
| StringReader |
A character stream whose source is a string.
|
| StringWriter |
A character stream that collects its output in a string buffer, which can
then be used to construct a string.
|
| Writer |
Abstract class for writing to character streams.
|
| Exception | Description |
|---|---|
| CharConversionException |
Base class for character conversion exceptions.
|
| EOFException |
Signals that an end of file or end of stream has been reached
unexpectedly during input.
|
| FileNotFoundException |
Signals that an attempt to open the file denoted by a specified pathname
has failed.
|
| InterruptedIOException |
Signals that an I/O operation has been interrupted.
|
| InvalidClassException |
Thrown when the Serialization runtime detects one of the following
problems with a Class.
|
| InvalidObjectException |
Indicates that one or more deserialized objects failed validation
tests.
|
| IOException |
Signals that an I/O exception of some sort has occurred.
|
| NotActiveException |
Thrown when serialization or deserialization is not active.
|
| NotSerializableException |
Thrown when an instance is required to have a Serializable interface.
|
| ObjectStreamException |
Superclass of all exceptions specific to Object Stream classes.
|
| OptionalDataException |
Exception indicating the failure of an object read operation due to
unread primitive data, or the end of data belonging to a serialized
object in the stream.
|
| StreamCorruptedException |
Thrown when control information that was read from an object stream
violates internal consistency checks.
|
| SyncFailedException |
Signals that a sync operation has failed.
|
| UncheckedIOException |
Wraps an
IOException with an unchecked exception. |
| UnsupportedEncodingException |
The Character Encoding is not supported.
|
| UTFDataFormatException |
Signals that a malformed string in
modified UTF-8
format has been read in a data
input stream or by any class that implements the data input
interface.
|
| WriteAbortedException |
Signals that one of the ObjectStreamExceptions was thrown during a
write operation.
|
| Error | 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
char values. |
| Cloneable |
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Comparable<T> |
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Iterable<T> |
Implementing this interface allows an object to be the target of
the "for-each loop" statement.
|
| Readable |
A Readable is a source of characters.
|
| Runnable |
The
Runnable interface should be implemented by any
class whose instances are intended to be executed by a thread. |
| Thread.UncaughtExceptionHandler |
Interface for handlers invoked when a Thread abruptly
terminates due to an uncaught exception.
|
| Class | Description |
|---|---|
| Boolean |
The Boolean class wraps a value of the primitive type
boolean in an object. |
| Byte |
The
Byte class wraps a value of primitive type byte
in an object. |
| Character |
The
Character class wraps a value of the primitive
type char in an object. |
| Character.Subset |
Instances of this class represent particular subsets of the Unicode
character set.
|
| Character.UnicodeBlock |
A family of character subsets representing the character blocks in the
Unicode specification.
|
| Class<T> |
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| ClassLoader |
A class loader is an object that is responsible for loading classes.
|
| ClassValue<T> |
Lazily associate a computed value with (potentially) every type.
|
| Compiler |
The
Compiler class is provided to support Java-to-native-code
compilers and related services. |
| Double |
The
Double class wraps a value of the primitive type
double in an object. |
| Enum<E extends Enum<E>> |
This is the common base class of all Java language enumeration types.
|
| Float |
The
Float class wraps a value of primitive type
float in an object. |
| InheritableThreadLocal<T> |
This class extends ThreadLocal to provide inheritance of values
from parent thread to child thread: when a child thread is created, the
child receives initial values for all inheritable thread-local variables
for which the parent has values.
|
| Integer |
The
Integer class wraps a value of the primitive type
int in an object. |
| Long |
The
Long class wraps a value of the primitive type long in an object. |
| Math |
The class
Math contains methods for performing basic
numeric operations such as the elementary exponential, logarithm,
square root, and trigonometric functions. |
| Number |
The abstract class
Number is the superclass of platform
classes representing numeric values that are convertible to the
primitive types byte , double , float , int , long , and short . |
| Object |
Class
Object is the root of the class hierarchy. |
| Package |
Package objects contain version information
about the implementation and specification of a Java package. |
| Process |
The
ProcessBuilder.start() and
Runtime.exec
methods create a native process and return an instance of a
subclass of Process that can be used to control the process
and obtain information about it. |
| ProcessBuilder |
This class is used to create operating system processes.
|
| ProcessBuilder.Redirect |
Represents a source of subprocess input or a destination of
subprocess output.
|
| Runtime |
Every Java application has a single instance of class
Runtime that allows the application to interface with
the environment in which the application is running. |
| RuntimePermission |
This class is for runtime permissions.
|
| SecurityManager |
The security manager is a class that allows
applications to implement a security policy.
|
| Short |
The
Short class wraps a value of primitive type short in an object. |
| StackTraceElement |
An element in a stack trace, as returned by
Throwable.getStackTrace() . |
| StrictMath |
The class
StrictMath contains methods for performing basic
numeric operations such as the elementary exponential, logarithm,
square root, and trigonometric functions. |
| String |
The
String class represents character strings. |
| StringBuffer |
A thread-safe, mutable sequence of characters.
|
| StringBuilder |
A mutable sequence of characters.
|
| System |
The
System class contains several useful class fields
and methods. |
| Thread |
A thread is a thread of execution in a program.
|
| ThreadGroup |
A thread group represents a set of threads.
|
| ThreadLocal<T> |
This class provides thread-local variables.
|
| Throwable |
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Void |
The
Void class is an uninstantiable placeholder class to hold a
reference to the Class object representing the Java keyword
void. |
| Enum | 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
forName method in class Class . |
| CloneNotSupportedException |
Thrown to indicate that the
clone method in class
Object has been called to clone an object, but that
the object's class does not implement the Cloneable
interface. |
| EnumConstantNotPresentException |
Thrown when an application tries to access an enum constant by name
and the enum type contains no constant with the specified name.
|
| Exception |
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| IllegalAccessException |
An IllegalAccessException is thrown when an application tries
to reflectively create an instance (other than an array),
set or get a field, or invoke a method, but the currently
executing method does not have access to the definition of
the specified class, field, method or constructor.
|
| IllegalArgumentException |
Thrown to indicate that a method has been passed an illegal or
inappropriate argument.
|
| IllegalMonitorStateException |
Thrown to indicate that a thread has attempted to wait on an
object's monitor or to notify other threads waiting on an object's
monitor without owning the specified monitor.
|
| IllegalStateException |
Signals that a method has been invoked at an illegal or
inappropriate time.
|
| IllegalThreadStateException |
Thrown to indicate that a thread is not in an appropriate state
for the requested operation.
|
| IndexOutOfBoundsException |
Thrown to indicate that an index of some sort (such as to an array, to a
string, or to a vector) is out of range.
|
| InstantiationException |
Thrown when an application tries to create an instance of a class
using the
newInstance method in class
Class , but the specified class object cannot be
instantiated. |
| InterruptedException |
Thrown when a thread is waiting, sleeping, or otherwise occupied,
and the thread is interrupted, either before or during the activity.
|
| NegativeArraySizeException |
Thrown if an application tries to create an array with negative size.
|
| NoSuchFieldException |
Signals that the class doesn't have a field of a specified name.
|
| NoSuchMethodException |
Thrown when a particular method cannot be found.
|
| NullPointerException |
Thrown when an application attempts to use
null in a
case where an object is required. |
| NumberFormatException |
Thrown to indicate that the application has attempted to convert
a string to one of the numeric types, but that the string does not
have the appropriate format.
|
| ReflectiveOperationException |
Common superclass of exceptions thrown by reflective operations in
core reflection.
|
| RuntimeException |
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| SecurityException |
Thrown by the security manager to indicate a security violation.
|
| StringIndexOutOfBoundsException |
Thrown by
String methods to indicate that an index
is either negative or greater than the size of the string. |
| TypeNotPresentException |
Thrown when an application tries to access a type using a string
representing the type's name, but no definition for the type with
the specified name can be found.
|
| UnsupportedOperationException |
Thrown to indicate that the requested operation is not supported.
|
| Error | Description |
|---|---|
| AbstractMethodError |
Thrown when an application tries to call an abstract method.
|
| AssertionError |
Thrown to indicate that an assertion has failed.
|
| BootstrapMethodError |
Thrown to indicate that an
invokedynamic instruction has
failed to find its bootstrap method,
or the bootstrap method has failed to provide a
call site with a target
of the correct method type. |
| ClassCircularityError |
Thrown when the Java Virtual Machine detects a circularity in the
superclass hierarchy of a class being loaded.
|
| ClassFormatError |
Thrown when the Java Virtual Machine attempts to read a class
file and determines that the file is malformed or otherwise cannot
be interpreted as a class file.
|
| Error |
An
Error is a subclass of Throwable
that indicates serious problems that a reasonable application
should not try to catch. |
| ExceptionInInitializerError |
Signals that an unexpected exception has occurred in a static initializer.
|
| IllegalAccessError |
Thrown if an application attempts to access or modify a field, or
to call a method that it does not have access to.
|
| IncompatibleClassChangeError |
Thrown when an incompatible class change has occurred to some class
definition.
|
| InstantiationError |
Thrown when an application tries to use the Java
new
construct to instantiate an abstract class or an interface. |
| InternalError |
Thrown to indicate some unexpected internal error has occurred in
the Java Virtual Machine.
|
| LinkageError |
Subclasses of
LinkageError indicate that a class has
some dependency on another class; however, the latter class has
incompatibly changed after the compilation of the former class. |
| NoClassDefFoundError |
Thrown if the Java Virtual Machine or a
ClassLoader instance
tries to load in the definition of a class (as part of a normal method call
or as part of creating a new instance using the new expression)
and no definition of the class could be found. |
| NoSuchFieldError |
Thrown if an application tries to access or modify a specified
field of an object, and that object no longer has that field.
|
| NoSuchMethodError |
Thrown if an application tries to call a specified method of a
class (either static or instance), and that class no longer has a
definition of that method.
|
| OutOfMemoryError |
Thrown when the Java Virtual Machine cannot allocate an object
because it is out of memory, and no more memory could be made
available by the garbage collector.
|
| StackOverflowError |
Thrown when a stack overflow occurs because an application
recurses too deeply.
|
| ThreadDeath |
An instance of
ThreadDeath is thrown in the victim thread
when the (deprecated) Thread.stop() method is invoked. |
| UnknownError |
Thrown when an unknown but serious exception has occurred in the
Java Virtual Machine.
|
| UnsatisfiedLinkError |
Thrown if the Java Virtual Machine cannot find an appropriate
native-language definition of a method declared
native . |
| UnsupportedClassVersionError |
Thrown when the Java Virtual Machine attempts to read a class
file and determines that the major and minor version numbers
in the file are not supported.
|
| VerifyError |
Thrown when the "verifier" detects that a class file,
though well formed, contains some sort of internal inconsistency
or security problem.
|
| VirtualMachineError |
Thrown to indicate that the Java Virtual Machine is broken or has
run out of resources necessary for it to continue operating.
|
| Annotation 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.Repeatable is
used to indicate that the annotation type whose declaration it
(meta-)annotates is repeatable. |
| Retention |
Indicates how long annotations with the annotated type are to
be retained.
|
| Target |
Indicates the contexts in which an annotation type is applicable.
|
| Interface | Description |
|---|---|
| MethodHandleInfo |
A symbolic reference obtained by cracking a direct method handle
into its consitutent symbolic parts.
|
| Class | Description |
|---|---|
| CallSite | |
| ConstantCallSite |
A
ConstantCallSite is a CallSite whose target is permanent, and can never be changed. |
| LambdaMetafactory |
Methods to facilitate the creation of simple "function objects" that
implement one or more interfaces by delegation to a provided
MethodHandle ,
possibly after type adaptation and partial evaluation of arguments. |
| MethodHandle |
A method handle is a typed, directly executable reference to an underlying method,
constructor, field, or similar low-level operation, with optional
transformations of arguments or return values.
|
| MethodHandleProxies |
This class consists exclusively of static methods that help adapt
method handles to other JVM types, such as interfaces.
|
| MethodHandles |
This class consists exclusively of static methods that operate on or return
method handles.
|
| MethodHandles.Lookup |
A lookup object is a factory for creating method handles,
when the creation requires access checking.
|
| MethodType |
A method type represents the arguments and return type accepted and
returned by a method handle, or the arguments and return type passed
and expected by a method handle caller.
|
| MutableCallSite |
A
MutableCallSite is a CallSite whose target variable
behaves like an ordinary field. |
| SerializedLambda |
Serialized form of a lambda expression.
|
| SwitchPoint |
A
SwitchPoint is an object which can publish state transitions to other threads. |
| VolatileCallSite |
A
VolatileCallSite is a CallSite whose target acts like a volatile variable. |
| Exception | 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 |
AnnotatedArrayType represents the potentially annotated use of an
array type, whose component type may itself represent the annotated use of a
type. |
| AnnotatedElement |
Represents an annotated element of the program currently running in this
VM.
|
| AnnotatedParameterizedType |
AnnotatedParameterizedType represents the potentially annotated use
of a parameterized type, whose type arguments may themselves represent
annotated uses of types. |
| AnnotatedType |
AnnotatedType represents the potentially annotated use of a type in
the program currently running in this VM. |
| AnnotatedTypeVariable |
AnnotatedTypeVariable represents the potentially annotated use of a
type variable, whose declaration may have bounds which themselves represent
annotated uses of types. |
| AnnotatedWildcardType |
AnnotatedWildcardType represents the potentially annotated use of a
wildcard type argument, whose upper or lower bounds may themselves represent
annotated uses of types. |
| GenericArrayType |
GenericArrayType represents an array type whose component
type is either a parameterized type or a type variable. |
| GenericDeclaration |
A common interface for all entities that declare type variables.
|
| InvocationHandler |
InvocationHandler is the interface implemented by
the invocation handler of a proxy instance. |
| Member |
Member is an interface that reflects identifying information about
a single member (a field or a method) or a constructor.
|
| ParameterizedType |
ParameterizedType represents a parameterized type such as
Collection<String>.
|
| Type |
Type is the common superinterface for all types in the Java
programming language.
|
| TypeVariable<D extends GenericDeclaration> |
TypeVariable is the common superinterface for type variables of kinds.
|
| WildcardType |
WildcardType represents a wildcard type expression, such as
? , ? extends Number , or ? super Integer . |
| Class | Description |
|---|---|
| AccessibleObject |
The AccessibleObject class is the base class for Field, Method and
Constructor objects.
|
| Array |
The
Array class provides static methods to dynamically create and
access Java arrays. |
| Constructor<T> |
Constructor provides information about, and access to, a single
constructor for a class. |
| Executable |
A shared superclass for the common functionality of
Method
and Constructor . |
| Field |
A
Field provides information about, and dynamic access to, a
single field of a class or an interface. |
| Method |
A
Method provides information about, and access to, a single method
on a class or interface. |
| Modifier |
The Modifier class provides
static methods and
constants to decode class and member access modifiers. |
| Parameter |
Information about method parameters.
|
| Proxy |
Proxy provides static methods for creating dynamic proxy
classes and instances, and it is also the superclass of all
dynamic proxy classes created by those methods. |
| ReflectPermission |
The Permission class for reflective operations.
|
| Exception | Description |
|---|---|
| InvocationTargetException |
InvocationTargetException is a checked exception that wraps
an exception thrown by an invoked method or constructor.
|
| MalformedParameterizedTypeException |
Thrown when a semantically malformed parameterized type is
encountered by a reflective method that needs to instantiate it.
|
| MalformedParametersException |
Thrown when
the
java.lang.reflect package attempts to read method parameters from
a class file and determines that one or more parameters are
malformed. |
| UndeclaredThrowableException |
Thrown by a method invocation on a proxy instance if its invocation
handler's
invoke method throws a
checked exception (a Throwable that is not assignable
to RuntimeException or Error ) that
is not assignable to any of the exception types declared in the
throws clause of the method that was invoked on the
proxy instance and dispatched to the invocation handler. |
| Error | 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
BigDecimal class. |
| 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
URL stream
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
ContentHandler is the superclass
of all classes that read an Object from a
URLConnection . |
| CookieHandler |
A CookieHandler object provides a callback mechanism to hook up a
HTTP state management policy implementation into the HTTP protocol
handler.
|
| CookieManager |
CookieManager provides a concrete implementation of
CookieHandler ,
which separates the storage of cookies from the policy surrounding accepting
and rejecting cookies. |
| DatagramPacket |
This class represents a datagram packet.
|
| DatagramSocket |
This class represents a socket for sending and receiving datagram packets.
|
| DatagramSocketImpl |
Abstract datagram and multicast socket implementation base class.
|
| HttpCookie |
An HttpCookie object represents an HTTP cookie, which carries state
information between server and user agent.
|
| HttpURLConnection |
A URLConnection with support for HTTP-specific features.
|
| IDN |
Provides methods to convert internationalized domain names (IDNs) between
a normal Unicode representation and an ASCII Compatible Encoding (ACE) representation.
|
| Inet4Address |
This class represents an Internet Protocol version 4 (IPv4) address.
|
| Inet6Address |
This class represents an Internet Protocol version 6 (IPv6) address.
|
| InetAddress |
This class represents an Internet Protocol (IP) address.
|
| InetSocketAddress |
This class implements an IP Socket Address (IP address + port number)
It can also be a pair (hostname + port number), in which case an attempt
will be made to resolve the hostname.
|
| InterfaceAddress |
This class represents a Network Interface address.
|
| JarURLConnection |
A URL Connection to a Java ARchive (JAR) file or an entry in a JAR
file.
|
| MulticastSocket |
The multicast datagram socket class is useful for sending
and receiving IP multicast packets.
|
| NetPermission |
This class is for various network permissions.
|
| NetworkInterface |
This class represents a Network Interface made up of a name,
and a list of IP addresses assigned to this interface.
|
| PasswordAuthentication |
The class PasswordAuthentication is a data holder that is used by
Authenticator.
|
| Proxy |
This class represents a proxy setting, typically a type (http, socks) and
a socket address.
|
| ProxySelector |
Selects the proxy server to use, if any, when connecting to the
network resource referenced by a URL.
|
| ResponseCache |
Represents implementations of URLConnection caches.
|
| SecureCacheResponse |
Represents a cache response originally retrieved through secure
means, such as TLS.
|
| ServerSocket |
This class implements server sockets.
|
| Socket |
This class implements client sockets (also called just
"sockets").
|
| SocketAddress |
This class represents a Socket Address with no protocol attachment.
|
| SocketImpl |
The abstract class
SocketImpl is a common superclass
of all classes that actually implement sockets. |
| SocketPermission |
This class represents access to a network via sockets.
|
| StandardSocketOptions |
Defines the standard socket options.
|
| URI |
Represents a Uniform Resource Identifier (URI) reference.
|
| URL |
Class
URL represents a Uniform Resource
Locator, a pointer to a "resource" on the World
Wide Web. |
| URLClassLoader |
This class loader is used to load classes and resources from a search
path of URLs referring to both JAR files and directories.
|
| URLConnection |
The abstract class
URLConnection is the superclass
of all classes that represent a communications link between the
application and a URL. |
| URLDecoder |
Utility class for HTML form decoding.
|
| URLEncoder |
Utility class for HTML form encoding.
|
| URLPermission |
Represents permission to access a resource or set of resources defined by a
given url, and for a given set of user-settable request methods
and request headers.
|
| URLStreamHandler |
The abstract class
URLStreamHandler is the common
superclass for all stream protocol handlers. |
| Enum | 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
SelectableChannel with a
Selector . |
| Selector |
A multiplexor of
SelectableChannel objects. |
| ServerSocketChannel |
A selectable channel for stream-oriented listening sockets.
|
| SocketChannel |
A selectable channel for stream-oriented connecting sockets.
|
| Exception | Description |
|---|---|
| AcceptPendingException |
Unchecked exception thrown when an attempt is made to initiate an accept
operation on a channel and a previous accept operation has not completed.
|
| AlreadyBoundException |
Unchecked exception thrown when an attempt is made to bind the socket a
network oriented channel that is already bound.
|
| AlreadyConnectedException |
Unchecked exception thrown when an attempt is made to connect a
SocketChannel that is already connected. |
| AsynchronousCloseException |
Checked exception received by a thread when another thread closes the
channel or the part of the channel upon which it is blocked in an I/O
operation.
|
| CancelledKeyException |
Unchecked exception thrown when an attempt is made to use
a selection key that is no longer valid.
|
| ClosedByInterruptException |
Checked exception received by a thread when another thread interrupts it
while it is blocked in an I/O operation upon a channel.
|
| ClosedChannelException |
Checked exception thrown when an attempt is made to invoke or complete an
I/O operation upon channel that is closed, or at least closed to that
operation.
|
| ClosedSelectorException |
Unchecked exception thrown when an attempt is made to invoke an I/O
operation upon a closed selector.
|
| ConnectionPendingException |
Unchecked exception thrown when an attempt is made to connect a
SocketChannel for which a non-blocking connection operation is already in
progress. |
| FileLockInterruptionException |
Checked exception received by a thread when another thread interrupts it
while it is waiting to acquire a file lock.
|
| IllegalBlockingModeException |
Unchecked exception thrown when a blocking-mode-specific operation
is invoked upon a channel in the incorrect blocking mode.
|
| IllegalChannelGroupException |
Unchecked exception thrown when an attempt is made to open a channel
in a group that was not created by the same provider.
|
| IllegalSelectorException |
Unchecked exception thrown when an attempt is made to register a channel
with a selector that was not created by the provider that created the
channel.
|
| InterruptedByTimeoutException |
Checked exception received by a thread when a timeout elapses before an
asynchronous operation completes.
|
| NoConnectionPendingException |
Unchecked exception thrown when the
finishConnect method of a SocketChannel is invoked without first
successfully invoking its connect method. |
| NonReadableChannelException |
Unchecked exception thrown when an attempt is made to read
from a channel that was not originally opened for reading.
|
| NonWritableChannelException |
Unchecked exception thrown when an attempt is made to write
to a channel that was not originally opened for writing.
|
| NotYetBoundException |
Unchecked exception thrown when an attempt is made to invoke an I/O
operation upon a server socket channel that is not yet bound.
|
| NotYetConnectedException |
Unchecked exception thrown when an attempt is made to invoke an I/O
operation upon a socket channel that is not yet connected.
|
| OverlappingFileLockException |
Unchecked exception thrown when an attempt is made to acquire a lock on a
region of a file that overlaps a region already locked by the same Java
virtual machine, or when another thread is already waiting to lock an
overlapping region of the same file.
|
| ReadPendingException |
Unchecked exception thrown when an attempt is made to read from an
asynchronous socket channel and a previous read has not completed.
|
| ShutdownChannelGroupException |
Unchecked exception thrown when an attempt is made to construct a channel in
a group that is shutdown or the completion handler for an I/O operation
cannot be invoked because the channel group has terminated.
|
| UnresolvedAddressException |
Unchecked exception thrown when an attempt is made to invoke a network
operation upon an unresolved socket address.
|
| UnsupportedAddressTypeException |
Unchecked exception thrown when an attempt is made to bind or connect
to a socket address of a type that is not supported.
|
| WritePendingException |
Unchecked exception thrown when an attempt is made to write to an
asynchronous socket channel and a previous write has not completed.
|
| 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
decodeLoop method of
a CharsetDecoder , or the encodeLoop method of a CharsetEncoder , 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
DirectoryStream that defines operations on files that are located
relative to an open directory. |
| Watchable |
An object that may be registered with a watch service so that it can be
watched for changes and events.
|
| WatchEvent<T> |
An event or a repeated event for an object that is registered with a
WatchService . |
| WatchEvent.Kind<T> |
An event kind, for the purposes of identification.
|
| WatchEvent.Modifier |
An event modifier that qualifies how a
Watchable is registered
with a WatchService . |
| WatchKey |
A token representing the registration of a
watchable object
with a WatchService . |
| WatchService |
A watch service that watches registered objects for changes and
events.
|
| Class | Description |
|---|---|
| Files |
This class consists exclusively of static methods that operate on files,
directories, or other types of files.
|
| FileStore |
Storage for files.
|
| FileSystem |
Provides an interface to a file system and is the factory for objects to
access files and other objects in the file system.
|
| FileSystems |
Factory methods for file systems.
|
| LinkPermission |
The
Permission class for link creation operations. |
| Paths | |
| 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
Path because the path string contains invalid characters, or
the path string is invalid for other file system specific reasons. |
| NoSuchFileException |
Checked exception thrown when an attempt is made to access a file that does
not exist.
|
| NotDirectoryException |
Checked exception thrown when a file system operation, intended for a
directory, fails because the file is not a directory.
|
| NotLinkException |
Checked exception thrown when a file system operation fails because a file
is not a symbolic link.
|
| ProviderMismatchException |
Unchecked exception thrown when an attempt is made to invoke a method on an
object created by one file system provider with a parameter created by a
different file system provider.
|
| ProviderNotFoundException |
Runtime exception thrown when a provider of the required type cannot be found.
|
| ReadOnlyFileSystemException |
Unchecked exception thrown when an attempt is made to update an object
associated with a
read-only FileSystem . |
| Interface | Description |
|---|---|
| AclFileAttributeView |
A file attribute view that supports reading or updating a file's Access
Control Lists (ACL) or file owner attributes.
|
| AttributeView |
An object that provides a read-only or updatable view of non-opaque
values associated with an object in a filesystem.
|
| BasicFileAttributes |
Basic attributes associated with a file in a file system.
|
| BasicFileAttributeView |
A file attribute view that provides a view of a basic set of file
attributes common to many file systems.
|
| DosFileAttributes |
File attributes associated with a file in a file system that supports
legacy "DOS" attributes.
|
| DosFileAttributeView |
A file attribute view that provides a view of the legacy "DOS" file attributes.
|
| FileAttribute<T> |
An object that encapsulates the value of a file attribute that can be set
atomically when creating a new file or directory by invoking the
createFile or createDirectory methods. |
| FileAttributeView |
An attribute view that is a read-only or updatable view of non-opaque
values associated with a file in a filesystem.
|
| FileOwnerAttributeView |
A file attribute view that supports reading or updating the owner of a file.
|
| FileStoreAttributeView |
An attribute view that is a read-only or updatable view of the attributes of
a
FileStore . |
| GroupPrincipal |
A
UserPrincipal representing a group identity, used to
determine access rights to objects in a file system. |
| PosixFileAttributes |
File attributes associated with files on file systems used by operating systems
that implement the Portable Operating System Interface (POSIX) family of
standards.
|
| PosixFileAttributeView |
A file attribute view that provides a view of the file attributes commonly
associated with files on file systems used by operating systems that implement
the Portable Operating System Interface (POSIX) family of standards.
|
| UserDefinedFileAttributeView |
A file attribute view that provides a view of a file's user-defined
attributes, sometimes known as extended attributes.
|
| UserPrincipal |
A
Principal representing an identity used to determine access rights
to objects in a file system. |
| Class | Description |
|---|---|
| AclEntry |
An entry in an access control list (ACL).
|
| AclEntry.Builder |
A builder of
AclEntry objects. |
| FileTime |
Represents the value of a file's time stamp attribute.
|
| PosixFilePermissions |
This class consists exclusively of static methods that operate on sets of
PosixFilePermission objects. |
| UserPrincipalLookupService |
An object to lookup user and group principals by name.
|
| Enum | Description |
|---|---|
| AclEntryFlag |
Defines the flags for used by the flags component of an ACL
entry . |
| AclEntryPermission |
Defines the permissions for use with the permissions component of an ACL
entry . |
| AclEntryType |
A typesafe enumeration of the access control entry types.
|
| PosixFilePermission |
Defines the bits for use with the
permissions attribute. |
| Exception | Description |
|---|---|
| UserPrincipalNotFoundException |
Checked exception thrown when a lookup of
UserPrincipal fails 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 |
|---|---|
| AlgorithmConstraints |
This interface specifies constraints for cryptographic algorithms,
keys (key sizes), and other algorithm parameters.
|
| Certificate | Deprecated
A new certificate handling package is created in the Java platform.
|
| DomainCombiner |
A
DomainCombiner provides a means to dynamically
update the ProtectionDomains associated with the current
AccessControlContext . |
| Guard |
This interface represents a guard, which is an object that is used
to protect access to another object.
|
| Key |
The Key interface is the top-level interface for all keys.
|
| KeyStore.Entry |
A marker interface for
KeyStore entry types. |
| KeyStore.Entry.Attribute |
An attribute associated with a keystore entry.
|
| KeyStore.LoadStoreParameter | |
| 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
AlgorithmParameterGenerator class is used to generate a
set of
parameters to be used with a certain algorithm. |
| AlgorithmParameterGeneratorSpi |
This class defines the Service Provider Interface (SPI)
for the
AlgorithmParameterGenerator class, which
is used to generate a set of parameters to be used with a certain algorithm. |
| AlgorithmParameters |
This class is used as an opaque representation of cryptographic parameters.
|
| AlgorithmParametersSpi |
This class defines the Service Provider Interface (SPI)
for the
AlgorithmParameters class, which is used to manage
algorithm parameters. |
| AllPermission |
The AllPermission is a permission that implies all other permissions.
|
| AuthProvider |
This class defines login and logout methods for a provider.
|
| BasicPermission |
The BasicPermission class extends the Permission class, and
can be used as the base class for permissions that want to
follow the same naming convention as BasicPermission.
|
| CodeSigner |
This class encapsulates information about a code signer.
|
| CodeSource |
This class extends the concept of a codebase to
encapsulate not only the location (URL) but also the certificate chains
that were used to verify signed code originating from that location.
|
| DigestInputStream |
A transparent stream that updates the associated message digest using
the bits going through the stream.
|
| DigestOutputStream |
A transparent stream that updates the associated message digest using
the bits going through the stream.
|
| DomainLoadStoreParameter |
Configuration data that specifies the keystores in a keystore domain.
|
| GuardedObject |
A GuardedObject is an object that is used to protect access to
another object.
|
| Identity | Deprecated
This class is no longer used.
|
| IdentityScope | Deprecated
This class is no longer used.
|
| KeyFactory |
Key factories are used to convert keys (opaque
cryptographic keys of type
Key ) into key specifications
(transparent representations of the underlying key material), and vice
versa. |
| KeyFactorySpi |
This class defines the Service Provider Interface (SPI)
for the
KeyFactory class. |
| KeyPair |
This class is a simple holder for a key pair (a public key and a
private key).
|
| KeyPairGenerator |
The KeyPairGenerator class is used to generate pairs of
public and private keys.
|
| KeyPairGeneratorSpi |
This class defines the Service Provider Interface (SPI)
for the
KeyPairGenerator class, which is used to generate
pairs of public and private keys. |
| KeyRep |
Standardized representation for serialized Key objects.
|
| KeyStore |
This class represents a storage facility for cryptographic
keys and certificates.
|
| KeyStore.Builder |
A description of a to-be-instantiated KeyStore object.
|
| KeyStore.CallbackHandlerProtection |
A ProtectionParameter encapsulating a CallbackHandler.
|
| KeyStore.PasswordProtection |
A password-based implementation of
ProtectionParameter . |
| KeyStore.PrivateKeyEntry |
A
KeyStore entry that holds a PrivateKey
and corresponding certificate chain. |
| KeyStore.SecretKeyEntry |
A
KeyStore entry that holds a SecretKey . |
| KeyStore.TrustedCertificateEntry |
A
KeyStore entry that holds a trusted
Certificate . |
| KeyStoreSpi |
This class defines the Service Provider Interface (SPI)
for the
KeyStore class. |
| MessageDigest |
This MessageDigest class provides applications the functionality of a
message digest algorithm, such as SHA-1 or SHA-256.
|
| MessageDigestSpi |
This class defines the Service Provider Interface (SPI)
for the
MessageDigest class, which provides the functionality
of a message digest algorithm, such as MD5 or SHA. |
| Permission |
Abstract class for representing access to a system resource.
|
| PermissionCollection |
Abstract class representing a collection of Permission objects.
|
| Permissions |
This class represents a heterogeneous collection of Permissions.
|
| PKCS12Attribute |
An attribute associated with a PKCS12 keystore entry.
|
| Policy |
A Policy object is responsible for determining whether code executing
in the Java runtime environment has permission to perform a
security-sensitive operation.
|
| PolicySpi |
This class defines the Service Provider Interface (SPI)
for the
Policy class. |
| ProtectionDomain |
This ProtectionDomain class encapsulates the characteristics of a domain,
which encloses a set of classes whose instances are granted a set
of permissions when being executed on behalf of a given set of Principals.
|
| Provider |
This class represents a "provider" for the
Java Security API, where a provider implements some or all parts of
Java Security.
|
| Provider.Service |
The description of a security service.
|
| SecureClassLoader |
This class extends ClassLoader with additional support for defining
classes with an associated code source and permissions which are
retrieved by the system policy by default.
|
| SecureRandom |
This class provides a cryptographically strong random number
generator (RNG).
|
| SecureRandomSpi |
This class defines the Service Provider Interface (SPI)
for the
SecureRandom class. |
| Security |
This class centralizes all security properties and common security
methods.
|
| SecurityPermission |
This class is for security permissions.
|
| Signature |
The Signature class is used to provide applications the functionality
of a digital signature algorithm.
|
| SignatureSpi |
This class defines the Service Provider Interface (SPI)
for the
Signature class, which is used to provide the
functionality of a digital signature algorithm. |
| SignedObject |
SignedObject is a class for the purpose of creating authentic
runtime objects whose integrity cannot be compromised without being
detected.
|
| Signer | Deprecated
This class is no longer used.
|
| Timestamp |
This class encapsulates information about a signed timestamp.
|
| UnresolvedPermission |
The UnresolvedPermission class is used to hold Permissions that
were "unresolved" when the Policy was initialized.
|
| URIParameter |
A parameter that contains a URI pointing to data intended for a
PolicySpi or ConfigurationSpi implementation.
|
| Enum | 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
GeneralSecurityException class is a generic
security exception class that provides type safety for all the
security-related exception classes that extend from it. |
| InvalidAlgorithmParameterException |
This is the exception for invalid or inappropriate algorithm parameters.
|
| InvalidKeyException |
This is the exception for invalid Keys (invalid encoding, wrong
length, uninitialized, etc).
|
| InvalidParameterException |
This exception, designed for use by the JCA/JCE engine classes,
is thrown when an invalid parameter is passed
to a method.
|
| KeyException |
This is the basic key exception.
|
| KeyManagementException |
This is the general key management exception for all operations
dealing with key management.
|
| KeyStoreException |
This is the generic KeyStore exception.
|
| NoSuchAlgorithmException |
This exception is thrown when a particular cryptographic algorithm is
requested but is not available in the environment.
|
| NoSuchProviderException |
This exception is thrown when a particular security provider is
requested but is not available in the environment.
|
| PrivilegedActionException |
This exception is thrown by
doPrivileged(PrivilegedExceptionAction) and
doPrivileged(PrivilegedExceptionAction,
AccessControlContext context) to indicate
that the action being performed threw a checked exception. |
| ProviderException |
A runtime exception for Provider exceptions (such as
misconfiguration errors or unrecoverable internal errors),
which may be subclassed by Providers to
throw specialized, provider-specific runtime errors.
|
| SignatureException |
This is the generic Signature exception.
|
| UnrecoverableEntryException |
This exception is thrown if an entry in the keystore cannot be recovered.
|
| UnrecoverableKeyException |
This exception is thrown if a key in the keystore cannot be recovered.
|
| Interface | Description |
|---|---|
| CertPathBuilderResult |
A specification of the result of a certification path builder algorithm.
|
| CertPathChecker |
Performs one or more checks on each
Certificate of a
CertPath . |
| CertPathParameters |
A specification of certification path algorithm parameters.
|
| CertPathValidatorException.Reason |
The reason the validation algorithm failed.
|
| CertPathValidatorResult |
A specification of the result of a certification path validator algorithm.
|
| CertSelector |
A selector that defines a set of criteria for selecting
Certificate s. |
| CertStoreParameters |
A specification of
CertStore parameters. |
| CRLSelector |
A selector that defines a set of criteria for selecting
CRL s. |
| Extension |
This interface represents an X.509 extension.
|
| PolicyNode |
An immutable valid policy tree node as defined by the PKIX certification
path validation algorithm.
|
| X509Extension |
Interface for an X.509 extension.
|
| Class | Description |
|---|---|
| Certificate |
Abstract class for managing a variety of identity certificates.
|
| Certificate.CertificateRep |
Alternate Certificate class for serialization.
|
| CertificateFactory |
This class defines the functionality of a certificate factory, which is
used to generate certificate, certification path (
CertPath )
and certificate revocation list (CRL) objects from their encodings. |
| CertificateFactorySpi |
This class defines the Service Provider Interface (SPI)
for the
CertificateFactory class. |
| CertPath |
An immutable sequence of certificates (a certification path).
|
| CertPath.CertPathRep |
Alternate
CertPath class for serialization. |
| CertPathBuilder |
A class for building certification paths (also known as certificate chains).
|
| CertPathBuilderSpi |
The Service Provider Interface (SPI)
for the
CertPathBuilder class. |
| CertPathValidator |
A class for validating certification paths (also known as certificate
chains).
|
| CertPathValidatorSpi |
The Service Provider Interface (SPI)
for the
CertPathValidator class. |
| CertStore |
A class for retrieving
Certificate s and CRL s
from a repository. |
| CertStoreSpi |
The Service Provider Interface (SPI)
for the
CertStore class. |
| CollectionCertStoreParameters |
Parameters used as input for the Collection
CertStore
algorithm. |
| CRL |
This class is an abstraction of certificate revocation lists (CRLs) that
have different formats but important common uses.
|
| LDAPCertStoreParameters |
Parameters used as input for the LDAP
CertStore algorithm. |
| PKIXBuilderParameters |
Parameters used as input for the PKIX
CertPathBuilder
algorithm. |
| PKIXCertPathBuilderResult |
This class represents the successful result of the PKIX certification
path builder algorithm.
|
| PKIXCertPathChecker |
An abstract class that performs one or more checks on an
X509Certificate . |
| PKIXCertPathValidatorResult |
This class represents the successful result of the PKIX certification
path validation algorithm.
|
| PKIXParameters |
Parameters used as input for the PKIX
CertPathValidator
algorithm. |
| PKIXRevocationChecker |
A
PKIXCertPathChecker for checking the revocation status of
certificates with the PKIX algorithm. |
| PolicyQualifierInfo |
An immutable policy qualifier represented by the ASN.1 PolicyQualifierInfo
structure.
|
| TrustAnchor |
A trust anchor or most-trusted Certification Authority (CA).
|
| X509Certificate |
Abstract class for X.509 certificates.
|
| X509CertSelector |
A
CertSelector that selects X509Certificates that
match all specified criteria. |
| X509CRL |
Abstract class for an X.509 Certificate Revocation List (CRL).
|
| X509CRLEntry |
Abstract class for a revoked certificate in a CRL (Certificate
Revocation List).
|
| X509CRLSelector |
A
CRLSelector that selects X509CRLs that
match all specified criteria. |
| Enum | Description |
|---|---|
| CertPathValidatorException.BasicReason |
The BasicReason enumerates the potential reasons that a certification
path of any type may be invalid.
|
| CRLReason |
The CRLReason enumeration specifies the reason that a certificate
is revoked, as defined in
RFC 3280: Internet X.509 Public Key Infrastructure Certificate and CRL
Profile.
|
| PKIXReason |
The
PKIXReason enumerates the potential PKIX-specific reasons
that an X.509 certification path may be invalid according to the PKIX
(RFC 3280) standard. |
| PKIXRevocationChecker.Option |
Various revocation options that can be specified for the revocation
checking mechanism.
|
| Exception | 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 an RSA public or private key.
|
| RSAMultiPrimePrivateCrtKey |
The interface to an RSA multi-prime private key, as defined in the
PKCS#1 v2.1, using the Chinese Remainder Theorem
(CRT) information values.
|
| RSAPrivateCrtKey |
The interface to an RSA private key, as defined in the PKCS#1 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 RSA-PSS signature scheme, as
defined in the
PKCS #1 v2.1
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 RSA-PSS signature scheme,
as defined in the
PKCS#1 v2.1
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.1, 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.1.
|
| RSAPrivateCrtKeySpec |
This class specifies an RSA private key, as defined in the PKCS#1
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 |
|---|---|
| AttributedCharacterIterator |
An
AttributedCharacterIterator allows 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
BreakIterator class implements methods for finding
the location of boundaries in text. |
| ChoiceFormat |
A
ChoiceFormat allows you to attach a format to a range of numbers. |
| CollationElementIterator |
The
CollationElementIterator class is used as an iterator
to walk through each character of an international string. |
| CollationKey |
A
CollationKey represents a String under the
rules of a specific Collator object. |
| Collator |
The
Collator class performs locale-sensitive
String comparison. |
| DateFormat |
DateFormat is an abstract class for date/time formatting subclasses which
formats and parses dates or time in a language-independent manner. |
| DateFormat.Field |
Defines constants that are used as attribute keys in the
AttributedCharacterIterator returned
from DateFormat.formatToCharacterIterator and as
field identifiers in FieldPosition . |
| DateFormatSymbols |
DateFormatSymbols is a public class for encapsulating
localizable date-time formatting data, such as the names of the
months, the names of the days of the week, and the time zone data. |
| DecimalFormat |
DecimalFormat is a concrete subclass of
NumberFormat that formats decimal numbers. |
| DecimalFormatSymbols |
This class represents the set of symbols (such as the decimal separator,
the grouping separator, and so on) needed by
DecimalFormat
to format numbers. |
| FieldPosition |
FieldPosition is a simple class used by Format
and its subclasses to identify fields in formatted output. |
| Format |
Format is an abstract base class for formatting locale-sensitive
information such as dates, messages, and numbers. |
| Format.Field |
Defines constants that are used as attribute keys in the
AttributedCharacterIterator returned
from Format.formatToCharacterIterator and as
field identifiers in FieldPosition . |
| MessageFormat |
MessageFormat provides a means to produce concatenated
messages in a language-neutral way. |
| MessageFormat.Field |
Defines constants that are used as attribute keys in the
AttributedCharacterIterator returned
from MessageFormat.formatToCharacterIterator . |
| Normalizer |
This class provides the method
normalize which transforms Unicode
text into an equivalent composed or decomposed form, allowing for easier
sorting and searching of text. |
| NumberFormat |
NumberFormat is the abstract base class for all number
formats. |
| NumberFormat.Field |
Defines constants that are used as attribute keys in the
AttributedCharacterIterator returned
from NumberFormat.formatToCharacterIterator and as
field identifiers in FieldPosition . |
| ParsePosition |
ParsePosition is a simple class used by Format
and its subclasses to keep track of the current position during parsing. |
| RuleBasedCollator |
The
RuleBasedCollator class is a concrete subclass of
Collator that provides a simple, data-driven, table
collator. |
| SimpleDateFormat |
SimpleDateFormat is a concrete class for formatting and
parsing dates in a locale-sensitive manner. |
| StringCharacterIterator |
StringCharacterIterator implements the
CharacterIterator protocol for a String . |
| Enum | 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
BreakIterator class. |
| CollatorProvider |
An abstract class for service providers that
provide concrete implementations of the
Collator class. |
| DateFormatProvider |
An abstract class for service providers that
provide concrete implementations of the
DateFormat class. |
| DateFormatSymbolsProvider |
An abstract class for service providers that
provide instances of the
DateFormatSymbols class. |
| DecimalFormatSymbolsProvider |
An abstract class for service providers that
provide instances of the
DecimalFormatSymbols class. |
| NumberFormatProvider |
An abstract class for service providers that
provide concrete implementations of the
NumberFormat class. |
| 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 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
SortedMap extended with navigation methods returning the
closest matches for given search targets. |
| NavigableSet<E> |
A
SortedSet extended with navigation methods reporting
closest matches for given search targets. |
| Observer |
A class can implement the
Observer interface when it
wants to be informed of changes in observable objects. |
| PrimitiveIterator<T,T_CONS> |
A base type for primitive specializations of
Iterator . |
| PrimitiveIterator.OfDouble |
An Iterator specialized for
double values. |
| PrimitiveIterator.OfInt |
An Iterator specialized for
int values. |
| PrimitiveIterator.OfLong |
An Iterator specialized for
long values. |
| Queue<E> |
A collection designed for holding elements prior to processing.
|
| RandomAccess |
Marker interface used by List implementations to indicate that
they support fast (generally constant time) random access.
|
| Set<E> |
A collection that contains no duplicate elements.
|
| SortedMap<K,V> |
A
Map that further provides a total ordering on its keys. |
| SortedSet<E> |
A
Set that further provides a total ordering on its elements. |
| Spliterator<T> |
An object for traversing and partitioning elements of a source.
|
| Spliterator.OfDouble |
A Spliterator specialized for
double values. |
| Spliterator.OfInt |
A Spliterator specialized for
int values. |
| Spliterator.OfLong |
A Spliterator specialized for
long values. |
| Spliterator.OfPrimitive<T,T_CONS,T_SPLITR extends Spliterator.OfPrimitive<T,T_CONS,T_SPLITR>> |
A Spliterator specialized for primitive values.
|
| Class | Description |
|---|---|
| AbstractCollection<E> |
This class provides a skeletal implementation of the Collection
interface, to minimize the effort required to implement this interface.
|
| AbstractList<E> |
This class provides a skeletal implementation of the
List
interface to minimize the effort required to implement this interface
backed by a "random access" data store (such as an array). |
| AbstractMap<K,V> |
This class provides a skeletal implementation of the Map
interface, to minimize the effort required to implement this interface.
|
| AbstractMap.SimpleEntry<K,V> |
An Entry maintaining a key and a value.
|
| AbstractMap.SimpleImmutableEntry<K,V> |
An Entry maintaining an immutable key and value.
|
| AbstractQueue<E> |
This class provides skeletal implementations of some
Queue
operations. |
| AbstractSequentialList<E> |
This class provides a skeletal implementation of the List
interface to minimize the effort required to implement this interface
backed by a "sequential access" data store (such as a linked list).
|
| AbstractSet<E> |
This class provides a skeletal implementation of the Set
interface to minimize the effort required to implement this
interface.
|
| ArrayDeque<E> |
Resizable-array implementation of the
Deque interface. |
| ArrayList<E> |
Resizable-array implementation of the List interface.
|
| Arrays |
This class contains various methods for manipulating arrays (such as
sorting and searching).
|
| Base64 |
This class consists exclusively of static methods for obtaining
encoders and decoders for the Base64 encoding scheme.
|
| Base64.Decoder |
This class implements a decoder for decoding byte data using the
Base64 encoding scheme as specified in RFC 4648 and RFC 2045.
|
| Base64.Encoder |
This class implements an encoder for encoding byte data using
the Base64 encoding scheme as specified in RFC 4648 and RFC 2045.
|
| BitSet |
This class implements a vector of bits that grows as needed.
|
| Calendar |
The
Calendar class is an abstract class that provides methods
for converting between a specific instant in time and a set of calendar fields such as YEAR , MONTH ,
DAY_OF_MONTH , HOUR , and so on, and for
manipulating the calendar fields, such as getting the date of the next
week. |
| Calendar.Builder |
Calendar.Builder is used for creating a Calendar from
various date-time parameters. |
| Collections |
This class consists exclusively of static methods that operate on or return
collections.
|
| Currency |
Represents a currency.
|
| Date |
The class
Date represents a specific instant
in time, with millisecond precision. |
| Dictionary<K,V> |
The
Dictionary class is the abstract parent of any
class, such as Hashtable , which maps keys to values. |
| DoubleSummaryStatistics |
A state object for collecting statistics such as count, min, max, sum, and
average.
|
| EnumMap<K extends Enum<K>,V> |
A specialized
Map implementation for use with enum type keys. |
| EnumSet<E extends Enum<E>> |
A specialized
Set implementation for use with enum types. |
| EventListenerProxy<T extends EventListener> |
An abstract wrapper class for an
EventListener class
which associates a set of additional parameters with the listener. |
| EventObject |
The root class from which all event state objects shall be derived.
|
| FormattableFlags |
FomattableFlags are passed to the
Formattable.formatTo() method and modify the output format for Formattables. |
| Formatter |
An interpreter for printf-style format strings.
|
| GregorianCalendar |
GregorianCalendar is a concrete subclass of
Calendar and provides the standard calendar system
used by most of the world. |
| HashMap<K,V> |
Hash table based implementation of the Map interface.
|
| HashSet<E> |
This class implements the Set interface, backed by a hash table
(actually a HashMap instance).
|
| Hashtable<K,V> |
This class implements a hash table, which maps keys to values.
|
| IdentityHashMap<K,V> |
This class implements the Map interface with a hash table, using
reference-equality in place of object-equality when comparing keys (and
values).
|
| IntSummaryStatistics |
A state object for collecting statistics such as count, min, max, sum, and
average.
|
| LinkedHashMap<K,V> |
Hash table and linked list implementation of the Map interface,
with predictable iteration order.
|
| LinkedHashSet<E> |
Hash table and linked list implementation of the Set interface,
with predictable iteration order.
|
| LinkedList<E> |
Doubly-linked list implementation of the
List and Deque
interfaces. |
| ListResourceBundle |
ListResourceBundle is an abstract subclass of
ResourceBundle that manages resources for a locale
in a convenient and easy to use list. |
| Locale |
A
Locale object represents a specific geographical, political,
or cultural region. |
| Locale.Builder |
Builder is used to build instances of Locale
from values configured by the setters. |
| Locale.LanguageRange |
This class expresses a Language Range defined in
RFC 4647 Matching of
Language Tags.
|
| LongSummaryStatistics |
A state object for collecting statistics such as count, min, max, sum, and
average.
|
| Objects |
This class consists of
static utility methods for operating
on objects. |
| Observable |
This class represents an observable object, or "data"
in the model-view paradigm.
|
| Optional<T> |
A container object which may or may not contain a non-null value.
|
| OptionalDouble |
A container object which may or may not contain a
double value. |
| OptionalInt |
A container object which may or may not contain a
int value. |
| OptionalLong |
A container object which may or may not contain a
long value. |
| PriorityQueue<E> |
An unbounded priority queue based on a priority heap.
|
| Properties |
The
Properties class represents a persistent set of
properties. |
| PropertyPermission |
This class is for property permissions.
|
| PropertyResourceBundle |
PropertyResourceBundle is a concrete subclass of
ResourceBundle that manages resources for a locale
using a set of static strings from a property file. |
| Random |
An instance of this class is used to generate a stream of
pseudorandom numbers.
|
| ResourceBundle |
Resource bundles contain locale-specific objects.
|
| ResourceBundle.Control |
ResourceBundle.Control defines a set of callback methods
that are invoked by the ResourceBundle.getBundle factory
methods during the bundle loading process. |
| Scanner |
A simple text scanner which can parse primitive types and strings using
regular expressions.
|
| ServiceLoader<S> |
A simple service-provider loading facility.
|
| SimpleTimeZone |
SimpleTimeZone is a concrete subclass of TimeZone
that represents a time zone for use with a Gregorian calendar. |
| Spliterators |
Static classes and methods for operating on or creating instances of
Spliterator and its primitive specializations
Spliterator.OfInt , Spliterator.OfLong , and
Spliterator.OfDouble . |
| Spliterators.AbstractDoubleSpliterator |
An abstract
Spliterator.OfDouble that implements
trySplit to permit limited parallelism. |
| Spliterators.AbstractIntSpliterator |
An abstract
Spliterator.OfInt that implements trySplit to
permit limited parallelism. |
| Spliterators.AbstractLongSpliterator |
An abstract
Spliterator.OfLong that implements trySplit
to permit limited parallelism. |
| Spliterators.AbstractSpliterator<T> |
An abstract
Spliterator that implements trySplit to
permit limited parallelism. |
| SplittableRandom |
A generator of uniform pseudorandom values applicable for use in
(among other contexts) isolated parallel computations that may
generate subtasks.
|
| Stack<E> |
The
Stack class represents a last-in-first-out
(LIFO) stack of objects. |
| StringJoiner |
StringJoiner is used to construct a sequence of characters separated
by a delimiter and optionally starting with a supplied prefix
and ending with a supplied suffix. |
| StringTokenizer |
The string tokenizer class allows an application to break a
string into tokens.
|
| Timer |
A facility for threads to schedule tasks for future execution in a
background thread.
|
| TimerTask |
A task that can be scheduled for one-time or repeated execution by a Timer.
|
| TimeZone |
TimeZone represents a time zone offset, and also figures out daylight
savings. |
| TreeMap<K,V> |
A Red-Black tree based
NavigableMap implementation. |
| TreeSet<E> |
A
NavigableSet implementation based on a TreeMap . |
| UUID |
A class that represents an immutable universally unique identifier (UUID).
|
| Vector<E> |
The
Vector class implements a growable array of
objects. |
| WeakHashMap<K,V> |
Hash table based implementation of the Map interface, with
weak keys.
|
| Enum | Description |
|---|---|
| Formatter.BigDecimalLayoutForm |
Enum for
BigDecimal formatting. |
| Locale.Category |
Enum for locale categories.
|
| Locale.FilteringMode |
This enum provides constants to select a filtering mode for locale
matching.
|
| Exception | Description |
|---|---|
| ConcurrentModificationException |
This exception may be thrown by methods that have detected concurrent
modification of an object when such modification is not permissible.
|
| DuplicateFormatFlagsException |
Unchecked exception thrown when duplicate flags are provided in the format
specifier.
|
| EmptyStackException |
Thrown by methods in the
Stack class to indicate
that the stack is empty. |
| FormatFlagsConversionMismatchException |
Unchecked exception thrown when a conversion and flag are incompatible.
|
| FormatterClosedException |
Unchecked exception thrown when the formatter has been closed.
|
| IllegalFormatCodePointException |
Unchecked exception thrown when a character with an invalid Unicode code
point as defined by
Character.isValidCodePoint(int) is passed to the
Formatter . |
| IllegalFormatConversionException |
Unchecked exception thrown when the argument corresponding to the format
specifier is of an incompatible type.
|
| IllegalFormatException |
Unchecked exception thrown when a format string contains an illegal syntax
or a format specifier that is incompatible with the given arguments.
|
| IllegalFormatFlagsException |
Unchecked exception thrown when an illegal combination flags is given.
|
| IllegalFormatPrecisionException |
Unchecked exception thrown when the precision is a negative value other than
-1, the conversion does not support a precision, or the value is
otherwise unsupported.
|
| IllegalFormatWidthException |
Unchecked exception thrown when the format width is a negative value other
than -1 or is otherwise unsupported.
|
| IllformedLocaleException |
Thrown by methods in
Locale and Locale.Builder to
indicate that an argument is not a well-formed BCP 47 tag. |
| InputMismatchException |
Thrown by a
Scanner to indicate that the token
retrieved does not match the pattern for the expected type, or
that the token is out of range for the expected type. |
| InvalidPropertiesFormatException |
Thrown to indicate that an operation could not complete because
the input did not conform to the appropriate XML document type
for a collection of properties, as per the
Properties
specification. |
| MissingFormatArgumentException |
Unchecked exception thrown when there is a format specifier which does not
have a corresponding argument or if an argument index refers to an argument
that does not exist.
|
| MissingFormatWidthException |
Unchecked exception thrown when the format width is required.
|
| MissingResourceException |
Signals that a resource is missing.
|
| NoSuchElementException |
Thrown by various accessor methods to indicate that the element being requested
does not exist.
|
| TooManyListenersException |
The
TooManyListenersException Exception is used as part of
the Java Event model to annotate and implement a unicast special case of
a multicast Event Source. |
| UnknownFormatConversionException |
Unchecked exception thrown when an unknown conversion is given.
|
| UnknownFormatFlagsException |
Unchecked exception thrown when an unknown flag is given.
|
| Error | Description |
|---|---|
| ServiceConfigurationError |
Error thrown when something goes wrong while loading a service provider.
|
| Interface | Description |
|---|---|
| BlockingDeque<E> |
A
Deque that additionally supports blocking operations that wait
for the deque to become non-empty when retrieving an element, and wait for
space to become available in the deque when storing an element. |
| BlockingQueue<E> |
A
Queue that additionally supports operations
that wait for the queue to become non-empty when retrieving an
element, and wait for space to become available in the queue when
storing an element. |
| Callable<V> |
A task that returns a result and may throw an exception.
|
| CompletableFuture.AsynchronousCompletionTask |
A marker interface identifying asynchronous tasks produced by
async methods. |
| CompletionService<V> |
A service that decouples the production of new asynchronous tasks
from the consumption of the results of completed tasks.
|
| CompletionStage<T> |
A stage of a possibly asynchronous computation, that performs an
action or computes a value when another CompletionStage completes.
|
| ConcurrentMap<K,V> |
A
Map providing thread safety and atomicity
guarantees. |
| ConcurrentNavigableMap<K,V> |
A
ConcurrentMap supporting NavigableMap operations,
and recursively so for its navigable sub-maps. |
| Delayed |
A mix-in style interface for marking objects that should be
acted upon after a given delay.
|
| Executor |
An object that executes submitted
Runnable tasks. |
| ExecutorService | |
| ForkJoinPool.ForkJoinWorkerThreadFactory |
Factory for creating new
ForkJoinWorkerThread s. |
| ForkJoinPool.ManagedBlocker |
Interface for extending managed parallelism for tasks running
in
ForkJoinPool s. |
| Future<V> |
A
Future represents the result of an asynchronous
computation. |
| RejectedExecutionHandler |
A handler for tasks that cannot be executed by a
ThreadPoolExecutor . |
| RunnableFuture<V> | |
| RunnableScheduledFuture<V> |
A
ScheduledFuture that is Runnable . |
| ScheduledExecutorService |
An
ExecutorService that can schedule commands to run after a given
delay, or to execute periodically. |
| ScheduledFuture<V> |
A delayed result-bearing action that can be cancelled.
|
| ThreadFactory |
An object that creates new threads on demand.
|
| TransferQueue<E> |
A
BlockingQueue in which producers may wait for consumers
to receive elements. |
| Class | Description |
|---|---|
| AbstractExecutorService |
Provides default implementations of
ExecutorService
execution methods. |
| ArrayBlockingQueue<E> |
A bounded blocking queue backed by an
array.
|
| CompletableFuture<T> |
A
Future that may be explicitly completed (setting its
value and status), and may be used as a CompletionStage ,
supporting dependent functions and actions that trigger upon its
completion. |
| ConcurrentHashMap<K,V> |
A hash table supporting full concurrency of retrievals and
high expected concurrency for updates.
|
| ConcurrentHashMap.KeySetView<K,V> |
A view of a ConcurrentHashMap as a
Set of keys, in
which additions may optionally be enabled by mapping to a
common value. |
| ConcurrentLinkedDeque<E> |
An unbounded concurrent deque based on linked nodes.
|
| ConcurrentLinkedQueue<E> |
An unbounded thread-safe queue based on linked nodes.
|
| ConcurrentSkipListMap<K,V> |
A scalable concurrent
ConcurrentNavigableMap implementation. |
| ConcurrentSkipListSet<E> |
A scalable concurrent
NavigableSet implementation based on
a ConcurrentSkipListMap . |
| CopyOnWriteArrayList<E> |
A thread-safe variant of
ArrayList in which all mutative
operations (add , set , and so on) are implemented by
making a fresh copy of the underlying array. |
| CopyOnWriteArraySet<E> |
A
Set that uses an internal CopyOnWriteArrayList
for all of its operations. |
| CountDownLatch |
A synchronization aid that allows one or more threads to wait until
a set of operations being performed in other threads completes.
|
| CountedCompleter<T> |
A
ForkJoinTask with a completion action performed when
triggered and there are no remaining pending actions. |
| CyclicBarrier |
A synchronization aid that allows a set of threads to all wait for
each other to reach a common barrier point.
|
| DelayQueue<E extends Delayed> |
An unbounded blocking queue of
Delayed elements, in which an element can only be taken
when its delay has expired. |
| Exchanger<V> |
A synchronization point at which threads can pair and swap elements
within pairs.
|
| ExecutorCompletionService<V> |
A
CompletionService that uses a supplied Executor
to execute tasks. |
| Executors |
Factory and utility methods for
Executor , ExecutorService , ScheduledExecutorService , ThreadFactory , and Callable classes defined in this
package. |
| ForkJoinPool |
An
ExecutorService for running ForkJoinTask s. |
| ForkJoinTask<V> |
Abstract base class for tasks that run within a
ForkJoinPool . |
| ForkJoinWorkerThread |
A thread managed by a
ForkJoinPool , which executes
ForkJoinTask s. |
| FutureTask<V> |
A cancellable asynchronous computation.
|
| LinkedBlockingDeque<E> |
An optionally-bounded blocking deque based on
linked nodes.
|
| LinkedBlockingQueue<E> |
An optionally-bounded blocking queue based on
linked nodes.
|
| LinkedTransferQueue<E> |
An unbounded
TransferQueue based on linked nodes. |
| Phaser |
A reusable synchronization barrier, similar in functionality to
CyclicBarrier and
CountDownLatch
but supporting more flexible usage. |
| PriorityBlockingQueue<E> |
An unbounded blocking queue that uses
the same ordering rules as class
PriorityQueue and supplies
blocking retrieval operations. |
| RecursiveAction |
A recursive resultless
ForkJoinTask . |
| RecursiveTask<V> |
A recursive result-bearing
ForkJoinTask . |
| ScheduledThreadPoolExecutor |
A
ThreadPoolExecutor that can additionally schedule
commands to run after a given delay, or to execute
periodically. |
| Semaphore |
A counting semaphore.
|
| SynchronousQueue<E> |
A blocking queue in which each insert
operation must wait for a corresponding remove operation by another
thread, and vice versa.
|
| ThreadLocalRandom |
A random number generator isolated to the current thread.
|
| ThreadPoolExecutor |
An
ExecutorService that executes each submitted task using
one of possibly several pooled threads, normally configured
using Executors factory methods. |
| ThreadPoolExecutor.AbortPolicy |
A handler for rejected tasks that throws a
RejectedExecutionException . |
| ThreadPoolExecutor.CallerRunsPolicy |
A handler for rejected tasks that runs the rejected task
directly in the calling thread of the
execute method,
unless the executor has been shut down, in which case the task
is discarded. |
| ThreadPoolExecutor.DiscardOldestPolicy |
A handler for rejected tasks that discards the oldest unhandled
request and then retries
execute , unless the executor
is shut down, in which case the task is discarded. |
| ThreadPoolExecutor.DiscardPolicy |
A handler for rejected tasks that silently discards the
rejected task.
|
| Enum | Description |
|---|---|
| TimeUnit |
A
TimeUnit represents time durations at a given unit of
granularity and provides utility methods to convert across units,
and to perform timing and delay operations in these units. |
| Exception | Description |
|---|---|
| BrokenBarrierException |
Exception thrown when a thread tries to wait upon a barrier that is
in a broken state, or which enters the broken state while the thread
is waiting.
|
| CancellationException |
Exception indicating that the result of a value-producing task,
such as a
FutureTask , cannot be retrieved because the task
was cancelled. |
| CompletionException |
Exception thrown when an error or other exception is encountered
in the course of completing a result or task.
|
| ExecutionException |
Exception thrown when attempting to retrieve the result of a task
that aborted by throwing an exception.
|
| RejectedExecutionException |
Exception thrown by an
Executor when a task cannot be
accepted for execution. |
| TimeoutException |
Exception thrown when a blocking operation times out.
|
| Class | Description |
|---|---|
| AtomicBoolean |
A
boolean value that may be updated atomically. |
| AtomicInteger |
An
int value that may be updated atomically. |
| AtomicIntegerArray |
An
int array in which elements may be updated atomically. |
| AtomicIntegerFieldUpdater<T> |
A reflection-based utility that enables atomic updates to
designated
volatile int fields of designated classes. |
| AtomicLong |
A
long value that may be updated atomically. |
| AtomicLongArray |
A
long array in which elements may be updated atomically. |
| AtomicLongFieldUpdater<T> |
A reflection-based utility that enables atomic updates to
designated
volatile long fields of designated classes. |
| AtomicMarkableReference<V> |
An
AtomicMarkableReference maintains an object reference
along with a mark bit, that can be updated atomically. |
| AtomicReference<V> |
An object reference that may be updated atomically.
|
| AtomicReferenceArray<E> |
An array of object references in which elements may be updated
atomically.
|
| AtomicReferenceFieldUpdater<T,V> |
A reflection-based utility that enables atomic updates to
designated
volatile reference fields of designated
classes. |
| AtomicStampedReference<V> |
An
AtomicStampedReference maintains an object reference
along with an integer "stamp", that can be updated atomically. |
| DoubleAccumulator |
One or more variables that together maintain a running
double
value updated using a supplied function. |
| DoubleAdder |
One or more variables that together maintain an initially zero
double sum. |
| LongAccumulator |
One or more variables that together maintain a running
long
value updated using a supplied function. |
| LongAdder |
One or more variables that together maintain an initially zero
long sum. |
| Interface | Description |
|---|---|
| Condition | |
| Lock |
Lock implementations provide more extensive locking
operations than can be obtained using synchronized methods
and statements. |
| ReadWriteLock |
A
ReadWriteLock maintains a pair of associated locks , one for read-only operations and one for writing. |
| Class | Description |
|---|---|
| AbstractOwnableSynchronizer |
A synchronizer that may be exclusively owned by a thread.
|
| AbstractQueuedLongSynchronizer |
A version of
AbstractQueuedSynchronizer in
which synchronization state is maintained as a long . |
| AbstractQueuedSynchronizer |
Provides a framework for implementing blocking locks and related
synchronizers (semaphores, events, etc) that rely on
first-in-first-out (FIFO) wait queues.
|
| LockSupport |
Basic thread blocking primitives for creating locks and other
synchronization classes.
|
| ReentrantLock |
A reentrant mutual exclusion
Lock with the same basic
behavior and semantics as the implicit monitor lock accessed using
synchronized methods and statements, but with extended
capabilities. |
| ReentrantReadWriteLock |
An implementation of
ReadWriteLock supporting similar
semantics to ReentrantLock . |
| ReentrantReadWriteLock.ReadLock |
The lock returned by method
ReentrantReadWriteLock.readLock() . |
| ReentrantReadWriteLock.WriteLock |
The lock returned by method
ReentrantReadWriteLock.writeLock() . |
| StampedLock |
A capability-based lock with three modes for controlling read/write
access.
|
| Interface | Description |
|---|---|
| BiConsumer<T,U> |
Represents an operation that accepts two input arguments and returns no
result.
|
| BiFunction<T,U,R> |
Represents a function that accepts two arguments and produces a result.
|
| BinaryOperator<T> |
Represents an operation upon two operands of the same type, producing a result
of the same type as the operands.
|
| BiPredicate<T,U> |
Represents a predicate (boolean-valued function) of two arguments.
|
| BooleanSupplier |
Represents a supplier of
boolean -valued results. |
| Consumer<T> |
Represents an operation that accepts a single input argument and returns no
result.
|
| DoubleBinaryOperator |
Represents an operation upon two
double -valued operands and producing a
double -valued result. |
| DoubleConsumer |
Represents an operation that accepts a single
double -valued argument and
returns no result. |
| DoubleFunction<R> |
Represents a function that accepts a double-valued argument and produces a
result.
|
| DoublePredicate |
Represents a predicate (boolean-valued function) of one
double -valued
argument. |
| DoubleSupplier |
Represents a supplier of
double -valued results. |
| DoubleToIntFunction |
Represents a function that accepts a double-valued argument and produces an
int-valued result.
|
| DoubleToLongFunction |
Represents a function that accepts a double-valued argument and produces a
long-valued result.
|
| DoubleUnaryOperator |
Represents an operation on a single
double -valued operand that produces
a double -valued result. |
| Function<T,R> |
Represents a function that accepts one argument and produces a result.
|
| IntBinaryOperator |
Represents an operation upon two
int -valued operands and producing an
int -valued result. |
| IntConsumer |
Represents an operation that accepts a single
int -valued argument and
returns no result. |
| IntFunction<R> |
Represents a function that accepts an int-valued argument and produces a
result.
|
| IntPredicate |
Represents a predicate (boolean-valued function) of one
int -valued
argument. |
| IntSupplier |
Represents a supplier of
int -valued results. |
| IntToDoubleFunction |
Represents a function that accepts an int-valued argument and produces a
double-valued result.
|
| IntToLongFunction |
Represents a function that accepts an int-valued argument and produces a
long-valued result.
|
| IntUnaryOperator |
Represents an operation on a single
int -valued operand that produces
an int -valued result. |
| LongBinaryOperator |
Represents an operation upon two
long -valued operands and producing a
long -valued result. |
| LongConsumer |
Represents an operation that accepts a single
long -valued argument and
returns no result. |
| LongFunction<R> |
Represents a function that accepts a long-valued argument and produces a
result.
|
| LongPredicate |
Represents a predicate (boolean-valued function) of one
long -valued
argument. |
| LongSupplier |
Represents a supplier of
long -valued results. |
| LongToDoubleFunction |
Represents a function that accepts a long-valued argument and produces a
double-valued result.
|
| LongToIntFunction |
Represents a function that accepts a long-valued argument and produces an
int-valued result.
|
| LongUnaryOperator |
Represents an operation on a single
long -valued operand that produces
a long -valued result. |
| ObjDoubleConsumer<T> |
Represents an operation that accepts an object-valued and a
double -valued argument, and returns no result. |
| ObjIntConsumer<T> |
Represents an operation that accepts an object-valued and a
int -valued argument, and returns no result. |
| ObjLongConsumer<T> |
Represents an operation that accepts an object-valued and a
long -valued argument, and returns no result. |
| Predicate<T> |
Represents a predicate (boolean-valued function) of one argument.
|
| Supplier<T> |
Represents a supplier of results.
|
| ToDoubleBiFunction<T,U> |
Represents a function that accepts two arguments and produces a double-valued
result.
|
| ToDoubleFunction<T> |
Represents a function that produces a double-valued result.
|
| ToIntBiFunction<T,U> |
Represents a function that accepts two arguments and produces an int-valued
result.
|
| ToIntFunction<T> |
Represents a function that produces an int-valued result.
|
| ToLongBiFunction<T,U> |
Represents a function that accepts two arguments and produces a long-valued
result.
|
| ToLongFunction<T> |
Represents a function that produces a long-valued result.
|
| UnaryOperator<T> |
Represents an operation on a single operand that produces a result of the
same type as its operand.
|
| 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
JarFile class is used to read the contents of a jar file
from any file that can be opened with java.io.RandomAccessFile . |
| JarInputStream |
The
JarInputStream class is used to read the contents of
a JAR file from any input stream. |
| JarOutputStream |
The
JarOutputStream class is used to write the contents
of a JAR file to any output stream. |
| Manifest |
The Manifest class is used to maintain Manifest entry names and their
associated Attributes.
|
| Pack200 |
Transforms a JAR file to or from a packed stream in Pack200 format.
|
| Exception | 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
LogRecord in a human readable
format. |
| SocketHandler |
Simple network logging Handler.
|
| StreamHandler |
Stream based logging Handler.
|
| XMLFormatter |
Format a LogRecord into a standard XML format.
|
| 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
Calendar parameters. |
| CalendarNameProvider |
An abstract class for service providers that provide localized string
representations (display names) of
Calendar field values. |
| CurrencyNameProvider |
An abstract class for service providers that
provide localized currency symbols and display names for the
Currency class. |
| LocaleNameProvider |
An abstract class for service providers that
provide localized names for the
Locale class. |
| LocaleServiceProvider |
This is the super class of all the locale sensitive service provider
interfaces (SPIs).
|
| TimeZoneNameProvider |
An abstract class for service providers that
provide localized time zone names for the
TimeZone class. |
| 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
Collector that implement various useful reduction
operations, such as accumulating elements into collections, summarizing
elements according to various criteria, etc. |
| StreamSupport |
Low-level utility methods for creating and manipulating streams.
|
| Enum | 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
Cipher class. |
| EncryptedPrivateKeyInfo |
This class implements the
EncryptedPrivateKeyInfo type
as defined in PKCS #8. |
| ExemptionMechanism |