IT. Expert System.

Java Standard Edition (SE)

compact1


Profile compact1

    • java.io

      Interface Summary 
      Interface Description
      Closeable
      A Closeable is a source or destination of data that can be closed.
      DataInput
      The DataInput interface provides for reading bytes from a binary stream and reconstructing from them data in any of the Java primitive types.
      DataOutput
      The DataOutput interface provides for converting data from any of the Java primitive types to a series of bytes and writing these bytes to a binary stream.
      Externalizable
      Only the identity of the class of an Externalizable instance is written in the serialization stream and it is the responsibility of the class to save and restore the contents of its instances.
      FileFilter
      A filter for abstract pathnames.
      FilenameFilter
      Instances of classes that implement this interface are used to filter filenames.
      Flushable
      A Flushable is a destination of data that can be flushed.
      ObjectInput
      ObjectInput extends the DataInput interface to include the reading of objects.
      ObjectInputValidation
      Callback interface to allow validation of objects within a graph.
      ObjectOutput
      ObjectOutput extends the DataOutput interface to include writing of objects.
      ObjectStreamConstants
      Constants written into the Object Serialization Stream.
      Serializable
      Serializability of a class is enabled by the class implementing the java.io.Serializable interface.
      Class Summary 
      Class Description
      BufferedInputStream
      A BufferedInputStream adds functionality to another input stream-namely, the ability to buffer the input and to support the mark and reset methods.
      BufferedOutputStream
      The class implements a buffered output stream.
      BufferedReader
      Reads text from a character-input stream, buffering characters so as to provide for the efficient reading of characters, arrays, and lines.
      BufferedWriter
      Writes text to a character-output stream, buffering characters so as to provide for the efficient writing of single characters, arrays, and strings.
      ByteArrayInputStream
      A ByteArrayInputStream contains an internal buffer that contains bytes that may be read from the stream.
      ByteArrayOutputStream
      This class implements an output stream in which the data is written into a byte array.
      CharArrayReader
      This class implements a character buffer that can be used as a character-input stream.
      CharArrayWriter
      This class implements a character buffer that can be used as an Writer.
      Console
      Methods to access the character-based console device, if any, associated with the current Java virtual machine.
      DataInputStream
      A data input stream lets an application read primitive Java data types from an underlying input stream in a machine-independent way.
      DataOutputStream
      A data output stream lets an application write primitive Java data types to an output stream in a portable way.
      File
      An abstract representation of file and directory pathnames.
      FileDescriptor
      Instances of the file descriptor class serve as an opaque handle to the underlying machine-specific structure representing an open file, an open socket, or another source or sink of bytes.
      FileInputStream
      A FileInputStream obtains input bytes from a file in a file system.
      FileOutputStream
      A file output stream is an output stream for writing data to a File or to a FileDescriptor.
      FilePermission
      This class represents access to a file or directory.
      FileReader
      Convenience class for reading character files.
      FileWriter
      Convenience class for writing character files.
      FilterInputStream
      A FilterInputStream contains some other input stream, which it uses as its basic source of data, possibly transforming the data along the way or providing additional functionality.
      FilterOutputStream
      This class is the superclass of all classes that filter output streams.
      FilterReader
      Abstract class for reading filtered character streams.
      FilterWriter
      Abstract class for writing filtered character streams.
      InputStream
      This abstract class is the superclass of all classes representing an input stream of bytes.
      InputStreamReader
      An InputStreamReader is a bridge from byte streams to character streams: It reads bytes and decodes them into characters using a specified charset.
      LineNumberInputStream Deprecated
      This class incorrectly assumes that bytes adequately represent characters.
      LineNumberReader
      A buffered character-input stream that keeps track of line numbers.
      ObjectInputStream
      An ObjectInputStream deserializes primitive data and objects previously written using an ObjectOutputStream.
      ObjectInputStream.GetField
      Provide access to the persistent fields read from the input stream.
      ObjectOutputStream
      An ObjectOutputStream writes primitive data types and graphs of Java objects to an OutputStream.
      ObjectOutputStream.PutField
      Provide programmatic access to the persistent fields to be written to ObjectOutput.
      ObjectStreamClass
      Serialization's descriptor for classes.
      ObjectStreamField
      A description of a Serializable field from a Serializable class.
      OutputStream
      This abstract class is the superclass of all classes representing an output stream of bytes.
      OutputStreamWriter
      An OutputStreamWriter is a bridge from character streams to byte streams: Characters written to it are encoded into bytes using a specified charset.
      PipedInputStream
      A piped input stream should be connected to a piped output stream; the piped input stream then provides whatever data bytes are written to the piped output stream.
      PipedOutputStream
      A piped output stream can be connected to a piped input stream to create a communications pipe.
      PipedReader
      Piped character-input streams.
      PipedWriter
      Piped character-output streams.
      PrintStream
      A PrintStream adds functionality to another output stream, namely the ability to print representations of various data values conveniently.
      PrintWriter
      Prints formatted representations of objects to a text-output stream.
      PushbackInputStream
      A PushbackInputStream adds functionality to another input stream, namely the ability to "push back" or "unread" one byte.
      PushbackReader
      A character-stream reader that allows characters to be pushed back into the stream.
      RandomAccessFile
      Instances of this class support both reading and writing to a random access file.
      Reader
      Abstract class for reading character streams.
      SequenceInputStream
      A SequenceInputStream represents the logical concatenation of other input streams.
      SerializablePermission
      This class is for Serializable permissions.
      StreamTokenizer
      The StreamTokenizer class takes an input stream and parses it into "tokens", allowing the tokens to be read one at a time.
      StringBufferInputStream Deprecated
      This class does not properly convert characters into bytes.
      StringReader
      A character stream whose source is a string.
      StringWriter
      A character stream that collects its output in a string buffer, which can then be used to construct a string.
      Writer
      Abstract class for writing to character streams.
      Exception Summary 
      Exception Description
      CharConversionException
      Base class for character conversion exceptions.
      EOFException
      Signals that an end of file or end of stream has been reached unexpectedly during input.
      FileNotFoundException
      Signals that an attempt to open the file denoted by a specified pathname has failed.
      InterruptedIOException
      Signals that an I/O operation has been interrupted.
      InvalidClassException
      Thrown when the Serialization runtime detects one of the following problems with a Class.
      InvalidObjectException
      Indicates that one or more deserialized objects failed validation tests.
      IOException
      Signals that an I/O exception of some sort has occurred.
      NotActiveException
      Thrown when serialization or deserialization is not active.
      NotSerializableException
      Thrown when an instance is required to have a Serializable interface.
      ObjectStreamException
      Superclass of all exceptions specific to Object Stream classes.
      OptionalDataException
      Exception indicating the failure of an object read operation due to unread primitive data, or the end of data belonging to a serialized object in the stream.
      StreamCorruptedException
      Thrown when control information that was read from an object stream violates internal consistency checks.
      SyncFailedException
      Signals that a sync operation has failed.
      UncheckedIOException
      Wraps an IOException with an unchecked exception.
      UnsupportedEncodingException
      The Character Encoding is not supported.
      UTFDataFormatException
      Signals that a malformed string in modified UTF-8 format has been read in a data input stream or by any class that implements the data input interface.
      WriteAbortedException
      Signals that one of the ObjectStreamExceptions was thrown during a write operation.
      Error Summary 
      Error Description
      IOError
      Thrown when a serious I/O error has occurred.
    • java.lang

      Interface Summary 
      Interface Description
      Appendable
      An object to which char sequences and values can be appended.
      AutoCloseable
      An object that may hold resources (such as file or socket handles) until it is closed.
      CharSequence
      A CharSequence is a readable sequence of char values.
      Cloneable
      A class implements the Cloneable interface to indicate to the Object.clone() method that it is legal for that method to make a field-for-field copy of instances of that class.
      Comparable<T>
      This interface imposes a total ordering on the objects of each class that implements it.
      Iterable<T>
      Implementing this interface allows an object to be the target of the "for-each loop" statement.
      Readable
      A Readable is a source of characters.
      Runnable
      The Runnable interface should be implemented by any class whose instances are intended to be executed by a thread.
      Thread.UncaughtExceptionHandler
      Interface for handlers invoked when a Thread abruptly terminates due to an uncaught exception.
      Class Summary 
      Class Description
      Boolean
      The Boolean class wraps a value of the primitive type boolean in an object.
      Byte
      The Byte class wraps a value of primitive type byte in an object.
      Character
      The Character class wraps a value of the primitive type char in an object.
      Character.Subset
      Instances of this class represent particular subsets of the Unicode character set.
      Character.UnicodeBlock
      A family of character subsets representing the character blocks in the Unicode specification.
      Class<T>
      Instances of the class Class represent classes and interfaces in a running Java application.
      ClassLoader
      A class loader is an object that is responsible for loading classes.
      ClassValue<T>
      Lazily associate a computed value with (potentially) every type.
      Compiler
      The Compiler class is provided to support Java-to-native-code compilers and related services.
      Double
      The Double class wraps a value of the primitive type double in an object.
      Enum<E extends Enum<E>>
      This is the common base class of all Java language enumeration types.
      Float
      The Float class wraps a value of primitive type float in an object.
      InheritableThreadLocal<T>
      This class extends ThreadLocal to provide inheritance of values from parent thread to child thread: when a child thread is created, the child receives initial values for all inheritable thread-local variables for which the parent has values.
      Integer
      The Integer class wraps a value of the primitive type int in an object.
      Long
      The Long class wraps a value of the primitive type long in an object.
      Math
      The class Math contains methods for performing basic numeric operations such as the elementary exponential, logarithm, square root, and trigonometric functions.
      Number
      The abstract class Number is the superclass of platform classes representing numeric values that are convertible to the primitive types byte, double, float, int, long, and short.
      Object
      Class Object is the root of the class hierarchy.
      Package
      Package objects contain version information about the implementation and specification of a Java package.
      Process
      The ProcessBuilder.start() and Runtime.exec methods create a native process and return an instance of a subclass of Process that can be used to control the process and obtain information about it.
      ProcessBuilder
      This class is used to create operating system processes.
      ProcessBuilder.Redirect
      Represents a source of subprocess input or a destination of subprocess output.
      Runtime
      Every Java application has a single instance of class Runtime that allows the application to interface with the environment in which the application is running.
      RuntimePermission
      This class is for runtime permissions.
      SecurityManager
      The security manager is a class that allows applications to implement a security policy.
      Short
      The Short class wraps a value of primitive type short in an object.
      StackTraceElement
      An element in a stack trace, as returned by Throwable.getStackTrace().
      StrictMath
      The class StrictMath contains methods for performing basic numeric operations such as the elementary exponential, logarithm, square root, and trigonometric functions.
      String
      The String class represents character strings.
      StringBuffer
      A thread-safe, mutable sequence of characters.
      StringBuilder
      A mutable sequence of characters.
      System
      The System class contains several useful class fields and methods.
      Thread
      A thread is a thread of execution in a program.
      ThreadGroup
      A thread group represents a set of threads.
      ThreadLocal<T>
      This class provides thread-local variables.
      Throwable
      The Throwable class is the superclass of all errors and exceptions in the Java language.
      Void
      The Void class is an uninstantiable placeholder class to hold a reference to the Class object representing the Java keyword void.
      Enum Summary 
      Enum Description
      Character.UnicodeScript
      A family of character subsets representing the character scripts defined in the Unicode Standard Annex #24: Script Names.
      ProcessBuilder.Redirect.Type
      Thread.State
      A thread state.
      Exception Summary 
      Exception Description
      ArithmeticException
      Thrown when an exceptional arithmetic condition has occurred.
      ArrayIndexOutOfBoundsException
      Thrown to indicate that an array has been accessed with an illegal index.
      ArrayStoreException
      Thrown to indicate that an attempt has been made to store the wrong type of object into an array of objects.
      ClassCastException
      Thrown to indicate that the code has attempted to cast an object to a subclass of which it is not an instance.
      ClassNotFoundException
      Thrown when an application tries to load in a class through its string name using: The forName method in class Class.
      CloneNotSupportedException
      Thrown to indicate that the clone method in class Object has been called to clone an object, but that the object's class does not implement the Cloneable interface.
      EnumConstantNotPresentException
      Thrown when an application tries to access an enum constant by name and the enum type contains no constant with the specified name.
      Exception
      The class Exception and its subclasses are a form of Throwable that indicates conditions that a reasonable application might want to catch.
      IllegalAccessException
      An IllegalAccessException is thrown when an application tries to reflectively create an instance (other than an array), set or get a field, or invoke a method, but the currently executing method does not have access to the definition of the specified class, field, method or constructor.
      IllegalArgumentException
      Thrown to indicate that a method has been passed an illegal or inappropriate argument.
      IllegalMonitorStateException
      Thrown to indicate that a thread has attempted to wait on an object's monitor or to notify other threads waiting on an object's monitor without owning the specified monitor.
      IllegalStateException
      Signals that a method has been invoked at an illegal or inappropriate time.
      IllegalThreadStateException
      Thrown to indicate that a thread is not in an appropriate state for the requested operation.
      IndexOutOfBoundsException
      Thrown to indicate that an index of some sort (such as to an array, to a string, or to a vector) is out of range.
      InstantiationException
      Thrown when an application tries to create an instance of a class using the newInstance method in class Class, but the specified class object cannot be instantiated.
      InterruptedException
      Thrown when a thread is waiting, sleeping, or otherwise occupied, and the thread is interrupted, either before or during the activity.
      NegativeArraySizeException
      Thrown if an application tries to create an array with negative size.
      NoSuchFieldException
      Signals that the class doesn't have a field of a specified name.
      NoSuchMethodException
      Thrown when a particular method cannot be found.
      NullPointerException
      Thrown when an application attempts to use null in a case where an object is required.
      NumberFormatException
      Thrown to indicate that the application has attempted to convert a string to one of the numeric types, but that the string does not have the appropriate format.
      ReflectiveOperationException
      Common superclass of exceptions thrown by reflective operations in core reflection.
      RuntimeException
      RuntimeException is the superclass of those exceptions that can be thrown during the normal operation of the Java Virtual Machine.
      SecurityException
      Thrown by the security manager to indicate a security violation.
      StringIndexOutOfBoundsException
      Thrown by String methods to indicate that an index is either negative or greater than the size of the string.
      TypeNotPresentException
      Thrown when an application tries to access a type using a string representing the type's name, but no definition for the type with the specified name can be found.
      UnsupportedOperationException
      Thrown to indicate that the requested operation is not supported.
      Error Summary 
      Error Description
      AbstractMethodError
      Thrown when an application tries to call an abstract method.
      AssertionError
      Thrown to indicate that an assertion has failed.
      BootstrapMethodError
      Thrown to indicate that an invokedynamic instruction has failed to find its bootstrap method, or the bootstrap method has failed to provide a call site with a target of the correct method type.
      ClassCircularityError
      Thrown when the Java Virtual Machine detects a circularity in the superclass hierarchy of a class being loaded.
      ClassFormatError
      Thrown when the Java Virtual Machine attempts to read a class file and determines that the file is malformed or otherwise cannot be interpreted as a class file.
      Error
      An Error is a subclass of Throwable that indicates serious problems that a reasonable application should not try to catch.
      ExceptionInInitializerError
      Signals that an unexpected exception has occurred in a static initializer.
      IllegalAccessError
      Thrown if an application attempts to access or modify a field, or to call a method that it does not have access to.
      IncompatibleClassChangeError
      Thrown when an incompatible class change has occurred to some class definition.
      InstantiationError
      Thrown when an application tries to use the Java new construct to instantiate an abstract class or an interface.
      InternalError
      Thrown to indicate some unexpected internal error has occurred in the Java Virtual Machine.
      LinkageError
      Subclasses of LinkageError indicate that a class has some dependency on another class; however, the latter class has incompatibly changed after the compilation of the former class.
      NoClassDefFoundError
      Thrown if the Java Virtual Machine or a ClassLoader instance tries to load in the definition of a class (as part of a normal method call or as part of creating a new instance using the new expression) and no definition of the class could be found.
      NoSuchFieldError
      Thrown if an application tries to access or modify a specified field of an object, and that object no longer has that field.
      NoSuchMethodError
      Thrown if an application tries to call a specified method of a class (either static or instance), and that class no longer has a definition of that method.
      OutOfMemoryError
      Thrown when the Java Virtual Machine cannot allocate an object because it is out of memory, and no more memory could be made available by the garbage collector.
      StackOverflowError
      Thrown when a stack overflow occurs because an application recurses too deeply.
      ThreadDeath
      An instance of ThreadDeath is thrown in the victim thread when the (deprecated) Thread.stop() method is invoked.
      UnknownError
      Thrown when an unknown but serious exception has occurred in the Java Virtual Machine.
      UnsatisfiedLinkError
      Thrown if the Java Virtual Machine cannot find an appropriate native-language definition of a method declared native.
      UnsupportedClassVersionError
      Thrown when the Java Virtual Machine attempts to read a class file and determines that the major and minor version numbers in the file are not supported.
      VerifyError
      Thrown when the "verifier" detects that a class file, though well formed, contains some sort of internal inconsistency or security problem.
      VirtualMachineError
      Thrown to indicate that the Java Virtual Machine is broken or has run out of resources necessary for it to continue operating.
      Annotation Types Summary 
      Annotation Type Description
      Deprecated
      A program element annotated @Deprecated is one that programmers are discouraged from using, typically because it is dangerous, or because a better alternative exists.
      FunctionalInterface
      An informative annotation type used to indicate that an interface type declaration is intended to be a functional interface as defined by the Java Language Specification.
      Override
      Indicates that a method declaration is intended to override a method declaration in a supertype.
      SafeVarargs
      A programmer assertion that the body of the annotated method or constructor does not perform potentially unsafe operations on its varargs parameter.
      SuppressWarnings
      Indicates that the named compiler warnings should be suppressed in the annotated element (and in all program elements contained in the annotated element).
    • java.lang.annotation

      Interface Summary 
      Interface Description
      Annotation
      The common interface extended by all annotation types.
      Enum Summary 
      Enum Description
      ElementType
      The constants of this enumerated type provide a simple classification of the syntactic locations where annotations may appear in a Java program.
      RetentionPolicy
      Annotation retention policy.
      Exception Summary 
      Exception Description
      AnnotationTypeMismatchException
      Thrown to indicate that a program has attempted to access an element of an annotation whose type has changed after the annotation was compiled (or serialized).
      IncompleteAnnotationException
      Thrown to indicate that a program has attempted to access an element of an annotation type that was added to the annotation type definition after the annotation was compiled (or serialized).
      Error Summary 
      Error Description
      AnnotationFormatError
      Thrown when the annotation parser attempts to read an annotation from a class file and determines that the annotation is malformed.
      Annotation Types Summary 
      Annotation Type Description
      Documented
      Indicates that annotations with a type are to be documented by javadoc and similar tools by default.
      Inherited
      Indicates that an annotation type is automatically inherited.
      Native
      Indicates that a field defining a constant value may be referenced from native code.
      Repeatable
      The annotation type java.lang.annotation.Repeatable is used to indicate that the annotation type whose declaration it (meta-)annotates is repeatable.
      Retention
      Indicates how long annotations with the annotated type are to be retained.
      Target
      Indicates the contexts in which an annotation type is applicable.
    • java.lang.invoke

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

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

      Interface Summary 
      Interface Description
      AnnotatedArrayType
      AnnotatedArrayType represents the potentially annotated use of an array type, whose component type may itself represent the annotated use of a type.
      AnnotatedElement
      Represents an annotated element of the program currently running in this VM.
      AnnotatedParameterizedType
      AnnotatedParameterizedType represents the potentially annotated use of a parameterized type, whose type arguments may themselves represent annotated uses of types.
      AnnotatedType
      AnnotatedType represents the potentially annotated use of a type in the program currently running in this VM.
      AnnotatedTypeVariable
      AnnotatedTypeVariable represents the potentially annotated use of a type variable, whose declaration may have bounds which themselves represent annotated uses of types.
      AnnotatedWildcardType
      AnnotatedWildcardType represents the potentially annotated use of a wildcard type argument, whose upper or lower bounds may themselves represent annotated uses of types.
      GenericArrayType
      GenericArrayType represents an array type whose component type is either a parameterized type or a type variable.
      GenericDeclaration
      A common interface for all entities that declare type variables.
      InvocationHandler
      InvocationHandler is the interface implemented by the invocation handler of a proxy instance.
      Member
      Member is an interface that reflects identifying information about a single member (a field or a method) or a constructor.
      ParameterizedType
      ParameterizedType represents a parameterized type such as Collection<String>.
      Type
      Type is the common superinterface for all types in the Java programming language.
      TypeVariable<D extends GenericDeclaration>
      TypeVariable is the common superinterface for type variables of kinds.
      WildcardType
      WildcardType represents a wildcard type expression, such as ?, ? extends Number, or ? super Integer.
      Class Summary 
      Class Description
      AccessibleObject
      The AccessibleObject class is the base class for Field, Method and Constructor objects.
      Array
      The Array class provides static methods to dynamically create and access Java arrays.
      Constructor<T>
      Constructor provides information about, and access to, a single constructor for a class.
      Executable
      A shared superclass for the common functionality of Method and Constructor.
      Field
      A Field provides information about, and dynamic access to, a single field of a class or an interface.
      Method
      A Method provides information about, and access to, a single method on a class or interface.
      Modifier
      The Modifier class provides static methods and constants to decode class and member access modifiers.
      Parameter
      Information about method parameters.
      Proxy
      Proxy provides static methods for creating dynamic proxy classes and instances, and it is also the superclass of all dynamic proxy classes created by those methods.
      ReflectPermission
      The Permission class for reflective operations.
      Exception Summary 
      Exception Description
      InvocationTargetException
      InvocationTargetException is a checked exception that wraps an exception thrown by an invoked method or constructor.
      MalformedParameterizedTypeException
      Thrown when a semantically malformed parameterized type is encountered by a reflective method that needs to instantiate it.
      MalformedParametersException
      Thrown when the java.lang.reflect package attempts to read method parameters from a class file and determines that one or more parameters are malformed.
      UndeclaredThrowableException
      Thrown by a method invocation on a proxy instance if its invocation handler's invoke method throws a checked exception (a Throwable that is not assignable to RuntimeException or Error) that is not assignable to any of the exception types declared in the throws clause of the method that was invoked on the proxy instance and dispatched to the invocation handler.
      Error Summary 
      Error Description
      GenericSignatureFormatError
      Thrown when a syntactically malformed signature attribute is encountered by a reflective method that needs to interpret the generic signature information for a type, method or constructor.
    • java.math

      Class Summary 
      Class Description
      BigDecimal
      Immutable, arbitrary-precision signed decimal numbers.
      BigInteger
      Immutable arbitrary-precision integers.
      MathContext
      Immutable objects which encapsulate the context settings which describe certain rules for numerical operators, such as those implemented by the BigDecimal class.
      Enum Summary 
      Enum Description
      RoundingMode
      Specifies a rounding behavior for numerical operations capable of discarding precision.
    • java.net

      Interface Summary 
      Interface Description
      ContentHandlerFactory
      This interface defines a factory for content handlers.
      CookiePolicy
      CookiePolicy implementations decide which cookies should be accepted and which should be rejected.
      CookieStore
      A CookieStore object represents a storage for cookie.
      DatagramSocketImplFactory
      This interface defines a factory for datagram socket implementations.
      FileNameMap
      A simple interface which provides a mechanism to map between a file name and a MIME type string.
      ProtocolFamily
      Represents a family of communication protocols.
      SocketImplFactory
      This interface defines a factory for socket implementations.
      SocketOption<T>
      A socket option associated with a socket.
      SocketOptions
      Interface of methods to get/set socket options.
      URLStreamHandlerFactory
      This interface defines a factory for URL stream protocol handlers.
      Class Summary 
      Class Description
      Authenticator
      The class Authenticator represents an object that knows how to obtain authentication for a network connection.
      CacheRequest
      Represents channels for storing resources in the ResponseCache.
      CacheResponse
      Represent channels for retrieving resources from the ResponseCache.
      ContentHandler
      The abstract class ContentHandler is the superclass of all classes that read an Object from a URLConnection.
      CookieHandler
      A CookieHandler object provides a callback mechanism to hook up a HTTP state management policy implementation into the HTTP protocol handler.
      CookieManager
      CookieManager provides a concrete implementation of CookieHandler, which separates the storage of cookies from the policy surrounding accepting and rejecting cookies.
      DatagramPacket
      This class represents a datagram packet.
      DatagramSocket
      This class represents a socket for sending and receiving datagram packets.
      DatagramSocketImpl
      Abstract datagram and multicast socket implementation base class.
      HttpCookie
      An HttpCookie object represents an HTTP cookie, which carries state information between server and user agent.
      HttpURLConnection
      A URLConnection with support for HTTP-specific features.
      IDN
      Provides methods to convert internationalized domain names (IDNs) between a normal Unicode representation and an ASCII Compatible Encoding (ACE) representation.
      Inet4Address
      This class represents an Internet Protocol version 4 (IPv4) address.
      Inet6Address
      This class represents an Internet Protocol version 6 (IPv6) address.
      InetAddress
      This class represents an Internet Protocol (IP) address.
      InetSocketAddress
      This class implements an IP Socket Address (IP address + port number) It can also be a pair (hostname + port number), in which case an attempt will be made to resolve the hostname.
      InterfaceAddress
      This class represents a Network Interface address.
      JarURLConnection
      A URL Connection to a Java ARchive (JAR) file or an entry in a JAR file.
      MulticastSocket
      The multicast datagram socket class is useful for sending and receiving IP multicast packets.
      NetPermission
      This class is for various network permissions.
      NetworkInterface
      This class represents a Network Interface made up of a name, and a list of IP addresses assigned to this interface.
      PasswordAuthentication
      The class PasswordAuthentication is a data holder that is used by Authenticator.
      Proxy
      This class represents a proxy setting, typically a type (http, socks) and a socket address.
      ProxySelector
      Selects the proxy server to use, if any, when connecting to the network resource referenced by a URL.
      ResponseCache
      Represents implementations of URLConnection caches.
      SecureCacheResponse
      Represents a cache response originally retrieved through secure means, such as TLS.
      ServerSocket
      This class implements server sockets.
      Socket
      This class implements client sockets (also called just "sockets").
      SocketAddress
      This class represents a Socket Address with no protocol attachment.
      SocketImpl
      The abstract class SocketImpl is a common superclass of all classes that actually implement sockets.
      SocketPermission
      This class represents access to a network via sockets.
      StandardSocketOptions
      Defines the standard socket options.
      URI
      Represents a Uniform Resource Identifier (URI) reference.
      URL
      Class URL represents a Uniform Resource Locator, a pointer to a "resource" on the World Wide Web.
      URLClassLoader
      This class loader is used to load classes and resources from a search path of URLs referring to both JAR files and directories.
      URLConnection
      The abstract class URLConnection is the superclass of all classes that represent a communications link between the application and a URL.
      URLDecoder
      Utility class for HTML form decoding.
      URLEncoder
      Utility class for HTML form encoding.
      URLPermission
      Represents permission to access a resource or set of resources defined by a given url, and for a given set of user-settable request methods and request headers.
      URLStreamHandler
      The abstract class URLStreamHandler is the common superclass for all stream protocol handlers.
      Enum Summary 
      Enum Description
      Authenticator.RequestorType
      The type of the entity requesting authentication.
      Proxy.Type
      Represents the proxy type.
      StandardProtocolFamily
      Defines the standard families of communication protocols.
      Exception Summary 
      Exception Description
      BindException
      Signals that an error occurred while attempting to bind a socket to a local address and port.
      ConnectException
      Signals that an error occurred while attempting to connect a socket to a remote address and port.
      HttpRetryException
      Thrown to indicate that a HTTP request needs to be retried but cannot be retried automatically, due to streaming mode being enabled.
      MalformedURLException
      Thrown to indicate that a malformed URL has occurred.
      NoRouteToHostException
      Signals that an error occurred while attempting to connect a socket to a remote address and port.
      PortUnreachableException
      Signals that an ICMP Port Unreachable message has been received on a connected datagram.
      ProtocolException
      Thrown to indicate that there is an error in the underlying protocol, such as a TCP error.
      SocketException
      Thrown to indicate that there is an error creating or accessing a Socket.
      SocketTimeoutException
      Signals that a timeout has occurred on a socket read or accept.
      UnknownHostException
      Thrown to indicate that the IP address of a host could not be determined.
      UnknownServiceException
      Thrown to indicate that an unknown service exception has occurred.
      URISyntaxException
      Checked exception thrown to indicate that a string could not be parsed as a URI reference.
    • java.nio.channels

      Interface Summary 
      Interface Description
      AsynchronousByteChannel
      An asynchronous channel that can read and write bytes.
      AsynchronousChannel
      A channel that supports asynchronous I/O operations.
      ByteChannel
      A channel that can read and write bytes.
      Channel
      A nexus for I/O operations.
      CompletionHandler<V,A>
      A handler for consuming the result of an asynchronous I/O operation.
      GatheringByteChannel
      A channel that can write bytes from a sequence of buffers.
      InterruptibleChannel
      A channel that can be asynchronously closed and interrupted.
      MulticastChannel
      A network channel that supports Internet Protocol (IP) multicasting.
      NetworkChannel
      A channel to a network socket.
      ReadableByteChannel
      A channel that can read bytes.
      ScatteringByteChannel
      A channel that can read bytes into a sequence of buffers.
      SeekableByteChannel
      A byte channel that maintains a current position and allows the position to be changed.
      WritableByteChannel
      A channel that can write bytes.
      Class Summary 
      Class Description
      AsynchronousChannelGroup
      A grouping of asynchronous channels for the purpose of resource sharing.
      AsynchronousFileChannel
      An asynchronous channel for reading, writing, and manipulating a file.
      AsynchronousServerSocketChannel
      An asynchronous channel for stream-oriented listening sockets.
      AsynchronousSocketChannel
      An asynchronous channel for stream-oriented connecting sockets.
      Channels
      Utility methods for channels and streams.
      DatagramChannel
      A selectable channel for datagram-oriented sockets.
      FileChannel
      A channel for reading, writing, mapping, and manipulating a file.
      FileChannel.MapMode
      A typesafe enumeration for file-mapping modes.
      FileLock
      A token representing a lock on a region of a file.
      MembershipKey
      A token representing the membership of an Internet Protocol (IP) multicast group.
      Pipe
      A pair of channels that implements a unidirectional pipe.
      Pipe.SinkChannel
      A channel representing the writable end of a Pipe.
      Pipe.SourceChannel
      A channel representing the readable end of a Pipe.
      SelectableChannel
      A channel that can be multiplexed via a Selector.
      SelectionKey
      A token representing the registration of a SelectableChannel with a Selector.
      Selector
      A multiplexor of SelectableChannel objects.
      ServerSocketChannel
      A selectable channel for stream-oriented listening sockets.
      SocketChannel
      A selectable channel for stream-oriented connecting sockets.
      Exception Summary 
      Exception Description
      AcceptPendingException
      Unchecked exception thrown when an attempt is made to initiate an accept operation on a channel and a previous accept operation has not completed.
      AlreadyBoundException
      Unchecked exception thrown when an attempt is made to bind the socket a network oriented channel that is already bound.
      AlreadyConnectedException
      Unchecked exception thrown when an attempt is made to connect a SocketChannel that is already connected.
      AsynchronousCloseException
      Checked exception received by a thread when another thread closes the channel or the part of the channel upon which it is blocked in an I/O operation.
      CancelledKeyException
      Unchecked exception thrown when an attempt is made to use a selection key that is no longer valid.
      ClosedByInterruptException
      Checked exception received by a thread when another thread interrupts it while it is blocked in an I/O operation upon a channel.
      ClosedChannelException
      Checked exception thrown when an attempt is made to invoke or complete an I/O operation upon channel that is closed, or at least closed to that operation.
      ClosedSelectorException
      Unchecked exception thrown when an attempt is made to invoke an I/O operation upon a closed selector.
      ConnectionPendingException
      Unchecked exception thrown when an attempt is made to connect a SocketChannel for which a non-blocking connection operation is already in progress.
      FileLockInterruptionException
      Checked exception received by a thread when another thread interrupts it while it is waiting to acquire a file lock.
      IllegalBlockingModeException
      Unchecked exception thrown when a blocking-mode-specific operation is invoked upon a channel in the incorrect blocking mode.
      IllegalChannelGroupException
      Unchecked exception thrown when an attempt is made to open a channel in a group that was not created by the same provider.
      IllegalSelectorException
      Unchecked exception thrown when an attempt is made to register a channel with a selector that was not created by the provider that created the channel.
      InterruptedByTimeoutException
      Checked exception received by a thread when a timeout elapses before an asynchronous operation completes.
      NoConnectionPendingException
      Unchecked exception thrown when the finishConnect method of a SocketChannel is invoked without first successfully invoking its connect method.
      NonReadableChannelException
      Unchecked exception thrown when an attempt is made to read from a channel that was not originally opened for reading.
      NonWritableChannelException
      Unchecked exception thrown when an attempt is made to write to a channel that was not originally opened for writing.
      NotYetBoundException
      Unchecked exception thrown when an attempt is made to invoke an I/O operation upon a server socket channel that is not yet bound.
      NotYetConnectedException
      Unchecked exception thrown when an attempt is made to invoke an I/O operation upon a socket channel that is not yet connected.
      OverlappingFileLockException
      Unchecked exception thrown when an attempt is made to acquire a lock on a region of a file that overlaps a region already locked by the same Java virtual machine, or when another thread is already waiting to lock an overlapping region of the same file.
      ReadPendingException
      Unchecked exception thrown when an attempt is made to read from an asynchronous socket channel and a previous read has not completed.
      ShutdownChannelGroupException
      Unchecked exception thrown when an attempt is made to construct a channel in a group that is shutdown or the completion handler for an I/O operation cannot be invoked because the channel group has terminated.
      UnresolvedAddressException
      Unchecked exception thrown when an attempt is made to invoke a network operation upon an unresolved socket address.
      UnsupportedAddressTypeException
      Unchecked exception thrown when an attempt is made to bind or connect to a socket address of a type that is not supported.
      WritePendingException
      Unchecked exception thrown when an attempt is made to write to an asynchronous socket channel and a previous write has not completed.
    • java.nio.file

      Interface Summary 
      Interface Description
      CopyOption
      An object that configures how to copy or move a file.
      DirectoryStream<T>
      An object to iterate over the entries in a directory.
      DirectoryStream.Filter<T>
      An interface that is implemented by objects that decide if a directory entry should be accepted or filtered.
      FileVisitor<T>
      A visitor of files.
      OpenOption
      An object that configures how to open or create a file.
      Path
      An object that may be used to locate a file in a file system.
      PathMatcher
      An interface that is implemented by objects that perform match operations on paths.
      SecureDirectoryStream<T>
      A DirectoryStream that defines operations on files that are located relative to an open directory.
      Watchable
      An object that may be registered with a watch service so that it can be watched for changes and events.
      WatchEvent<T>
      An event or a repeated event for an object that is registered with a WatchService.
      WatchEvent.Kind<T>
      An event kind, for the purposes of identification.
      WatchEvent.Modifier
      An event modifier that qualifies how a Watchable is registered with a WatchService.
      WatchKey
      A token representing the registration of a watchable object with a WatchService.
      WatchService
      A watch service that watches registered objects for changes and events.
      Class Summary 
      Class Description
      Files
      This class consists exclusively of static methods that operate on files, directories, or other types of files.
      FileStore
      Storage for files.
      FileSystem
      Provides an interface to a file system and is the factory for objects to access files and other objects in the file system.
      FileSystems
      Factory methods for file systems.
      LinkPermission
      The Permission class for link creation operations.
      Paths
      This class consists exclusively of static methods that return a Path by converting a path string or URI.
      SimpleFileVisitor<T>
      A simple visitor of files with default behavior to visit all files and to re-throw I/O errors.
      StandardWatchEventKinds
      Defines the standard event kinds.
      Enum Summary 
      Enum Description
      AccessMode
      Defines access modes used to test the accessibility of a file.
      FileVisitOption
      Defines the file tree traversal options.
      FileVisitResult
      The result type of a FileVisitor.
      LinkOption
      Defines the options as to how symbolic links are handled.
      StandardCopyOption
      Defines the standard copy options.
      StandardOpenOption
      Defines the standard open options.
      Exception Summary 
      Exception Description
      AccessDeniedException
      Checked exception thrown when a file system operation is denied, typically due to a file permission or other access check.
      AtomicMoveNotSupportedException
      Checked exception thrown when a file cannot be moved as an atomic file system operation.
      ClosedDirectoryStreamException
      Unchecked exception thrown when an attempt is made to invoke an operation on a directory stream that is closed.
      ClosedFileSystemException
      Unchecked exception thrown when an attempt is made to invoke an operation on a file and the file system is closed.
      ClosedWatchServiceException
      Unchecked exception thrown when an attempt is made to invoke an operation on a watch service that is closed.
      DirectoryIteratorException
      Runtime exception thrown if an I/O error is encountered when iterating over the entries in a directory.
      DirectoryNotEmptyException
      Checked exception thrown when a file system operation fails because a directory is not empty.
      FileAlreadyExistsException
      Checked exception thrown when an attempt is made to create a file or directory and a file of that name already exists.
      FileSystemAlreadyExistsException
      Runtime exception thrown when an attempt is made to create a file system that already exists.
      FileSystemException
      Thrown when a file system operation fails on one or two files.
      FileSystemLoopException
      Checked exception thrown when a file system loop, or cycle, is encountered.
      FileSystemNotFoundException
      Runtime exception thrown when a file system cannot be found.
      InvalidPathException
      Unchecked exception thrown when path string cannot be converted into a Path because the path string contains invalid characters, or the path string is invalid for other file system specific reasons.
      NoSuchFileException
      Checked exception thrown when an attempt is made to access a file that does not exist.
      NotDirectoryException
      Checked exception thrown when a file system operation, intended for a directory, fails because the file is not a directory.
      NotLinkException
      Checked exception thrown when a file system operation fails because a file is not a symbolic link.
      ProviderMismatchException
      Unchecked exception thrown when an attempt is made to invoke a method on an object created by one file system provider with a parameter created by a different file system provider.
      ProviderNotFoundException
      Runtime exception thrown when a provider of the required type cannot be found.
      ReadOnlyFileSystemException
      Unchecked exception thrown when an attempt is made to update an object associated with a read-only FileSystem.
    • java.nio.file.attribute

      Interface Summary 
      Interface Description
      AclFileAttributeView
      A file attribute view that supports reading or updating a file's Access Control Lists (ACL) or file owner attributes.
      AttributeView
      An object that provides a read-only or updatable view of non-opaque values associated with an object in a filesystem.
      BasicFileAttributes
      Basic attributes associated with a file in a file system.
      BasicFileAttributeView
      A file attribute view that provides a view of a basic set of file attributes common to many file systems.
      DosFileAttributes
      File attributes associated with a file in a file system that supports legacy "DOS" attributes.
      DosFileAttributeView
      A file attribute view that provides a view of the legacy "DOS" file attributes.
      FileAttribute<T>
      An object that encapsulates the value of a file attribute that can be set atomically when creating a new file or directory by invoking the createFile or createDirectory methods.
      FileAttributeView
      An attribute view that is a read-only or updatable view of non-opaque values associated with a file in a filesystem.
      FileOwnerAttributeView
      A file attribute view that supports reading or updating the owner of a file.
      FileStoreAttributeView
      An attribute view that is a read-only or updatable view of the attributes of a FileStore.
      GroupPrincipal
      A UserPrincipal representing a group identity, used to determine access rights to objects in a file system.
      PosixFileAttributes
      File attributes associated with files on file systems used by operating systems that implement the Portable Operating System Interface (POSIX) family of standards.
      PosixFileAttributeView
      A file attribute view that provides a view of the file attributes commonly associated with files on file systems used by operating systems that implement the Portable Operating System Interface (POSIX) family of standards.
      UserDefinedFileAttributeView
      A file attribute view that provides a view of a file's user-defined attributes, sometimes known as extended attributes.
      UserPrincipal
      A Principal representing an identity used to determine access rights to objects in a file system.
      Class Summary 
      Class Description
      AclEntry
      An entry in an access control list (ACL).
      AclEntry.Builder
      A builder of AclEntry objects.
      FileTime
      Represents the value of a file's time stamp attribute.
      PosixFilePermissions
      This class consists exclusively of static methods that operate on sets of PosixFilePermission objects.
      UserPrincipalLookupService
      An object to lookup user and group principals by name.
      Enum Summary 
      Enum Description
      AclEntryFlag
      Defines the flags for used by the flags component of an ACL entry.
      AclEntryPermission
      Defines the permissions for use with the permissions component of an ACL entry.
      AclEntryType
      A typesafe enumeration of the access control entry types.
      PosixFilePermission
      Defines the bits for use with the permissions attribute.
      Exception Summary 
      Exception Description
      UserPrincipalNotFoundException
      Checked exception thrown when a lookup of UserPrincipal fails because the principal does not exist.
    • java.security

      Interface Summary 
      Interface Description
      AlgorithmConstraints
      This interface specifies constraints for cryptographic algorithms, keys (key sizes), and other algorithm parameters.
      Certificate Deprecated
      A new certificate handling package is created in the Java platform.
      DomainCombiner
      A DomainCombiner provides a means to dynamically update the ProtectionDomains associated with the current AccessControlContext.
      Guard
      This interface represents a guard, which is an object that is used to protect access to another object.
      Key
      The Key interface is the top-level interface for all keys.
      KeyStore.Entry
      A marker interface for KeyStore entry types.
      KeyStore.Entry.Attribute
      An attribute associated with a keystore entry.
      KeyStore.LoadStoreParameter
      A marker interface for KeyStore load and store parameters.
      KeyStore.ProtectionParameter
      A marker interface for keystore protection parameters.
      Policy.Parameters
      This represents a marker interface for Policy parameters.
      Principal
      This interface represents the abstract notion of a principal, which can be used to represent any entity, such as an individual, a corporation, and a login id.
      PrivateKey
      A private key.
      PrivilegedAction<T>
      A computation to be performed with privileges enabled.
      PrivilegedExceptionAction<T>
      A computation to be performed with privileges enabled, that throws one or more checked exceptions.
      PublicKey
      A public key.
      Class Summary 
      Class Description
      AccessControlContext
      An AccessControlContext is used to make system resource access decisions based on the context it encapsulates.
      AccessController
      The AccessController class is used for access control operations and decisions.
      AlgorithmParameterGenerator
      The AlgorithmParameterGenerator class is used to generate a set of parameters to be used with a certain algorithm.
      AlgorithmParameterGeneratorSpi
      This class defines the Service Provider Interface (SPI) for the AlgorithmParameterGenerator class, which is used to generate a set of parameters to be used with a certain algorithm.
      AlgorithmParameters
      This class is used as an opaque representation of cryptographic parameters.
      AlgorithmParametersSpi
      This class defines the Service Provider Interface (SPI) for the AlgorithmParameters class, which is used to manage algorithm parameters.
      AllPermission
      The AllPermission is a permission that implies all other permissions.
      AuthProvider
      This class defines login and logout methods for a provider.
      BasicPermission
      The BasicPermission class extends the Permission class, and can be used as the base class for permissions that want to follow the same naming convention as BasicPermission.
      CodeSigner
      This class encapsulates information about a code signer.
      CodeSource
      This class extends the concept of a codebase to encapsulate not only the location (URL) but also the certificate chains that were used to verify signed code originating from that location.
      DigestInputStream
      A transparent stream that updates the associated message digest using the bits going through the stream.
      DigestOutputStream
      A transparent stream that updates the associated message digest using the bits going through the stream.
      DomainLoadStoreParameter
      Configuration data that specifies the keystores in a keystore domain.
      GuardedObject
      A GuardedObject is an object that is used to protect access to another object.
      Identity Deprecated
      This class is no longer used.
      IdentityScope Deprecated
      This class is no longer used.
      KeyFactory
      Key factories are used to convert keys (opaque cryptographic keys of type Key) into key specifications (transparent representations of the underlying key material), and vice versa.
      KeyFactorySpi
      This class defines the Service Provider Interface (SPI) for the KeyFactory class.
      KeyPair
      This class is a simple holder for a key pair (a public key and a private key).
      KeyPairGenerator
      The KeyPairGenerator class is used to generate pairs of public and private keys.
      KeyPairGeneratorSpi
      This class defines the Service Provider Interface (SPI) for the KeyPairGenerator class, which is used to generate pairs of public and private keys.
      KeyRep
      Standardized representation for serialized Key objects.
      KeyStore
      This class represents a storage facility for cryptographic keys and certificates.
      KeyStore.Builder
      A description of a to-be-instantiated KeyStore object.
      KeyStore.CallbackHandlerProtection
      A ProtectionParameter encapsulating a CallbackHandler.
      KeyStore.PasswordProtection
      A password-based implementation of ProtectionParameter.
      KeyStore.PrivateKeyEntry
      A KeyStore entry that holds a PrivateKey and corresponding certificate chain.
      KeyStore.SecretKeyEntry
      A KeyStore entry that holds a SecretKey.
      KeyStore.TrustedCertificateEntry
      A KeyStore entry that holds a trusted Certificate.
      KeyStoreSpi
      This class defines the Service Provider Interface (SPI) for the KeyStore class.
      MessageDigest
      This MessageDigest class provides applications the functionality of a message digest algorithm, such as SHA-1 or SHA-256.
      MessageDigestSpi
      This class defines the Service Provider Interface (SPI) for the MessageDigest class, which provides the functionality of a message digest algorithm, such as MD5 or SHA.
      Permission
      Abstract class for representing access to a system resource.
      PermissionCollection
      Abstract class representing a collection of Permission objects.
      Permissions
      This class represents a heterogeneous collection of Permissions.
      PKCS12Attribute
      An attribute associated with a PKCS12 keystore entry.
      Policy
      A Policy object is responsible for determining whether code executing in the Java runtime environment has permission to perform a security-sensitive operation.
      PolicySpi
      This class defines the Service Provider Interface (SPI) for the Policy class.
      ProtectionDomain
      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 Summary 
      Enum Description
      CryptoPrimitive
      An enumeration of cryptographic primitives.
      KeyRep.Type
      Key type.
      Exception Summary 
      Exception Description
      AccessControlException
      This exception is thrown by the AccessController to indicate that a requested access (to a critical system resource such as the file system or the network) is denied.
      DigestException
      This is the generic Message Digest exception.
      GeneralSecurityException
      The GeneralSecurityException class is a generic security exception class that provides type safety for all the security-related exception classes that extend from it.
      InvalidAlgorithmParameterException
      This is the exception for invalid or inappropriate algorithm parameters.
      InvalidKeyException
      This is the exception for invalid Keys (invalid encoding, wrong length, uninitialized, etc).
      InvalidParameterException
      This exception, designed for use by the JCA/JCE engine classes, is thrown when an invalid parameter is passed to a method.
      KeyException
      This is the basic key exception.
      KeyManagementException
      This is the general key management exception for all operations dealing with key management.
      KeyStoreException
      This is the generic KeyStore exception.
      NoSuchAlgorithmException
      This exception is thrown when a particular cryptographic algorithm is requested but is not available in the environment.
      NoSuchProviderException
      This exception is thrown when a particular security provider is requested but is not available in the environment.
      PrivilegedActionException
      This exception is thrown by doPrivileged(PrivilegedExceptionAction) and doPrivileged(PrivilegedExceptionAction, AccessControlContext context) to indicate that the action being performed threw a checked exception.
      ProviderException
      A runtime exception for Provider exceptions (such as misconfiguration errors or unrecoverable internal errors), which may be subclassed by Providers to throw specialized, provider-specific runtime errors.
      SignatureException
      This is the generic Signature exception.
      UnrecoverableEntryException
      This exception is thrown if an entry in the keystore cannot be recovered.
      UnrecoverableKeyException
      This exception is thrown if a key in the keystore cannot be recovered.
    • java.security.interfaces

      Interface Summary 
      Interface Description
      DSAKey
      The interface to a DSA public or private key.
      DSAKeyPairGenerator
      An interface to an object capable of generating DSA key pairs.
      DSAParams
      Interface to a DSA-specific set of key parameters, which defines a DSA key family.
      DSAPrivateKey
      The standard interface to a DSA private key.
      DSAPublicKey
      The interface to a DSA public key.
      ECKey
      The interface to an elliptic curve (EC) key.
      ECPrivateKey
      The interface to an elliptic curve (EC) private key.
      ECPublicKey
      The interface to an elliptic curve (EC) public key.
      RSAKey
      The interface to 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.
    • java.security.spec

      Interface Summary 
      Interface Description
      AlgorithmParameterSpec
      A (transparent) specification of cryptographic parameters.
      ECField
      This interface represents an elliptic curve (EC) finite field.
      KeySpec
      A (transparent) specification of the key material that constitutes a cryptographic key.
      Class Summary 
      Class Description
      DSAGenParameterSpec
      This immutable class specifies the set of parameters used for generating DSA parameters as specified in FIPS 186-3 Digital Signature Standard (DSS).
      DSAParameterSpec
      This class specifies the set of parameters used with the DSA algorithm.
      DSAPrivateKeySpec
      This class specifies a DSA private key with its associated parameters.
      DSAPublicKeySpec
      This class specifies a DSA public key with its associated parameters.
      ECFieldF2m
      This immutable class defines an elliptic curve (EC) characteristic 2 finite field.
      ECFieldFp
      This immutable class defines an elliptic curve (EC) prime finite field.
      ECGenParameterSpec
      This immutable class specifies the set of parameters used for generating elliptic curve (EC) domain parameters.
      ECParameterSpec
      This immutable class specifies the set of domain parameters used with elliptic curve cryptography (ECC).
      ECPoint
      This immutable class represents a point on an elliptic curve (EC) in affine coordinates.
      ECPrivateKeySpec
      This immutable class specifies an elliptic curve private key with its associated parameters.
      ECPublicKeySpec
      This immutable class specifies an elliptic curve public key with its associated parameters.
      EllipticCurve
      This immutable class holds the necessary values needed to represent an elliptic curve.
      EncodedKeySpec
      This class represents a public or private key in encoded format.
      MGF1ParameterSpec
      This class specifies the set of parameters used with mask generation function MGF1 in OAEP Padding and 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 Summary 
      Exception Description
      InvalidKeySpecException
      This is the exception for invalid key specifications.
      InvalidParameterSpecException
      This is the exception for invalid parameter specifications.
    • java.text

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

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

      Interface Summary 
      Interface Description
      ChronoLocalDate
      A date without time-of-day or time-zone in an arbitrary chronology, intended for advanced globalization use cases.
      ChronoLocalDateTime<D extends ChronoLocalDate>
      A date-time without a time-zone in an arbitrary chronology, intended for advanced globalization use cases.
      Chronology
      A calendar system, used to organize and identify dates.
      ChronoPeriod
      A date-based amount of time, such as '3 years, 4 months and 5 days' in an arbitrary chronology, intended for advanced globalization use cases.
      ChronoZonedDateTime<D extends ChronoLocalDate>
      A date-time with a time-zone in an arbitrary chronology, intended for advanced globalization use cases.
      Era
      An era of the time-line.
      Class Summary 
      Class Description
      AbstractChronology
      An abstract implementation of a calendar system, used to organize and identify dates.
      HijrahChronology
      The Hijrah calendar is a lunar calendar supporting Islamic calendars.
      HijrahDate
      A date in the Hijrah calendar system.
      IsoChronology
      The ISO calendar system.
      JapaneseChronology
      The Japanese Imperial calendar system.
      JapaneseDate
      A date in the Japanese Imperial calendar system.
      JapaneseEra
      An era in the Japanese Imperial calendar system.
      MinguoChronology
      The Minguo calendar system.
      MinguoDate
      A date in the Minguo calendar system.
      ThaiBuddhistChronology
      The Thai Buddhist calendar system.
      ThaiBuddhistDate
      A date in the Thai Buddhist calendar system.
      Enum Summary 
      Enum Description
      HijrahEra
      An era in the Hijrah calendar system.
      IsoEra
      An era in the ISO calendar system.
      MinguoEra
      An era in the Minguo calendar system.
      ThaiBuddhistEra
      An era in the Thai Buddhist calendar system.
    • java.time.format

      Class Summary 
      Class Description
      DateTimeFormatter
      Formatter for printing and parsing date-time objects.
      DateTimeFormatterBuilder
      Builder to create date-time formatters.
      DecimalStyle
      Localized decimal style used in date and time formatting.
      Enum Summary 
      Enum Description
      FormatStyle
      Enumeration of the style of a localized date, time or date-time formatter.
      ResolverStyle
      Enumeration of different ways to resolve dates and times.
      SignStyle
      Enumeration of ways to handle the positive/negative sign.
      TextStyle
      Enumeration of the style of text formatting and parsing.
      Exception Summary 
      Exception Description
      DateTimeParseException
      An exception thrown when an error occurs during parsing.
    • java.time.temporal

      Interface Summary 
      Interface Description
      Temporal
      Framework-level interface defining read-write access to a temporal object, such as a date, time, offset or some combination of these.
      TemporalAccessor
      Framework-level interface defining read-only access to a temporal object, such as a date, time, offset or some combination of these.
      TemporalAdjuster
      Strategy for adjusting a temporal object.
      TemporalAmount
      Framework-level interface defining an amount of time, such as "6 hours", "8 days" or "2 years and 3 months".
      TemporalField
      A field of date-time, such as month-of-year or hour-of-minute.
      TemporalQuery<R>
      Strategy for querying a temporal object.
      TemporalUnit
      A unit of date-time, such as Days or Hours.
      Class Summary 
      Class Description
      IsoFields
      Fields and units specific to the ISO-8601 calendar system, including quarter-of-year and week-based-year.
      JulianFields
      A set of date fields that provide access to Julian Days.
      TemporalAdjusters
      Common and useful TemporalAdjusters.
      TemporalQueries
      Common implementations of TemporalQuery.
      ValueRange
      The range of valid values for a date-time field.
      WeekFields
      Localized definitions of the day-of-week, week-of-month and week-of-year fields.
      Enum Summary 
      Enum Description
      ChronoField
      A standard set of fields.
      ChronoUnit
      A standard set of date periods units.
      Exception Summary 
      Exception Description
      UnsupportedTemporalTypeException
      UnsupportedTemporalTypeException indicates that a ChronoField or ChronoUnit is not supported for a Temporal class.
    • java.util

      Interface Summary 
      Interface Description
      Collection<E>
      The root interface in the collection hierarchy.
      Comparator<T>
      A comparison function, which imposes a total ordering on some collection of objects.
      Deque<E>
      A linear collection that supports element insertion and removal at both ends.
      Enumeration<E>
      An object that implements the Enumeration interface generates a series of elements, one at a time.
      EventListener
      A tagging interface that all event listener interfaces must extend.
      Formattable
      The Formattable interface must be implemented by any class that needs to perform custom formatting using the 's' conversion specifier of Formatter.
      Iterator<E>
      An iterator over a collection.
      List<E>
      An ordered collection (also known as a sequence).
      ListIterator<E>
      An iterator for lists that allows the programmer to traverse the list in either direction, modify the list during iteration, and obtain the iterator's current position in the list.
      Map<K,V>
      An object that maps keys to values.
      Map.Entry<K,V>
      A map entry (key-value pair).
      NavigableMap<K,V>
      A SortedMap extended with navigation methods returning the closest matches for given search targets.
      NavigableSet<E>
      A SortedSet extended with navigation methods reporting closest matches for given search targets.
      Observer
      A class can implement the Observer interface when it wants to be informed of changes in observable objects.
      PrimitiveIterator<T,T_CONS>
      A base type for primitive specializations of Iterator.
      PrimitiveIterator.OfDouble
      An Iterator specialized for double values.
      PrimitiveIterator.OfInt
      An Iterator specialized for int values.
      PrimitiveIterator.OfLong
      An Iterator specialized for long values.
      Queue<E>
      A collection designed for holding elements prior to processing.
      RandomAccess
      Marker interface used by List implementations to indicate that they support fast (generally constant time) random access.
      Set<E>
      A collection that contains no duplicate elements.
      SortedMap<K,V>
      A Map that further provides a total ordering on its keys.
      SortedSet<E>
      A Set that further provides a total ordering on its elements.
      Spliterator<T>
      An object for traversing and partitioning elements of a source.
      Spliterator.OfDouble
      A Spliterator specialized for double values.
      Spliterator.OfInt
      A Spliterator specialized for int values.
      Spliterator.OfLong
      A Spliterator specialized for long values.
      Spliterator.OfPrimitive<T,T_CONS,T_SPLITR extends Spliterator.OfPrimitive<T,T_CONS,T_SPLITR>>
      A Spliterator specialized for primitive values.
      Class Summary 
      Class Description
      AbstractCollection<E>
      This class provides a skeletal implementation of the Collection interface, to minimize the effort required to implement this interface.
      AbstractList<E>
      This class provides a skeletal implementation of the List interface to minimize the effort required to implement this interface backed by a "random access" data store (such as an array).
      AbstractMap<K,V>
      This class provides a skeletal implementation of the Map interface, to minimize the effort required to implement this interface.
      AbstractMap.SimpleEntry<K,V>
      An Entry maintaining a key and a value.
      AbstractMap.SimpleImmutableEntry<K,V>
      An Entry maintaining an immutable key and value.
      AbstractQueue<E>
      This class provides skeletal implementations of some Queue operations.
      AbstractSequentialList<E>
      This class provides a skeletal implementation of the List interface to minimize the effort required to implement this interface backed by a "sequential access" data store (such as a linked list).
      AbstractSet<E>
      This class provides a skeletal implementation of the Set interface to minimize the effort required to implement this interface.
      ArrayDeque<E>
      Resizable-array implementation of the Deque interface.
      ArrayList<E>
      Resizable-array implementation of the List interface.
      Arrays
      This class contains various methods for manipulating arrays (such as sorting and searching).
      Base64
      This class consists exclusively of static methods for obtaining encoders and decoders for the Base64 encoding scheme.
      Base64.Decoder
      This class implements a decoder for decoding byte data using the Base64 encoding scheme as specified in RFC 4648 and RFC 2045.
      Base64.Encoder
      This class implements an encoder for encoding byte data using the Base64 encoding scheme as specified in RFC 4648 and RFC 2045.
      BitSet
      This class implements a vector of bits that grows as needed.
      Calendar
      The Calendar class is an abstract class that provides methods for converting between a specific instant in time and a set of calendar fields such as YEAR, MONTH, DAY_OF_MONTH, HOUR, and so on, and for manipulating the calendar fields, such as getting the date of the next week.
      Calendar.Builder
      Calendar.Builder is used for creating a Calendar from various date-time parameters.
      Collections
      This class consists exclusively of static methods that operate on or return collections.
      Currency
      Represents a currency.
      Date
      The class Date represents a specific instant in time, with millisecond precision.
      Dictionary<K,V>
      The Dictionary class is the abstract parent of any class, such as Hashtable, which maps keys to values.
      DoubleSummaryStatistics
      A state object for collecting statistics such as count, min, max, sum, and average.
      EnumMap<K extends Enum<K>,V>
      A specialized Map implementation for use with enum type keys.
      EnumSet<E extends Enum<E>>
      A specialized Set implementation for use with enum types.
      EventListenerProxy<T extends EventListener>
      An abstract wrapper class for an EventListener class which associates a set of additional parameters with the listener.
      EventObject
      The root class from which all event state objects shall be derived.
      FormattableFlags
      FomattableFlags are passed to the Formattable.formatTo() method and modify the output format for Formattables.
      Formatter
      An interpreter for printf-style format strings.
      GregorianCalendar
      GregorianCalendar is a concrete subclass of Calendar and provides the standard calendar system used by most of the world.
      HashMap<K,V>
      Hash table based implementation of the Map interface.
      HashSet<E>
      This class implements the Set interface, backed by a hash table (actually a HashMap instance).
      Hashtable<K,V>
      This class implements a hash table, which maps keys to values.
      IdentityHashMap<K,V>
      This class implements the Map interface with a hash table, using reference-equality in place of object-equality when comparing keys (and values).
      IntSummaryStatistics
      A state object for collecting statistics such as count, min, max, sum, and average.
      LinkedHashMap<K,V>
      Hash table and linked list implementation of the Map interface, with predictable iteration order.
      LinkedHashSet<E>
      Hash table and linked list implementation of the Set interface, with predictable iteration order.
      LinkedList<E>
      Doubly-linked list implementation of the List and Deque interfaces.
      ListResourceBundle
      ListResourceBundle is an abstract subclass of ResourceBundle that manages resources for a locale in a convenient and easy to use list.
      Locale
      A Locale object represents a specific geographical, political, or cultural region.
      Locale.Builder
      Builder is used to build instances of Locale from values configured by the setters.
      Locale.LanguageRange
      This class expresses a Language Range defined in RFC 4647 Matching of Language Tags.
      LongSummaryStatistics
      A state object for collecting statistics such as count, min, max, sum, and average.
      Objects
      This class consists of static utility methods for operating on objects.
      Observable
      This class represents an observable object, or "data" in the model-view paradigm.
      Optional<T>
      A container object which may or may not contain a non-null value.
      OptionalDouble
      A container object which may or may not contain a double value.
      OptionalInt
      A container object which may or may not contain a int value.
      OptionalLong
      A container object which may or may not contain a long value.
      PriorityQueue<E>
      An unbounded priority queue based on a priority heap.
      Properties
      The Properties class represents a persistent set of properties.
      PropertyPermission
      This class is for property permissions.
      PropertyResourceBundle
      PropertyResourceBundle is a concrete subclass of ResourceBundle that manages resources for a locale using a set of static strings from a property file.
      Random
      An instance of this class is used to generate a stream of pseudorandom numbers.
      ResourceBundle
      Resource bundles contain locale-specific objects.
      ResourceBundle.Control
      ResourceBundle.Control defines a set of callback methods that are invoked by the ResourceBundle.getBundle factory methods during the bundle loading process.
      Scanner
      A simple text scanner which can parse primitive types and strings using regular expressions.
      ServiceLoader<S>
      A simple service-provider loading facility.
      SimpleTimeZone
      SimpleTimeZone is a concrete subclass of TimeZone that represents a time zone for use with a Gregorian calendar.
      Spliterators
      Static classes and methods for operating on or creating instances of Spliterator and its primitive specializations Spliterator.OfInt, Spliterator.OfLong, and Spliterator.OfDouble.
      Spliterators.AbstractDoubleSpliterator
      An abstract Spliterator.OfDouble that implements trySplit to permit limited parallelism.
      Spliterators.AbstractIntSpliterator
      An abstract Spliterator.OfInt that implements trySplit to permit limited parallelism.
      Spliterators.AbstractLongSpliterator
      An abstract Spliterator.OfLong that implements trySplit to permit limited parallelism.
      Spliterators.AbstractSpliterator<T>
      An abstract Spliterator that implements trySplit to permit limited parallelism.
      SplittableRandom
      A generator of uniform pseudorandom values applicable for use in (among other contexts) isolated parallel computations that may generate subtasks.
      Stack<E>
      The Stack class represents a last-in-first-out (LIFO) stack of objects.
      StringJoiner
      StringJoiner is used to construct a sequence of characters separated by a delimiter and optionally starting with a supplied prefix and ending with a supplied suffix.
      StringTokenizer
      The string tokenizer class allows an application to break a string into tokens.
      Timer
      A facility for threads to schedule tasks for future execution in a background thread.
      TimerTask
      A task that can be scheduled for one-time or repeated execution by a Timer.
      TimeZone
      TimeZone represents a time zone offset, and also figures out daylight savings.
      TreeMap<K,V>
      A Red-Black tree based NavigableMap implementation.
      TreeSet<E>
      A NavigableSet implementation based on a TreeMap.
      UUID
      A class that represents an immutable universally unique identifier (UUID).
      Vector<E>
      The Vector class implements a growable array of objects.
      WeakHashMap<K,V>
      Hash table based implementation of the Map interface, with weak keys.
      Enum Summary 
      Enum Description
      Formatter.BigDecimalLayoutForm
      Enum for BigDecimal formatting.
      Locale.Category
      Enum for locale categories.
      Locale.FilteringMode
      This enum provides constants to select a filtering mode for locale matching.
      Exception Summary 
      Exception Description
      ConcurrentModificationException
      This exception may be thrown by methods that have detected concurrent modification of an object when such modification is not permissible.
      DuplicateFormatFlagsException
      Unchecked exception thrown when duplicate flags are provided in the format specifier.
      EmptyStackException
      Thrown by methods in the Stack class to indicate that the stack is empty.
      FormatFlagsConversionMismatchException
      Unchecked exception thrown when a conversion and flag are incompatible.
      FormatterClosedException
      Unchecked exception thrown when the formatter has been closed.
      IllegalFormatCodePointException
      Unchecked exception thrown when a character with an invalid Unicode code point as defined by Character.isValidCodePoint(int) is passed to the Formatter.
      IllegalFormatConversionException
      Unchecked exception thrown when the argument corresponding to the format specifier is of an incompatible type.
      IllegalFormatException
      Unchecked exception thrown when a format string contains an illegal syntax or a format specifier that is incompatible with the given arguments.
      IllegalFormatFlagsException
      Unchecked exception thrown when an illegal combination flags is given.
      IllegalFormatPrecisionException
      Unchecked exception thrown when the precision is a negative value other than -1, the conversion does not support a precision, or the value is otherwise unsupported.
      IllegalFormatWidthException
      Unchecked exception thrown when the format width is a negative value other than -1 or is otherwise unsupported.
      IllformedLocaleException
      Thrown by methods in Locale and Locale.Builder to indicate that an argument is not a well-formed BCP 47 tag.
      InputMismatchException
      Thrown by a Scanner to indicate that the token retrieved does not match the pattern for the expected type, or that the token is out of range for the expected type.
      InvalidPropertiesFormatException
      Thrown to indicate that an operation could not complete because the input did not conform to the appropriate XML document type for a collection of properties, as per the Properties specification.
      MissingFormatArgumentException
      Unchecked exception thrown when there is a format specifier which does not have a corresponding argument or if an argument index refers to an argument that does not exist.
      MissingFormatWidthException
      Unchecked exception thrown when the format width is required.
      MissingResourceException
      Signals that a resource is missing.
      NoSuchElementException
      Thrown by various accessor methods to indicate that the element being requested does not exist.
      TooManyListenersException
      The TooManyListenersException Exception is used as part of the Java Event model to annotate and implement a unicast special case of a multicast Event Source.
      UnknownFormatConversionException
      Unchecked exception thrown when an unknown conversion is given.
      UnknownFormatFlagsException
      Unchecked exception thrown when an unknown flag is given.
      Error Summary 
      Error Description
      ServiceConfigurationError
      Error thrown when something goes wrong while loading a service provider.
    • java.util.concurrent.atomic

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

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

      Interface Summary 
      Interface Description
      Pack200.Packer
      The packer engine applies various transformations to the input JAR file, making the pack stream highly compressible by a compressor such as gzip or zip.
      Pack200.Unpacker
      The unpacker engine converts the packed stream to a JAR file.
      Class Summary 
      Class Description
      Attributes
      The Attributes class maps Manifest attribute names to associated string values.
      Attributes.Name
      The Attributes.Name class represents an attribute name stored in this Map.
      JarEntry
      This class is used to represent a JAR file entry.
      JarFile
      The JarFile class is used to read the contents of a jar file from any file that can be opened with java.io.RandomAccessFile.
      JarInputStream
      The JarInputStream class is used to read the contents of a JAR file from any input stream.
      JarOutputStream
      The JarOutputStream class is used to write the contents of a JAR file to any output stream.
      Manifest
      The Manifest class is used to maintain Manifest entry names and their associated Attributes.
      Pack200
      Transforms a JAR file to or from a packed stream in Pack200 format.
      Exception Summary 
      Exception Description
      JarException
      Signals that an error of some sort has occurred while reading from or writing to a JAR file.
    • java.util.logging

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

      Interface Summary 
      Interface Description
      MatchResult
      The result of a match operation.
      Class Summary 
      Class Description
      Matcher
      An engine that performs match operations on a character sequence by interpreting a Pattern.
      Pattern
      A compiled representation of a regular expression.
      Exception Summary 
      Exception Description
      PatternSyntaxException
      Unchecked exception thrown to indicate a syntax error in a regular-expression pattern.
    • java.util.stream

      Interface Summary 
      Interface Description
      BaseStream<T,S extends BaseStream<T,S>>
      Base interface for streams, which are sequences of elements supporting sequential and parallel aggregate operations.
      Collector<T,A,R>
      A mutable reduction operation that accumulates input elements into a mutable result container, optionally transforming the accumulated result into a final representation after all input elements have been processed.
      DoubleStream
      A sequence of primitive double-valued elements supporting sequential and parallel aggregate operations.
      DoubleStream.Builder
      A mutable builder for a DoubleStream.
      IntStream
      A sequence of primitive int-valued elements supporting sequential and parallel aggregate operations.
      IntStream.Builder
      A mutable builder for an IntStream.
      LongStream
      A sequence of primitive long-valued elements supporting sequential and parallel aggregate operations.
      LongStream.Builder
      A mutable builder for a LongStream.
      Stream<T>
      A sequence of elements supporting sequential and parallel aggregate operations.
      Stream.Builder<T>
      A mutable builder for a Stream.
      Class Summary 
      Class Description
      Collectors
      Implementations of Collector that implement various useful reduction operations, such as accumulating elements into collections, summarizing elements according to various criteria, etc.
      StreamSupport
      Low-level utility methods for creating and manipulating streams.
      Enum Summary 
      Enum Description
      Collector.Characteristics
      Characteristics indicating properties of a Collector, which can be used to optimize reduction implementations.
    • java.util.zip

      Interface Summary 
      Interface Description
      Checksum
      An interface representing a data checksum.
      Class Summary 
      Class Description
      Adler32
      A class that can be used to compute the Adler-32 checksum of a data stream.
      CheckedInputStream
      An input stream that also maintains a checksum of the data being read.
      CheckedOutputStream
      An output stream that also maintains a checksum of the data being written.
      CRC32
      A class that can be used to compute the CRC-32 of a data stream.
      Deflater
      This class provides support for general purpose compression using the popular ZLIB compression library.
      DeflaterInputStream
      Implements an input stream filter for compressing data in the "deflate" compression format.
      DeflaterOutputStream
      This class implements an output stream filter for compressing data in the "deflate" compression format.
      GZIPInputStream
      This class implements a stream filter for reading compressed data in the GZIP file format.
      GZIPOutputStream
      This class implements a stream filter for writing compressed data in the GZIP file format.
      Inflater
      This class provides support for general purpose decompression using the popular ZLIB compression library.
      InflaterInputStream
      This class implements a stream filter for uncompressing data in the "deflate" compression format.
      InflaterOutputStream
      Implements an output stream filter for uncompressing data stored in the "deflate" compression format.
      ZipEntry
      This class is used to represent a ZIP file entry.
      ZipFile
      This class is used to read entries from a zip file.
      ZipInputStream
      This class implements an input stream filter for reading files in the ZIP file format.
      ZipOutputStream
      This class implements an output stream filter for writing files in the ZIP file format.
      Exception Summary 
      Exception Description
      DataFormatException
      Signals that a data format error has occurred.
      ZipException
      Signals that a Zip exception of some sort has occurred.
      Error Summary 
      Error Description
      ZipError
      Signals that an unrecoverable error has occurred.
    • javax.net.ssl

      Interface Summary 
      Interface Description
      HandshakeCompletedListener
      This interface is implemented by any class which wants to receive notifications about the completion of an SSL protocol handshake on a given SSL connection.
      HostnameVerifier
      This class is the base interface for hostname verification.
      KeyManager
      This is the base interface for JSSE key managers.
      ManagerFactoryParameters
      This class is the base interface for providing algorithm-specific information to a KeyManagerFactory or TrustManagerFactory.
      SSLSession
      In SSL, sessions are used to describe an ongoing relationship between two entities.
      SSLSessionBindingListener
      This interface is implemented by objects which want to know when they are being bound or unbound from a SSLSession.
      SSLSessionContext
      A SSLSessionContext represents a set of SSLSessions associated with a single entity.
      TrustManager
      This is the base interface for JSSE trust managers.
      X509KeyManager
      Instances of this interface manage which X509 certificate-based key pairs are used to authenticate the local side of a secure socket.
      X509TrustManager
      Instance of this interface manage which X509 certificates may be used to authenticate the remote side of a secure socket.
      Class Summary 
      Class Description
      CertPathTrustManagerParameters
      A wrapper for CertPathParameters.
      ExtendedSSLSession
      Extends the SSLSession interface to support additional session attributes.
      HandshakeCompletedEvent
      This event indicates that an SSL handshake completed on a given SSL connection.
      HttpsURLConnection
      HttpsURLConnection extends HttpURLConnection with support for https-specific features.
      KeyManagerFactory
      This class acts as a factory for key managers based on a source of key material.
      KeyManagerFactorySpi
      This class defines the Service Provider Interface (SPI) for the KeyManagerFactory class.
      KeyStoreBuilderParameters
      A parameters object for X509KeyManagers that encapsulates a List of KeyStore.Builders.
      SNIHostName
      Instances of this class represent a server name of type host_name in a Server Name Indication (SNI) extension.
      SNIMatcher
      Instances of this class represent a matcher that performs match operations on an SNIServerName instance.
      SNIServerName
      Instances of this class represent a server name in a Server Name Indication (SNI) extension.
      SSLContext
      Instances of this class represent a secure socket protocol implementation which acts as a factory for secure socket factories or SSLEngines.
      SSLContextSpi
      This class defines the Service Provider Interface (SPI) for the SSLContext class.
      SSLEngine
      A class which enables secure communications using protocols such as the Secure Sockets Layer (SSL) or IETF RFC 2246 "Transport Layer Security" (TLS) protocols, but is transport independent.
      SSLEngineResult
      An encapsulation of the result state produced by SSLEngine I/O calls.
      SSLParameters
      Encapsulates parameters for an SSL/TLS connection.
      SSLPermission
      This class is for various network permissions.
      SSLServerSocket
      This class extends ServerSockets and provides secure server sockets using protocols such as the Secure Sockets Layer (SSL) or Transport Layer Security (TLS) protocols.
      SSLServerSocketFactory
      SSLServerSocketFactorys create SSLServerSockets.
      SSLSessionBindingEvent
      This event is propagated to a SSLSessionBindingListener.
      SSLSocket
      This class extends Sockets and provides secure socket using protocols such as the "Secure Sockets Layer" (SSL) or IETF "Transport Layer Security" (TLS) protocols.
      SSLSocketFactory
      SSLSocketFactorys create SSLSockets.
      StandardConstants
      Standard constants definitions
      TrustManagerFactory
      This class acts as a factory for trust managers based on a source of trust material.
      TrustManagerFactorySpi
      This class defines the Service Provider Interface (SPI) for the TrustManagerFactory class.
      X509ExtendedKeyManager
      Abstract class that provides for extension of the X509KeyManager interface.
      X509ExtendedTrustManager
      Extensions to the X509TrustManager interface to support SSL/TLS connection sensitive trust management.
      Enum Summary 
      Enum Description
      SSLEngineResult.HandshakeStatus
      An SSLEngineResult enum describing the current handshaking state of this SSLEngine.
      SSLEngineResult.Status
      An SSLEngineResult enum describing the overall result of the SSLEngine operation.
      Exception Summary 
      Exception Description
      SSLException
      Indicates some kind of error detected by an SSL subsystem.
      SSLHandshakeException
      Indicates that the client and server could not negotiate the desired level of security.
      SSLKeyException
      Reports a bad SSL key.
      SSLPeerUnverifiedException
      Indicates that the peer's identity has not been verified.
      SSLProtocolException
      Reports an error in the operation of the SSL protocol.
    • javax.script

      Interface Summary 
      Interface Description
      Bindings
      A mapping of key/value pairs, all of whose keys are Strings.
      Compilable
      The optional interface implemented by ScriptEngines whose methods compile scripts to a form that can be executed repeatedly without recompilation.
      Invocable
      The optional interface implemented by ScriptEngines whose methods allow the invocation of procedures in scripts that have previously been executed.
      ScriptContext
      The interface whose implementing classes are used to connect Script Engines with objects, such as scoped Bindings, in hosting applications.
      ScriptEngine
      ScriptEngine is the fundamental interface whose methods must be fully functional in every implementation of this specification.
      ScriptEngineFactory
      ScriptEngineFactory is used to describe and instantiate ScriptEngines.
      Class Summary 
      Class Description
      AbstractScriptEngine
      Provides a standard implementation for several of the variants of the eval method.
      CompiledScript
      Extended by classes that store results of compilations.
      ScriptEngineManager
      The ScriptEngineManager implements a discovery and instantiation mechanism for ScriptEngine classes and also maintains a collection of key/value pairs storing state shared by all engines created by the Manager.
      SimpleBindings
      A simple implementation of Bindings backed by a HashMap or some other specified Map.
      SimpleScriptContext
      Simple implementation of ScriptContext.
      Exception Summary 
      Exception Description
      ScriptException
      The generic Exception class for the Scripting APIs.
    • javax.security.auth

      Interface Summary 
      Interface Description
      Destroyable
      Objects such as credentials may optionally implement this interface to provide the capability to destroy its contents.
      Refreshable
      Objects such as credentials may optionally implement this interface to provide the capability to refresh itself.
      Class Summary 
      Class Description
      AuthPermission
      This class is for authentication permissions.
      Policy Deprecated
      as of JDK version 1.4 -- Replaced by java.security.Policy.
      PrivateCredentialPermission
      This class is used to protect access to private Credentials belonging to a particular Subject.
      Subject
      A Subject represents a grouping of related information for a single entity, such as a person.
      SubjectDomainCombiner
      A SubjectDomainCombiner updates ProtectionDomains with Principals from the Subject associated with this SubjectDomainCombiner.
      Exception Summary 
      Exception Description
      DestroyFailedException
      Signals that a destroy operation failed.
      RefreshFailedException
      Signals that a refresh operation failed.
    • javax.security.auth.callback

      Interface Summary 
      Interface Description
      Callback
      Implementations of this interface are passed to a CallbackHandler, allowing underlying security services the ability to interact with a calling application to retrieve specific authentication data such as usernames and passwords, or to display certain information, such as error and warning messages.
      CallbackHandler
      An application implements a CallbackHandler and passes it to underlying security services so that they may interact with the application to retrieve specific authentication data, such as usernames and passwords, or to display certain information, such as error and warning messages.
      Class Summary 
      Class Description
      ChoiceCallback
      Underlying security services instantiate and pass a ChoiceCallback to the handle method of a CallbackHandler to display a list of choices and to retrieve the selected choice(s).
      ConfirmationCallback
      Underlying security services instantiate and pass a ConfirmationCallback to the handle method of a CallbackHandler to ask for YES/NO, OK/CANCEL, YES/NO/CANCEL or other similar confirmations.
      LanguageCallback
      Underlying security services instantiate and pass a LanguageCallback to the handle method of a CallbackHandler to retrieve the Locale used for localizing text.
      NameCallback
      Underlying security services instantiate and pass a NameCallback to the handle method of a CallbackHandler to retrieve name information.
      PasswordCallback
      Underlying security services instantiate and pass a PasswordCallback to the handle method of a CallbackHandler to retrieve password information.
      TextInputCallback
      Underlying security services instantiate and pass a TextInputCallback to the handle method of a CallbackHandler to retrieve generic text information.
      TextOutputCallback
      Underlying security services instantiate and pass a TextOutputCallback to the handle method of a CallbackHandler to display information messages, warning messages and error messages.
      Exception Summary 
      Exception Description
      UnsupportedCallbackException
      Signals that a CallbackHandler does not recognize a particular Callback.


Content

Android Reference

Java basics

Java Enterprise Edition (EE)

Java Standard Edition (SE)

SQL

HTML

PHP

CSS

Java Script

MYSQL

JQUERY

VBS

REGEX

C

C++

C#

Design patterns

RFC (standard status)

RFC (proposed standard status)

RFC (draft standard status)

RFC (informational status)

RFC (experimental status)

RFC (best current practice status)

RFC (historic status)

RFC (unknown status)

IT dictionary

License.
All information of this service is derived from the free sources and is provided solely in the form of quotations. This service provides information and interfaces solely for the familiarization (not ownership) and under the "as is" condition.
Copyright 2016 © ELTASK.COM. All rights reserved.
Site is optimized for mobile devices.
Downloads: 326 / 158852328. Delta: 0.08771 с