IT. Expert System.

Java Standard Edition (SE)

compact3


Profile compact3

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

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

      Interface Summary 
      Interface Description
      ActivationInstantiator
      An ActivationInstantiator is responsible for creating instances of "activatable" objects.
      ActivationMonitor
      An ActivationMonitor is specific to an ActivationGroup and is obtained when a group is reported active via a call to ActivationSystem.activeGroup (this is done internally).
      ActivationSystem
      The ActivationSystem provides a means for registering groups and "activatable" objects to be activated within those groups.
      Activator
      The Activator facilitates remote object activation.
      Class Summary 
      Class Description
      Activatable
      The Activatable class provides support for remote objects that require persistent access over time and that can be activated by the system.
      ActivationDesc
      An activation descriptor contains the information necessary to activate an object: the object's group identifier, the object's fully-qualified class name, the object's code location (the location of the class), a codebase URL path, the object's restart "mode", and, a "marshalled" object that can contain object specific initialization data.
      ActivationGroup
      An ActivationGroup is responsible for creating new instances of "activatable" objects in its group, informing its ActivationMonitor when either: its object's become active or inactive, or the group as a whole becomes inactive.
      ActivationGroup_Stub
      ActivationGroup_Stub is a stub class for the subclasses of java.rmi.activation.ActivationGroup that are exported as a java.rmi.server.UnicastRemoteObject.
      ActivationGroupDesc
      An activation group descriptor contains the information necessary to create/recreate an activation group in which to activate objects.
      ActivationGroupDesc.CommandEnvironment
      Startup options for ActivationGroup implementations.
      ActivationGroupID
      The identifier for a registered activation group serves several purposes: identifies the group uniquely within the activation system, and contains a reference to the group's activation system so that the group can contact its activation system when necessary.
      ActivationID
      Activation makes use of special identifiers to denote remote objects that can be activated over time.
      Exception Summary 
      Exception Description
      ActivateFailedException
      This exception is thrown by the RMI runtime when activation fails during a remote call to an activatable object.
      ActivationException
      General exception used by the activation interfaces.
      UnknownGroupException
      An UnknownGroupException is thrown by methods of classes and interfaces in the java.rmi.activation package when the ActivationGroupID parameter to the method is determined to be invalid, i.e., not known by the ActivationSystem.
      UnknownObjectException
      An UnknownObjectException is thrown by methods of classes and interfaces in the java.rmi.activation package when the ActivationID parameter to the method is determined to be invalid.
    • java.rmi.dgc

      Interface Summary 
      Interface Description
      DGC
      The DGC abstraction is used for the server side of the distributed garbage collection algorithm.
      Class Summary 
      Class Description
      Lease
      A lease contains a unique VM identifier and a lease duration.
      VMID
      A VMID is a identifier that is unique across all Java virtual machines.
    • java.rmi.registry

      Interface Summary 
      Interface Description
      Registry
      Registry is a remote interface to a simple remote object registry that provides methods for storing and retrieving remote object references bound with arbitrary string names.
      RegistryHandler Deprecated
      no replacement
      Class Summary 
      Class Description
      LocateRegistry
      LocateRegistry is used to obtain a reference to a bootstrap remote object registry on a particular host (including the local host), or to create a remote object registry that accepts calls on a specific port.
    • java.rmi.server

      Interface Summary 
      Interface Description
      LoaderHandler Deprecated
      no replacement
      RemoteCall Deprecated
      no replacement.
      RemoteRef
      RemoteRef represents the handle for a remote object.
      RMIClientSocketFactory
      An RMIClientSocketFactory instance is used by the RMI runtime in order to obtain client sockets for RMI calls.
      RMIFailureHandler
      An RMIFailureHandler can be registered via the RMISocketFactory.setFailureHandler call.
      RMIServerSocketFactory
      An RMIServerSocketFactory instance is used by the RMI runtime in order to obtain server sockets for RMI calls.
      ServerRef Deprecated
      No replacement.
      Skeleton Deprecated
      no replacement.
      Unreferenced
      A remote object implementation should implement the Unreferenced interface to receive notification when there are no more clients that reference that remote object.
      Class Summary 
      Class Description
      LogStream Deprecated
      no replacement
      ObjID
      An ObjID is used to identify a remote object exported to an RMI runtime.
      Operation Deprecated
      no replacement
      RemoteObject
      The RemoteObject class implements the java.lang.Object behavior for remote objects.
      RemoteObjectInvocationHandler
      An implementation of the InvocationHandler interface for use with Java Remote Method Invocation (Java RMI).
      RemoteServer
      The RemoteServer class is the common superclass to server implementations and provides the framework to support a wide range of remote reference semantics.
      RemoteStub Deprecated
      Statically generated stubs are deprecated, since stubs are generated dynamically.
      RMIClassLoader
      RMIClassLoader comprises static methods to support dynamic class loading with RMI.
      RMIClassLoaderSpi
      RMIClassLoaderSpi is the service provider interface for RMIClassLoader.
      RMISocketFactory
      An RMISocketFactory instance is used by the RMI runtime in order to obtain client and server sockets for RMI calls.
      UID
      A UID represents an identifier that is unique over time with respect to the host it is generated on, or one of 216 "well-known" identifiers.
      UnicastRemoteObject
      Used for exporting a remote object with JRMP and obtaining a stub that communicates to the remote object.
      Exception Summary 
      Exception Description
      ExportException
      An ExportException is a RemoteException thrown if an attempt to export a remote object fails.
      ServerCloneException
      A ServerCloneException is thrown if a remote exception occurs during the cloning of a UnicastRemoteObject.
      ServerNotActiveException
      An ServerNotActiveException is an Exception thrown during a call to RemoteServer.getClientHost if the getClientHost method is called outside of servicing a remote method call.
      SkeletonMismatchException Deprecated
      no replacement.
      SkeletonNotFoundException Deprecated
      no replacement.
      SocketSecurityException Deprecated
      This class is obsolete.
    • java.security

      Interface Summary 
      Interface Description
      AlgorithmConstraints
      This interface specifies constraints for cryptographic algorithms, keys (key sizes), and other algorithm parameters.
      Certificate Deprecated
      A new certificate handling package is created in the Java platform.
      DomainCombiner
      A DomainCombiner provides a means to dynamically update the ProtectionDomains associated with the current AccessControlContext.
      Guard
      This interface represents a guard, which is an object that is used to protect access to another object.
      Key
      The Key interface is the top-level interface for all keys.
      KeyStore.Entry
      A marker interface for KeyStore entry types.
      KeyStore.Entry.Attribute
      An attribute associated with a keystore entry.
      KeyStore.LoadStoreParameter
      A marker interface for KeyStore load and store parameters.
      KeyStore.ProtectionParameter
      A marker interface for keystore protection parameters.
      Policy.Parameters
      This represents a marker interface for Policy parameters.
      Principal
      This interface represents the abstract notion of a principal, which can be used to represent any entity, such as an individual, a corporation, and a login id.
      PrivateKey
      A private key.
      PrivilegedAction<T>
      A computation to be performed with privileges enabled.
      PrivilegedExceptionAction<T>
      A computation to be performed with privileges enabled, that throws one or more checked exceptions.
      PublicKey
      A public key.
      Class Summary 
      Class Description
      AccessControlContext
      An AccessControlContext is used to make system resource access decisions based on the context it encapsulates.
      AccessController
      The AccessController class is used for access control operations and decisions.
      AlgorithmParameterGenerator
      The AlgorithmParameterGenerator class is used to generate a set of parameters to be used with a certain algorithm.
      AlgorithmParameterGeneratorSpi
      This class defines the Service Provider Interface (SPI) for the AlgorithmParameterGenerator class, which is used to generate a set of parameters to be used with a certain algorithm.
      AlgorithmParameters
      This class is used as an opaque representation of cryptographic parameters.
      AlgorithmParametersSpi
      This class defines the Service Provider Interface (SPI) for the AlgorithmParameters class, which is used to manage algorithm parameters.
      AllPermission
      The AllPermission is a permission that implies all other permissions.
      AuthProvider
      This class defines login and logout methods for a provider.
      BasicPermission
      The BasicPermission class extends the Permission class, and can be used as the base class for permissions that want to follow the same naming convention as BasicPermission.
      CodeSigner
      This class encapsulates information about a code signer.
      CodeSource
      This class extends the concept of a codebase to encapsulate not only the location (URL) but also the certificate chains that were used to verify signed code originating from that location.
      DigestInputStream
      A transparent stream that updates the associated message digest using the bits going through the stream.
      DigestOutputStream
      A transparent stream that updates the associated message digest using the bits going through the stream.
      DomainLoadStoreParameter
      Configuration data that specifies the keystores in a keystore domain.
      GuardedObject
      A GuardedObject is an object that is used to protect access to another object.
      Identity Deprecated
      This class is no longer used.
      IdentityScope Deprecated
      This class is no longer used.
      KeyFactory
      Key factories are used to convert keys (opaque cryptographic keys of type Key) into key specifications (transparent representations of the underlying key material), and vice versa.
      KeyFactorySpi
      This class defines the Service Provider Interface (SPI) for the KeyFactory class.
      KeyPair
      This class is a simple holder for a key pair (a public key and a private key).
      KeyPairGenerator
      The KeyPairGenerator class is used to generate pairs of public and private keys.
      KeyPairGeneratorSpi
      This class defines the Service Provider Interface (SPI) for the KeyPairGenerator class, which is used to generate pairs of public and private keys.
      KeyRep
      Standardized representation for serialized Key objects.
      KeyStore
      This class represents a storage facility for cryptographic keys and certificates.
      KeyStore.Builder
      A description of a to-be-instantiated KeyStore object.
      KeyStore.CallbackHandlerProtection
      A ProtectionParameter encapsulating a CallbackHandler.
      KeyStore.PasswordProtection
      A password-based implementation of ProtectionParameter.
      KeyStore.PrivateKeyEntry
      A KeyStore entry that holds a PrivateKey and corresponding certificate chain.
      KeyStore.SecretKeyEntry
      A KeyStore entry that holds a SecretKey.
      KeyStore.TrustedCertificateEntry
      A KeyStore entry that holds a trusted Certificate.
      KeyStoreSpi
      This class defines the Service Provider Interface (SPI) for the KeyStore class.
      MessageDigest
      This MessageDigest class provides applications the functionality of a message digest algorithm, such as SHA-1 or SHA-256.
      MessageDigestSpi
      This class defines the Service Provider Interface (SPI) for the MessageDigest class, which provides the functionality of a message digest algorithm, such as MD5 or SHA.
      Permission
      Abstract class for representing access to a system resource.
      PermissionCollection
      Abstract class representing a collection of Permission objects.
      Permissions
      This class represents a heterogeneous collection of Permissions.
      PKCS12Attribute
      An attribute associated with a PKCS12 keystore entry.
      Policy
      A Policy object is responsible for determining whether code executing in the Java runtime environment has permission to perform a security-sensitive operation.
      PolicySpi
      This class defines the Service Provider Interface (SPI) for the Policy class.
      ProtectionDomain
      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.acl

      Interface Summary 
      Interface Description
      Acl
      Interface representing an Access Control List (ACL).
      AclEntry
      This is the interface used for representing one entry in an Access Control List (ACL).
      Group
      This interface is used to represent a group of principals.
      Owner
      Interface for managing owners of Access Control Lists (ACLs) or ACL configurations.
      Permission
      This interface represents a permission, such as that used to grant a particular type of access to a resource.
      Exception Summary 
      Exception Description
      AclNotFoundException
      This is an exception that is thrown whenever a reference is made to a non-existent ACL (Access Control List).
      LastOwnerException
      This is an exception that is thrown whenever an attempt is made to delete the last owner of an Access Control List.
      NotOwnerException
      This is an exception that is thrown whenever the modification of an object (such as an Access Control List) is only allowed to be done by an owner of the object, but the Principal attempting the modification is not an owner.
    • 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.sql

      Interface Summary 
      Interface Description
      Array
      The mapping in the Java programming language for the SQL type ARRAY.
      Blob
      The representation (mapping) in the Java™ programming language of an SQL BLOB value.
      CallableStatement
      The interface used to execute SQL stored procedures.
      Clob
      The mapping in the Java™ programming language for the SQL CLOB type.
      Connection
      A connection (session) with a specific database.
      DatabaseMetaData
      Comprehensive information about the database as a whole.
      Driver
      The interface that every driver class must implement.
      DriverAction
      An interface that must be implemented when a Driver wants to be notified by DriverManager.
      NClob
      The mapping in the Java™ programming language for the SQL NCLOB type.
      ParameterMetaData
      An object that can be used to get information about the types and properties for each parameter marker in a PreparedStatement object.
      PreparedStatement
      An object that represents a precompiled SQL statement.
      Ref
      The mapping in the Java programming language of an SQL REF value, which is a reference to an SQL structured type value in the database.
      ResultSet
      A table of data representing a database result set, which is usually generated by executing a statement that queries the database.
      ResultSetMetaData
      An object that can be used to get information about the types and properties of the columns in a ResultSet object.
      RowId
      The representation (mapping) in the Java programming language of an SQL ROWID value.
      Savepoint
      The representation of a savepoint, which is a point within the current transaction that can be referenced from the Connection.rollback method.
      SQLData
      The interface used for the custom mapping of an SQL user-defined type (UDT) to a class in the Java programming language.
      SQLInput
      An input stream that contains a stream of values representing an instance of an SQL structured type or an SQL distinct type.
      SQLOutput
      The output stream for writing the attributes of a user-defined type back to the database.
      SQLType
      An object that is used to identify a generic SQL type, called a JDBC type or a vendor specific data type.
      SQLXML
      The mapping in the JavaTM programming language for the SQL XML type.
      Statement
      The object used for executing a static SQL statement and returning the results it produces.
      Struct
      The standard mapping in the Java programming language for an SQL structured type.
      Wrapper
      Interface for JDBC classes which provide the ability to retrieve the delegate instance when the instance in question is in fact a proxy class.
      Class Summary 
      Class Description
      Date
      A thin wrapper around a millisecond value that allows JDBC to identify this as an SQL DATE value.
      DriverManager
      The basic service for managing a set of JDBC drivers.
      NOTE: The DataSource interface, new in the JDBC 2.0 API, provides another way to connect to a data source.
      DriverPropertyInfo
      Driver properties for making a connection.
      SQLPermission
      The permission for which the SecurityManager will check when code that is running an application with a SecurityManager enabled, calls the DriverManager.deregisterDriver method, DriverManager.setLogWriter method, DriverManager.setLogStream (deprecated) method, SyncFactory.setJNDIContext method, SyncFactory.setLogger method, Connection.setNetworktimeout method, or the Connection.abort method.
      Time
      A thin wrapper around the java.util.Date class that allows the JDBC API to identify this as an SQL TIME value.
      Timestamp
      A thin wrapper around java.util.Date that allows the JDBC API to identify this as an SQL TIMESTAMP value.
      Types
      The class that defines the constants that are used to identify generic SQL types, called JDBC types.
      Enum Summary 
      Enum Description
      ClientInfoStatus
      Enumeration for status of the reason that a property could not be set via a call to Connection.setClientInfo
      JDBCType
      Defines the constants that are used to identify generic SQL types, called JDBC types.
      PseudoColumnUsage
      Enumeration for pseudo/hidden column usage.
      RowIdLifetime
      Enumeration for RowId life-time values.
      Exception Summary 
      Exception Description
      BatchUpdateException
      The subclass of SQLException thrown when an error occurs during a batch update operation.
      DataTruncation
      An exception thrown as a DataTruncation exception (on writes) or reported as a DataTruncation warning (on reads) when a data values is unexpectedly truncated for reasons other than its having exceeded MaxFieldSize.
      SQLClientInfoException
      The subclass of SQLException is thrown when one or more client info properties could not be set on a Connection.
      SQLDataException
      The subclass of SQLException thrown when the SQLState class value is '22', or under vendor-specified conditions.
      SQLException
      An exception that provides information on a database access error or other errors.
      SQLFeatureNotSupportedException
      The subclass of SQLException thrown when the SQLState class value is '0A' ( the value is 'zero' A).
      SQLIntegrityConstraintViolationException
      The subclass of SQLException thrown when the SQLState class value is '23', or under vendor-specified conditions.
      SQLInvalidAuthorizationSpecException
      The subclass of SQLException thrown when the SQLState class value is '28', or under vendor-specified conditions.
      SQLNonTransientConnectionException
      The subclass of SQLException thrown for the SQLState class value '08', or under vendor-specified conditions.
      SQLNonTransientException
      The subclass of SQLException thrown when an instance where a retry of the same operation would fail unless the cause of the SQLException is corrected.
      SQLRecoverableException
      The subclass of SQLException thrown in situations where a previously failed operation might be able to succeed if the application performs some recovery steps and retries the entire transaction or in the case of a distributed transaction, the transaction branch.
      SQLSyntaxErrorException
      The subclass of SQLException thrown when the SQLState class value is '42', or under vendor-specified conditions.
      SQLTimeoutException
      The subclass of SQLException thrown when the timeout specified by Statement.setQueryTimeout, DriverManager.setLoginTimeout, DataSource.setLoginTimeout,XADataSource.setLoginTimeout has expired.
      SQLTransactionRollbackException
      The subclass of SQLException thrown when the SQLState class value is '40', or under vendor-specified conditions.
      SQLTransientConnectionException
      The subclass of SQLException for the SQLState class value '08', or under vendor-specified conditions.
      SQLTransientException
      The subclass of SQLException is thrown in situations where a previously failed operation might be able to succeed when the operation is retried without any intervention by application-level functionality.
      SQLWarning
      An exception that provides information on database access warnings.
    • java.text

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

      Interface Summary 
      Interface Description
      NodeChangeListener
      A listener for receiving preference node change events.
      PreferenceChangeListener
      A listener for receiving preference change events.
      PreferencesFactory
      A factory object that generates Preferences objects.
      Class Summary 
      Class Description
      AbstractPreferences
      This class provides a skeletal implementation of the Preferences class, greatly easing the task of implementing it.
      NodeChangeEvent
      An event emitted by a Preferences node to indicate that a child of that node has been added or removed.
      PreferenceChangeEvent
      An event emitted by a Preferences node to indicate that a preference has been added, removed or has had its value changed.
      Preferences
      A node in a hierarchical collection of preference data.
      Exception Summary 
      Exception Description
      BackingStoreException
      Thrown to indicate that a preferences operation could not complete because of a failure in the backing store, or a failure to contact the backing store.
      InvalidPreferencesFormatException
      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 preferences, as per the Preferences specification.
    • 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.lang.model

      Interface Summary 
      Interface Description
      AnnotatedConstruct
      Represents a construct that can be annotated.
      Enum Summary 
      Enum Description
      SourceVersion
      Source versions of the Java™ programming language.
      Exception Summary 
      Exception Description
      UnknownEntityException
      Superclass of exceptions which indicate that an unknown kind of entity was encountered.
    • javax.lang.model.element

      Interface Summary 
      Interface Description
      AnnotationMirror
      Represents an annotation.
      AnnotationValue
      Represents a value of an annotation type element.
      AnnotationValueVisitor<R,P>
      A visitor of the values of annotation type elements, using a variant of the visitor design pattern.
      Element
      Represents a program element such as a package, class, or method.
      ElementVisitor<R,P>
      A visitor of program elements, in the style of the visitor design pattern.
      ExecutableElement
      Represents a method, constructor, or initializer (static or instance) of a class or interface, including annotation type elements.
      Name
      An immutable sequence of characters.
      PackageElement
      Represents a package program element.
      Parameterizable
      A mixin interface for an element that has type parameters.
      QualifiedNameable
      A mixin interface for an element that has a qualified name.
      TypeElement
      Represents a class or interface program element.
      TypeParameterElement
      Represents a formal type parameter of a generic class, interface, method, or constructor element.
      VariableElement
      Represents a field, enum constant, method or constructor parameter, local variable, resource variable, or exception parameter.
      Enum Summary 
      Enum Description
      ElementKind
      The kind of an element.
      Modifier
      Represents a modifier on a program element such as a class, method, or field.
      NestingKind
      The nesting kind of a type element.
      Exception Summary 
      Exception Description
      UnknownAnnotationValueException
      Indicates that an unknown kind of annotation value was encountered.
      UnknownElementException
      Indicates that an unknown kind of element was encountered.
    • javax.management.monitor

      Interface Summary 
      Interface Description
      CounterMonitorMBean
      Exposes the remote management interface of the counter monitor MBean.
      GaugeMonitorMBean
      Exposes the remote management interface of the gauge monitor MBean.
      MonitorMBean
      Exposes the remote management interface of monitor MBeans.
      StringMonitorMBean
      Exposes the remote management interface of the string monitor MBean.
      Class Summary 
      Class Description
      CounterMonitor
      Defines a monitor MBean designed to observe the values of a counter attribute.
      GaugeMonitor
      Defines a monitor MBean designed to observe the values of a gauge attribute.
      Monitor
      Defines the part common to all monitor MBeans.
      MonitorNotification
      Provides definitions of the notifications sent by monitor MBeans.
      StringMonitor
      Defines a monitor MBean designed to observe the values of a string attribute.
      Exception Summary 
      Exception Description
      MonitorSettingException
      Exception thrown by the monitor when a monitor setting becomes invalid while the monitor is running.
    • javax.management.openmbean

      Interface Summary 
      Interface Description
      CompositeData
      The CompositeData interface specifies the behavior of a specific type of complex open data objects which represent composite data structures.
      CompositeDataView
      A Java class can implement this interface to indicate how it is to be converted into a CompositeData by the MXBean framework.
      OpenMBeanAttributeInfo
      Describes an attribute of an open MBean.
      OpenMBeanConstructorInfo
      Describes a constructor of an Open MBean.
      OpenMBeanInfo
      Describes an Open MBean: an Open MBean is recognized as such if its getMBeanInfo() method returns an instance of a class which implements the OpenMBeanInfo interface, typically OpenMBeanInfoSupport.
      OpenMBeanOperationInfo
      Describes an operation of an Open MBean.
      OpenMBeanParameterInfo
      Describes a parameter used in one or more operations or constructors of an open MBean.
      TabularData
      The TabularData interface specifies the behavior of a specific type of complex open data objects which represent tabular data structures.
      Class Summary 
      Class Description
      ArrayType<T>
      The ArrayType class is the open type class whose instances describe all open data values which are n-dimensional arrays of open data values.
      CompositeDataInvocationHandler
      An InvocationHandler that forwards getter methods to a CompositeData.
      CompositeDataSupport
      The CompositeDataSupport class is the open data class which implements the CompositeData interface.
      CompositeType
      The CompositeType class is the open type class whose instances describe the types of CompositeData values.
      OpenMBeanAttributeInfoSupport
      Describes an attribute of an open MBean.
      OpenMBeanConstructorInfoSupport
      Describes a constructor of an Open MBean.
      OpenMBeanInfoSupport
      The OpenMBeanInfoSupport class describes the management information of an open MBean: it is a subclass of MBeanInfo, and it implements the OpenMBeanInfo interface.
      OpenMBeanOperationInfoSupport
      Describes an operation of an Open MBean.
      OpenMBeanParameterInfoSupport
      Describes a parameter used in one or more operations or constructors of an open MBean.
      OpenType<T>
      The OpenType class is the parent abstract class of all classes which describe the actual open type of open data values.
      SimpleType<T>
      The SimpleType class is the open type class whose instances describe all open data values which are neither arrays, nor CompositeData values, nor TabularData values.
      TabularDataSupport
      The TabularDataSupport class is the open data class which implements the TabularData and the Map interfaces, and which is internally based on a hash map data structure.
      TabularType
      The TabularType class is the open type class whose instances describe the types of TabularData values.
      Exception Summary 
      Exception Description
      InvalidKeyException
      This runtime exception is thrown to indicate that a method parameter which was expected to be an item name of a composite data or a row index of a tabular data is not valid.
      InvalidOpenTypeException
      This runtime exception is thrown to indicate that the open type of an open data value is not the one expected.
      KeyAlreadyExistsException
      This runtime exception is thrown to indicate that the index of a row to be added to a tabular data instance is already used to refer to another row in this tabular data instance.
      OpenDataException
      This checked exception is thrown when an open type, an open data or an open MBean metadata info instance could not be constructed because one or more validity constraints were not met.
    • javax.management.relation

      Interface Summary 
      Interface Description
      Relation
      This interface has to be implemented by any MBean class expected to represent a relation managed using the Relation Service.
      RelationServiceMBean
      The Relation Service is in charge of creating and deleting relation types and relations, of handling the consistency and of providing query mechanisms.
      RelationSupportMBean
      A RelationSupport object is used internally by the Relation Service to represent simple relations (only roles, no properties or methods), with an unlimited number of roles, of any relation type.
      RelationType
      The RelationType interface has to be implemented by any class expected to represent a relation type.
      Class Summary 
      Class Description
      MBeanServerNotificationFilter
      RelationNotification
      A notification of a change in the Relation Service.
      RelationService
      The Relation Service is in charge of creating and deleting relation types and relations, of handling the consistency and of providing query mechanisms.
      RelationSupport
      A RelationSupport object is used internally by the Relation Service to represent simple relations (only roles, no properties or methods), with an unlimited number of roles, of any relation type.
      RelationTypeSupport
      A RelationTypeSupport object implements the RelationType interface.
      Role
      Represents a role: includes a role name and referenced MBeans (via their ObjectNames).
      RoleInfo
      A RoleInfo object summarises a role in a relation type.
      RoleList
      A RoleList represents a list of roles (Role objects).
      RoleResult
      Represents the result of a multiple access to several roles of a relation (either for reading or writing).
      RoleStatus
      This class describes the various problems which can be encountered when accessing a role.
      RoleUnresolved
      Represents an unresolved role: a role not retrieved from a relation due to a problem.
      RoleUnresolvedList
      A RoleUnresolvedList represents a list of RoleUnresolved objects, representing roles not retrieved from a relation due to a problem encountered when trying to access (read or write) the roles.
      Exception Summary 
      Exception Description
      InvalidRelationIdException
      This exception is raised when relation id provided for a relation is already used.
      InvalidRelationServiceException
      This exception is raised when an invalid Relation Service is provided.
      InvalidRelationTypeException
      Invalid relation type.
      InvalidRoleInfoException
      This exception is raised when, in a role info, its minimum degree is greater than its maximum degree.
      InvalidRoleValueException
      Role value is invalid.
      RelationException
      This class is the superclass of any exception which can be raised during relation management.
      RelationNotFoundException
      This exception is raised when there is no relation for a given relation id in a Relation Service.
      RelationServiceNotRegisteredException
      This exception is raised when an access is done to the Relation Service and that one is not registered.
      RelationTypeNotFoundException
      This exception is raised when there is no relation type with given name in Relation Service.
      RoleInfoNotFoundException
      This exception is raised when there is no role info with given name in a given relation type.
      RoleNotFoundException
      This exception is raised when a role in a relation does not exist, or is not readable, or is not settable.
    • javax.management.timer

      Interface Summary 
      Interface Description
      TimerMBean
      Exposes the management interface of the timer MBean.
      Class Summary 
      Class Description
      Timer
      Provides the implementation of the timer MBean.
      TimerNotification
      This class provides definitions of the notifications sent by timer MBeans.
    • javax.naming

      Interface Summary 
      Interface Description
      Context
      This interface represents a naming context, which consists of a set of name-to-object bindings.
      Name
      The Name interface represents a generic name -- an ordered sequence of components.
      NameParser
      This interface is used for parsing names from a hierarchical namespace.
      NamingEnumeration<T>
      This interface is for enumerating lists returned by methods in the javax.naming and javax.naming.directory packages.
      Referenceable
      This interface is implemented by an object that can provide a Reference to itself.
      Class Summary 
      Class Description
      BinaryRefAddr
      This class represents the binary form of the address of a communications end-point.
      Binding
      This class represents a name-to-object binding found in a context.
      CompositeName
      This class represents a composite name -- a sequence of component names spanning multiple namespaces.
      CompoundName
      This class represents a compound name -- a name from a hierarchical name space.
      InitialContext
      This class is the starting context for performing naming operations.
      LinkRef
      This class represents a Reference whose contents is a name, called the link name, that is bound to an atomic name in a context.
      NameClassPair
      This class represents the object name and class name pair of a binding found in a context.
      RefAddr
      This class represents the address of a communications end-point.
      Reference
      This class represents a reference to an object that is found outside of the naming/directory system.
      StringRefAddr
      This class represents the string form of the address of a communications end-point.
      Exception Summary 
      Exception Description
      AuthenticationException
      This exception is thrown when an authentication error occurs while accessing the naming or directory service.
      AuthenticationNotSupportedException
      This exception is thrown when the particular flavor of authentication requested is not supported.
      CannotProceedException
      This exception is thrown to indicate that the operation reached a point in the name where the operation cannot proceed any further.
      CommunicationException
      This exception is thrown when the client is unable to communicate with the directory or naming service.
      ConfigurationException
      This exception is thrown when there is a configuration problem.
      ContextNotEmptyException
      This exception is thrown when attempting to destroy a context that is not empty.
      InsufficientResourcesException
      This exception is thrown when resources are not available to complete the requested operation.
      InterruptedNamingException
      This exception is thrown when the naming operation being invoked has been interrupted.
      InvalidNameException
      This exception indicates that the name being specified does not conform to the naming syntax of a naming system.
      LimitExceededException
      This exception is thrown when a method terminates abnormally due to a user or system specified limit.
      LinkException
      This exception is used to describe problems encounter while resolving links.
      LinkLoopException
      This exception is thrown when a loop was detected will attempting to resolve a link, or an implementation specific limit on link counts has been reached.
      MalformedLinkException
      This exception is thrown when a malformed link was encountered while resolving or constructing a link.
      NameAlreadyBoundException
      This exception is thrown by methods to indicate that a binding cannot be added because the name is already bound to another object.
      NameNotFoundException
      This exception is thrown when a component of the name cannot be resolved because it is not bound.
      NamingException
      This is the superclass of all exceptions thrown by operations in the Context and DirContext interfaces.
      NamingSecurityException
      This is the superclass of security-related exceptions thrown by operations in the Context and DirContext interfaces.
      NoInitialContextException
      This exception is thrown when no initial context implementation can be created.
      NoPermissionException
      This exception is thrown when attempting to perform an operation for which the client has no permission.
      NotContextException
      This exception is thrown when a naming operation proceeds to a point where a context is required to continue the operation, but the resolved object is not a context.
      OperationNotSupportedException
      This exception is thrown when a context implementation does not support the operation being invoked.
      PartialResultException
      This exception is thrown to indicate that the result being returned or returned so far is partial, and that the operation cannot be completed.
      ReferralException
      This abstract class is used to represent a referral exception, which is generated in response to a referral such as that returned by LDAP v3 servers.
      ServiceUnavailableException
      This exception is thrown when attempting to communicate with a directory or naming service and that service is not available.
      SizeLimitExceededException
      This exception is thrown when a method produces a result that exceeds a size-related limit.
      TimeLimitExceededException
      This exception is thrown when a method does not terminate within the specified time limit.
    • javax.naming.directory

      Interface Summary 
      Interface Description
      Attribute
      This interface represents an attribute associated with a named object.
      Attributes
      This interface represents a collection of attributes.
      DirContext
      The directory service interface, containing methods for examining and updating attributes associated with objects, and for searching the directory.
      Class Summary 
      Class Description
      BasicAttribute
      This class provides a basic implementation of the Attribute interface.
      BasicAttributes
      This class provides a basic implementation of the Attributes interface.
      InitialDirContext
      This class is the starting context for performing directory operations.
      ModificationItem
      This class represents a modification item.
      SearchControls
      This class encapsulates factors that determine scope of search and what gets returned as a result of the search.
      SearchResult
      This class represents an item in the NamingEnumeration returned as a result of the DirContext.search() methods.
      Exception Summary 
      Exception Description
      AttributeInUseException
      This exception is thrown when an operation attempts to add an attribute that already exists.
      AttributeModificationException
      This exception is thrown when an attempt is made to add, or remove, or modify an attribute, its identifier, or its values that conflicts with the attribute's (schema) definition or the attribute's state.
      InvalidAttributeIdentifierException
      This exception is thrown when an attempt is made to add to create an attribute with an invalid attribute identifier.
      InvalidAttributesException
      This exception is thrown when an attempt is made to add or modify an attribute set that has been specified incompletely or incorrectly.
      InvalidAttributeValueException
      This class is thrown when an attempt is made to add to an attribute a value that conflicts with the attribute's schema definition.
      InvalidSearchControlsException
      This exception is thrown when the specification of the SearchControls for a search operation is invalid.
      InvalidSearchFilterException
      This exception is thrown when the specification of a search filter is invalid.
      NoSuchAttributeException
      This exception is thrown when attempting to access an attribute that does not exist.
      SchemaViolationException
      This exception is thrown when a method in some ways violates the schema.
    • javax.naming.event

      Interface Summary 
      Interface Description
      EventContext
      Contains methods for registering/deregistering listeners to be notified of events fired when objects named in a context changes.
      EventDirContext
      Contains methods for registering listeners to be notified of events fired when objects named in a directory context changes.
      NamespaceChangeListener
      Specifies the methods that a listener interested in namespace changes must implement.
      NamingListener
      This interface is the root of listener interfaces that handle NamingEvents.
      ObjectChangeListener
      Specifies the method that a listener of a NamingEvent with event type of OBJECT_CHANGED must implement.
      Class Summary 
      Class Description
      NamingEvent
      This class represents an event fired by a naming/directory service.
      NamingExceptionEvent
      This class represents an event fired when the procedures/processes used to collect information for notifying listeners of NamingEvents threw a NamingException.
    • javax.naming.spi

      Interface Summary 
      Interface Description
      DirObjectFactory
      This interface represents a factory for creating an object given an object and attributes about the object.
      DirStateFactory
      This interface represents a factory for obtaining the state of an object and corresponding attributes for binding.
      InitialContextFactory
      This interface represents a factory that creates an initial context.
      InitialContextFactoryBuilder
      This interface represents a builder that creates initial context factories.
      ObjectFactory
      This interface represents a factory for creating an object.
      ObjectFactoryBuilder
      This interface represents a builder that creates object factories.
      Resolver
      This interface represents an "intermediate context" for name resolution.
      StateFactory
      This interface represents a factory for obtaining the state of an object for binding.
      Class Summary 
      Class Description
      DirectoryManager
      This class contains methods for supporting DirContext implementations.
      DirStateFactory.Result
      An object/attributes pair for returning the result of DirStateFactory.getStateToBind().
      NamingManager
      This class contains methods for creating context objects and objects referred to by location information in the naming or directory service.
      ResolveResult
      This class represents the result of resolution of a name.
    • 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.rmi.ssl

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

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

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

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

      Class Summary 
      Class Description
      DelegationPermission
      This class is used to restrict the usage of the Kerberos delegation model, ie: forwardable and proxiable tickets.
      KerberosKey
      This class encapsulates a long term secret key for a Kerberos principal.
      KerberosPrincipal
      This class encapsulates a Kerberos principal.
      KerberosTicket
      This class encapsulates a Kerberos ticket and associated information as viewed from the client's point of view.
      KeyTab
      This class encapsulates a keytab file.
      ServicePermission
      This class is used to protect Kerberos services and the credentials necessary to access those services.
    • javax.security.sasl

      Interface Summary 
      Interface Description
      SaslClient
      Performs SASL authentication as a client.
      SaslClientFactory
      An interface for creating instances of SaslClient.
      SaslServer
      Performs SASL authentication as a server.
      SaslServerFactory
      An interface for creating instances of SaslServer.
      Class Summary 
      Class Description
      AuthorizeCallback
      This callback is used by SaslServer to determine whether one entity (identified by an authenticated authentication id) can act on behalf of another entity (identified by an authorization id).
      RealmCallback
      This callback is used by SaslClient and SaslServer to retrieve realm information.
      RealmChoiceCallback
      This callback is used by SaslClient and SaslServer to obtain a realm given a list of realm choices.
      Sasl
      A static class for creating SASL clients and servers.
      Exception Summary 
      Exception Description
      AuthenticationException
      This exception is thrown by a SASL mechanism implementation to indicate that the SASL exchange has failed due to reasons related to authentication, such as an invalid identity, passphrase, or key.
      SaslException
      This class represents an error that has occurred when using SASL.
    • javax.sql

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

      Interface Summary 
      Interface Description
      CachedRowSet
      The interface that all standard implementations of CachedRowSet must implement.
      FilteredRowSet
      The standard interface that all standard implementations of FilteredRowSet must implement.
      JdbcRowSet
      The standard interface that all standard implementations of JdbcRowSet must implement.
      Joinable
      1.0 Background
      JoinRowSet
      The JoinRowSet interface provides a mechanism for combining related data from different RowSet objects into one JoinRowSet object, which represents an SQL JOIN.
      Predicate
      The standard interface that provides the framework for all FilteredRowSet objects to describe their filters.
      RowSetFactory
      An interface that defines the implementation of a factory that is used to obtain different types of RowSet implementations.
      WebRowSet
      The standard interface that all implementations of a WebRowSet must implement.
      Class Summary 
      Class Description
      BaseRowSet
      An abstract class providing a RowSet object with its basic functionality.
      RowSetMetaDataImpl
      Provides implementations for the methods that set and get metadata information about a RowSet object's columns.
      RowSetProvider
      A factory API that enables applications to obtain a RowSetFactory implementation that can be used to create different types of RowSet implementations.
      Exception Summary 
      Exception Description
      RowSetWarning
      An extension of SQLException that provides information about database warnings set on RowSet objects.
    • javax.sql.rowset.serial

      Class Summary 
      Class Description
      SerialArray
      A serialized version of an Array object, which is the mapping in the Java programming language of an SQL ARRAY value.
      SerialBlob
      A serialized mapping in the Java programming language of an SQL BLOB value.
      SerialClob
      A serialized mapping in the Java programming language of an SQL CLOB value.
      SerialDatalink
      A serialized mapping in the Java programming language of an SQL DATALINK value.
      SerialJavaObject
      A serializable mapping in the Java programming language of an SQL JAVA_OBJECT value.
      SerialRef
      A serialized mapping of a Ref object, which is the mapping in the Java programming language of an SQL REF value.
      SerialStruct
      A serialized mapping in the Java programming language of an SQL structured type.
      SQLInputImpl
      An input stream used for custom mapping user-defined types (UDTs).
      SQLOutputImpl
      The output stream for writing the attributes of a custom-mapped user-defined type (UDT) back to the database.
      Exception Summary 
      Exception Description
      SerialException
      Indicates and an error with the serialization or de-serialization of SQL types such as BLOB, CLOB, STRUCT or ARRAY in addition to SQL types such as DATALINK and JAVAOBJECT
    • javax.sql.rowset.spi

      Interface Summary 
      Interface Description
      SyncResolver
      Defines a framework that allows applications to use a manual decision tree to decide what should be done when a synchronization conflict occurs.
      TransactionalWriter
      A specialized interface that facilitates an extension of the standard SyncProvider abstract class so that it has finer grained transaction control.
      XmlReader
      A specialized interface that facilitates an extension of the SyncProvider abstract class for XML orientated synchronization providers.
      XmlWriter
      A specialized interface that facilitates an extension of the SyncProvider abstract class for XML orientated synchronization providers.
      Class Summary 
      Class Description
      SyncFactory
      The Service Provider Interface (SPI) mechanism that generates SyncProvider instances to be used by disconnected RowSet objects.
      SyncProvider
      The synchronization mechanism that provides reader/writer capabilities for disconnected RowSet objects.
      Exception Summary 
      Exception Description
      SyncFactoryException
      Indicates an error with SyncFactory mechanism.
      SyncProviderException
      Indicates an error with the SyncProvider mechanism.
    • javax.transaction.xa

      Interface Summary 
      Interface Description
      XAResource
      The XAResource interface is a Java mapping of the industry standard XA interface based on the X/Open CAE Specification (Distributed Transaction Processing: The XA Specification).
      Xid
      The Xid interface is a Java mapping of the X/Open transaction identifier XID structure.
      Exception Summary 
      Exception Description
      XAException
      The XAException is thrown by the Resource Manager (RM) to inform the Transaction Manager of an error encountered by the involved transaction.
    • javax.xml

      Class Summary 
      Class Description
      XMLConstants
      Utility class to contain basic XML values as constants.
    • javax.xml.parsers

      Class Summary 
      Class Description
      DocumentBuilder
      Defines the API to obtain DOM Document instances from an XML document.
      DocumentBuilderFactory
      Defines a factory API that enables applications to obtain a parser that produces DOM object trees from XML documents.
      SAXParser
      Defines the API that wraps an XMLReader implementation class.
      SAXParserFactory
      Defines a factory API that enables applications to configure and obtain a SAX based parser to parse XML documents.
      Exception Summary 
      Exception Description
      ParserConfigurationException
      Indicates a serious configuration error.
      Error Summary 
      Error Description
      FactoryConfigurationError
      Thrown when a problem with configuration with the Parser Factories exists.
    • javax.xml.stream

      Interface Summary 
      Interface Description
      EventFilter
      This interface declares a simple filter interface that one can create to filter XMLEventReaders
      Location
      Provides information on the location of an event.
      StreamFilter
      This interface declares a simple filter interface that one can create to filter XMLStreamReaders
      XMLEventReader
      This is the top level interface for parsing XML Events.
      XMLEventWriter
      This is the top level interface for writing XML documents.
      XMLReporter
      This interface is used to report non-fatal errors.
      XMLResolver
      This interface is used to resolve resources during an XML parse.
      XMLStreamConstants
      This interface declares the constants used in this API.
      XMLStreamReader
      The XMLStreamReader interface allows forward, read-only access to XML.
      XMLStreamWriter
      The XMLStreamWriter interface specifies how to write XML.
      Class Summary 
      Class Description
      XMLEventFactory
      This interface defines a utility class for creating instances of XMLEvents
      XMLInputFactory
      Defines an abstract implementation of a factory for getting streams.
      XMLOutputFactory
      Defines an abstract implementation of a factory for getting XMLEventWriters and XMLStreamWriters.
      Exception Summary 
      Exception Description
      XMLStreamException
      The base exception for unexpected processing errors.
      Error Summary 
      Error Description
      FactoryConfigurationError
      An error class for reporting factory configuration errors.
    • javax.xml.stream.events

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

      Interface Summary 
      Interface Description
      XMLEventAllocator
      This interface defines a class that allows a user to register a way to allocate events given an XMLStreamReader.
      XMLEventConsumer
      This interface defines an event consumer interface.
      Class Summary 
      Class Description
      EventReaderDelegate
      This is the base class for deriving an XMLEventReader filter.
      StreamReaderDelegate
      This is the base class for deriving an XMLStreamReader filter This class is designed to sit between an XMLStreamReader and an application's XMLStreamReader.
    • javax.xml.transform

      Interface Summary 
      Interface Description
      ErrorListener
      To provide customized error handling, implement this interface and use the setErrorListener method to register an instance of the implmentation with the Transformer.
      Result
      An object that implements this interface contains the information needed to build a transformation result tree.
      Source
      An object that implements this interface contains the information needed to act as source input (XML source or transformation instructions).
      SourceLocator
      This interface is primarily for the purposes of reporting where an error occurred in the XML source or transformation instructions.
      Templates
      An object that implements this interface is the runtime representation of processed transformation instructions.
      URIResolver
      An object that implements this interface that can be called by the processor to turn a URI used in document(), xsl:import, or xsl:include into a Source object.
      Class Summary 
      Class Description
      OutputKeys
      Provides string constants that can be used to set output properties for a Transformer, or to retrieve output properties from a Transformer or Templates object.
      Transformer
      An instance of this abstract class can transform a source tree into a result tree.
      TransformerFactory
      A TransformerFactory instance can be used to create Transformer and Templates objects.
      Exception Summary 
      Exception Description
      TransformerConfigurationException
      Indicates a serious configuration error.
      TransformerException
      This class specifies an exceptional condition that occured during the transformation process.
      Error Summary 
      Error Description
      TransformerFactoryConfigurationError
      Thrown when a problem with configuration with the Transformer Factories exists.
    • javax.xml.transform.dom

      Interface Summary 
      Interface Description
      DOMLocator
      Indicates the position of a node in a source DOM, intended primarily for error reporting.
      Class Summary 
      Class Description
      DOMResult
      Acts as a holder for a transformation result tree in the form of a Document Object Model (DOM) tree.
      DOMSource
      Acts as a holder for a transformation Source tree in the form of a Document Object Model (DOM) tree.
    • javax.xml.transform.sax

      Interface Summary 
      Interface Description
      TemplatesHandler
      A SAX ContentHandler that may be used to process SAX parse events (parsing transformation instructions) into a Templates object.
      TransformerHandler
      A TransformerHandler listens for SAX ContentHandler parse events and transforms them to a Result.
      Class Summary 
      Class Description
      SAXResult
      Acts as an holder for a transformation Result.
      SAXSource
      Acts as an holder for SAX-style Source.
      SAXTransformerFactory
      This class extends TransformerFactory to provide SAX-specific factory methods.
    • javax.xml.transform.stream

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

      Interface Summary 
      Interface Description
      GSSContext
      This interface encapsulates the GSS-API security context and provides the security services that are available over the context.
      GSSCredential
      This interface encapsulates the GSS-API credentials for an entity.
      GSSName
      This interface encapsulates a single GSS-API principal entity.
      Class Summary 
      Class Description
      ChannelBinding
      This class encapsulates the concept of caller-provided channel binding information.
      GSSManager
      This class serves as a factory for other important GSS-API classes and also provides information about the mechanisms that are supported.
      MessageProp
      This is a utility class used within the per-message GSSContext methods to convey per-message properties.
      Oid
      This class represents Universal Object Identifiers (Oids) and their associated operations.
      Exception Summary 
      Exception Description
      GSSException
      This exception is thrown whenever a GSS-API error occurs, including any mechanism specific error.
    • org.w3c.dom

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

      Interface Summary 
      Interface Description
      DocumentEvent
      The DocumentEvent interface provides a mechanism by which the user can create an Event of a type supported by the implementation.
      Event
      The Event interface is used to provide contextual information about an event to the handler processing the event.
      EventListener
      The EventListener interface is the primary method for handling events.
      EventTarget
      The EventTarget interface is implemented by all Nodes in an implementation which supports the DOM Event Model.
      MouseEvent
      The MouseEvent interface provides specific contextual information associated with Mouse events.
      MutationEvent
      The MutationEvent interface provides specific contextual information associated with Mutation events.
      UIEvent
      The UIEvent interface provides specific contextual information associated with User Interface events.
      Exception Summary 
      Exception Description
      EventException
      Event operations may throw an EventException as specified in their method descriptions.
    • org.w3c.dom.ls

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

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


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: 13620 / 159220478. Delta: 0.13701 с