| Package | Description | 
|---|---|
| java.beans | 
 Contains classes related to developing
beans -- components
based on the JavaBeans™ architecture. 
 | 
| java.io | 
 Provides for system input and output through data streams,
serialization and the file system. 
 | 
| java.net | 
 Provides the classes for implementing networking applications. 
 | 
| java.nio.channels | 
 Defines channels, which represent connections to entities that are capable of
 performing I/O operations, such as files and sockets; defines selectors, for
 multiplexed, non-blocking I/O operations. 
 | 
| java.nio.channels.spi | 
 Service-provider classes for the  
java.nio.channels package. | 
| java.nio.file | 
 Defines interfaces and classes for the Java virtual machine to access files,
 file attributes, and file systems. 
 | 
| java.rmi.server | 
 Provides classes and interfaces for supporting the server
side of RMI. 
 | 
| java.security | 
 Provides the classes and interfaces for the security framework. 
 | 
| java.sql | 
 Provides the API for accessing and processing data stored in a 
data source (usually a relational database) using the 
JavaTM programming language. 
 | 
| java.util | 
 Contains the collections framework, legacy collection classes, event model,
date and time facilities, internationalization, and miscellaneous utility
classes (a string tokenizer, a random-number generator, and a bit array). 
 | 
| java.util.jar | 
 Provides classes for reading and writing the JAR (Java ARchive) file
format, which is based on the standard ZIP file format with an
optional manifest file. 
 | 
| java.util.stream | 
 Classes to support functional-style operations on streams of elements, such
 as map-reduce transformations on collections. 
 | 
| java.util.zip | 
 Provides classes for reading and writing the standard ZIP and GZIP
file formats. 
 | 
| javax.crypto | 
 Provides the classes and interfaces for cryptographic operations. 
 | 
| javax.imageio.stream | 
 A package of the Java Image I/O API dealing with low-level I/O from
files and streams. 
 | 
| javax.management.loading | 
 Provides the classes which implement advanced dynamic
        loading. 
 | 
| javax.management.remote | 
 Interfaces for remote access to
        JMX MBean servers. 
 | 
| javax.management.remote.rmi | 
 The RMI connector is a connector for the JMX Remote API that
      uses RMI to transmit client requests to a remote MBean server. 
 | 
| javax.net.ssl | 
 Provides classes for the secure socket package. 
 | 
| javax.sound.midi | 
 Provides interfaces and classes for I/O, sequencing, and synthesis of MIDI 
(Musical Instrument Digital Interface) data. 
 | 
| javax.sound.sampled | 
 Provides interfaces and classes for capture, processing, and playback of sampled audio data. 
 | 
| javax.sql | 
 Provides the API for server side data source access and processing from
the JavaTM programming language. 
 | 
| javax.sql.rowset | 
 Standard interfaces and base classes for JDBC  
RowSet
implementations. | 
| javax.sql.rowset.spi | 
 The standard classes and interfaces that a third party vendor has to
use in its implementation of a synchronization provider. 
 | 
| javax.swing | 
 Provides a set of "lightweight"
(all-Java language) components that,
to the maximum degree possible, work the same on all platforms. 
 | 
| javax.tools | 
 Provides interfaces for tools which can be invoked from a program,
 for example, compilers. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
XMLDecoder
The  
XMLDecoder class is used to read XML documents
 created using the XMLEncoder and is used just like
 the ObjectInputStream. | 
class  | 
XMLEncoder
The  
XMLEncoder class is a complementary alternative to
 the ObjectOutputStream and can used to generate
 a textual representation of a JavaBean in the same
 way that the ObjectOutputStream can
 be used to create binary representation of Serializable
 objects. | 
| Modifier and Type | Interface and Description | 
|---|---|
interface  | 
Closeable
A  
Closeable is a source or destination of data that can be closed. | 
interface  | 
ObjectInput
ObjectInput extends the DataInput interface to include the reading of
 objects. 
 | 
interface  | 
ObjectOutput
ObjectOutput extends the DataOutput interface to include writing of objects. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
BufferedInputStream
A  
BufferedInputStream adds
 functionality to another input stream-namely,
 the ability to buffer the input and to
 support the mark and reset
 methods. | 
class  | 
BufferedOutputStream
The class implements a buffered output stream. 
 | 
class  | 
BufferedReader
Reads text from a character-input stream, buffering characters so as to
 provide for the efficient reading of characters, arrays, and lines. 
 | 
class  | 
BufferedWriter
Writes text to a character-output stream, buffering characters so as to
 provide for the efficient writing of single characters, arrays, and strings. 
 | 
class  | 
ByteArrayInputStream
A  
ByteArrayInputStream contains
 an internal buffer that contains bytes that
 may be read from the stream. | 
class  | 
ByteArrayOutputStream
This class implements an output stream in which the data is
 written into a byte array. 
 | 
class  | 
CharArrayReader
This class implements a character buffer that can be used as a
 character-input stream. 
 | 
class  | 
CharArrayWriter
This class implements a character buffer that can be used as an Writer. 
 | 
class  | 
DataInputStream
A data input stream lets an application read primitive Java data
 types from an underlying input stream in a machine-independent
 way. 
 | 
class  | 
DataOutputStream
A data output stream lets an application write primitive Java data
 types to an output stream in a portable way. 
 | 
class  | 
FileInputStream
A  
FileInputStream obtains input bytes
 from a file in a file system. | 
class  | 
FileOutputStream
A file output stream is an output stream for writing data to a
  
File or to a FileDescriptor. | 
class  | 
FileReader
Convenience class for reading character files. 
 | 
class  | 
FileWriter
Convenience class for writing character files. 
 | 
class  | 
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. | 
class  | 
FilterOutputStream
This class is the superclass of all classes that filter output
 streams. 
 | 
class  | 
FilterReader
Abstract class for reading filtered character streams. 
 | 
class  | 
FilterWriter
Abstract class for writing filtered character streams. 
 | 
class  | 
InputStream
This abstract class is the superclass of all classes representing
 an input stream of bytes. 
 | 
class  | 
InputStreamReader
An InputStreamReader is a bridge from byte streams to character streams: It
 reads bytes and decodes them into characters using a specified  
charset. | 
class  | 
LineNumberInputStream
Deprecated. 
 
This class incorrectly assumes that bytes adequately represent
             characters.  As of JDK 1.1, the preferred way to operate on
             character streams is via the new character-stream classes, which
             include a class for counting line numbers. 
 | 
class  | 
LineNumberReader
A buffered character-input stream that keeps track of line numbers. 
 | 
class  | 
ObjectInputStream
An ObjectInputStream deserializes primitive data and objects previously
 written using an ObjectOutputStream. 
 | 
class  | 
ObjectOutputStream
An ObjectOutputStream writes primitive data types and graphs of Java objects
 to an OutputStream. 
 | 
class  | 
OutputStream
This abstract class is the superclass of all classes representing
 an output stream of bytes. 
 | 
class  | 
OutputStreamWriter
An OutputStreamWriter is a bridge from character streams to byte streams:
 Characters written to it are encoded into bytes using a specified  
charset. | 
class  | 
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. 
 | 
class  | 
PipedOutputStream
A piped output stream can be connected to a piped input stream
 to create a communications pipe. 
 | 
class  | 
PipedReader
Piped character-input streams. 
 | 
class  | 
PipedWriter
Piped character-output streams. 
 | 
class  | 
PrintStream
A  
PrintStream adds functionality to another output stream,
 namely the ability to print representations of various data values
 conveniently. | 
class  | 
PrintWriter
Prints formatted representations of objects to a text-output stream. 
 | 
class  | 
PushbackInputStream
A  
PushbackInputStream adds
 functionality to another input stream, namely
 the  ability to "push back" or "unread"
 one byte. | 
class  | 
PushbackReader
A character-stream reader that allows characters to be pushed back into the
 stream. 
 | 
class  | 
RandomAccessFile
Instances of this class support both reading and writing to a
 random access file. 
 | 
class  | 
Reader
Abstract class for reading character streams. 
 | 
class  | 
SequenceInputStream
A  
SequenceInputStream represents
 the logical concatenation of other input
 streams. | 
class  | 
StringBufferInputStream
Deprecated. 
 
This class does not properly convert characters into bytes.  As
             of JDK 1.1, the preferred way to create a stream from a
             string is via the  
StringReader class. | 
class  | 
StringReader
A character stream whose source is a string. 
 | 
class  | 
StringWriter
A character stream that collects its output in a string buffer, which can
 then be used to construct a string. 
 | 
class  | 
Writer
Abstract class for writing to character streams. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
DatagramSocket
This class represents a socket for sending and receiving datagram packets. 
 | 
class  | 
MulticastSocket
The multicast datagram socket class is useful for sending
 and receiving IP multicast packets. 
 | 
class  | 
ServerSocket
This class implements server sockets. 
 | 
class  | 
Socket
This class implements client sockets (also called just
 "sockets"). 
 | 
class  | 
URLClassLoader
This class loader is used to load classes and resources from a search
 path of URLs referring to both JAR files and directories. 
 | 
| Modifier and Type | Interface and Description | 
|---|---|
interface  | 
AsynchronousByteChannel
An asynchronous channel that can read and write bytes. 
 | 
interface  | 
AsynchronousChannel
A channel that supports asynchronous I/O operations. 
 | 
interface  | 
ByteChannel
A channel that can read and write bytes. 
 | 
interface  | 
Channel
A nexus for I/O operations. 
 | 
interface  | 
GatheringByteChannel
A channel that can write bytes from a sequence of buffers. 
 | 
interface  | 
InterruptibleChannel
A channel that can be asynchronously closed and interrupted. 
 | 
interface  | 
MulticastChannel
A network channel that supports Internet Protocol (IP) multicasting. 
 | 
interface  | 
NetworkChannel
A channel to a network socket. 
 | 
interface  | 
ReadableByteChannel
A channel that can read bytes. 
 | 
interface  | 
ScatteringByteChannel
A channel that can read bytes into a sequence of buffers. 
 | 
interface  | 
SeekableByteChannel
A byte channel that maintains a current position and allows the
 position to be changed. 
 | 
interface  | 
WritableByteChannel
A channel that can write bytes. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
AsynchronousFileChannel
An asynchronous channel for reading, writing, and manipulating a file. 
 | 
class  | 
AsynchronousServerSocketChannel
An asynchronous channel for stream-oriented listening sockets. 
 | 
class  | 
AsynchronousSocketChannel
An asynchronous channel for stream-oriented connecting sockets. 
 | 
class  | 
DatagramChannel
A selectable channel for datagram-oriented sockets. 
 | 
class  | 
FileChannel
A channel for reading, writing, mapping, and manipulating a file. 
 | 
class  | 
FileLock
A token representing a lock on a region of a file. 
 | 
static class  | 
Pipe.SinkChannel
A channel representing the writable end of a  
Pipe. | 
static class  | 
Pipe.SourceChannel
A channel representing the readable end of a  
Pipe. | 
class  | 
SelectableChannel
A channel that can be multiplexed via a  
Selector. | 
class  | 
Selector
A multiplexor of  
SelectableChannel objects. | 
class  | 
ServerSocketChannel
A selectable channel for stream-oriented listening sockets. 
 | 
class  | 
SocketChannel
A selectable channel for stream-oriented connecting sockets. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
AbstractInterruptibleChannel
Base implementation class for interruptible channels. 
 | 
class  | 
AbstractSelectableChannel
Base implementation class for selectable channels. 
 | 
class  | 
AbstractSelector
Base implementation class for selectors. 
 | 
| Modifier and Type | Interface and Description | 
|---|---|
interface  | 
DirectoryStream<T>
An object to iterate over the entries in a directory. 
 | 
interface  | 
SecureDirectoryStream<T>
A  
DirectoryStream that defines operations on files that are located
 relative to an open directory. | 
interface  | 
WatchService
A watch service that watches registered objects for changes and
 events. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
FileSystem
Provides an interface to a file system and is the factory for objects to
 access files and other objects in the file system. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
LogStream
Deprecated. 
 
no replacement 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
DigestInputStream
A transparent stream that updates the associated message digest using
 the bits going through the stream. 
 | 
class  | 
DigestOutputStream
A transparent stream that updates the associated message digest using
 the bits going through the stream. 
 | 
| Modifier and Type | Interface and Description | 
|---|---|
interface  | 
CallableStatement
The interface used to execute SQL stored procedures. 
 | 
interface  | 
Connection
A connection (session) with a specific
 database. 
 | 
interface  | 
PreparedStatement
An object that represents a precompiled SQL statement. 
 | 
interface  | 
ResultSet
A table of data representing a database result set, which
 is usually generated by executing a statement that queries the database. 
 | 
interface  | 
Statement
The object used for executing a static SQL statement
 and returning the results it produces. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
Formatter
An interpreter for printf-style format strings. 
 | 
class  | 
Scanner
A simple text scanner which can parse primitive types and strings using
 regular expressions. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
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. | 
class  | 
JarInputStream
The  
JarInputStream class is used to read the contents of
 a JAR file from any input stream. | 
class  | 
JarOutputStream
The  
JarOutputStream class is used to write the contents
 of a JAR file to any output stream. | 
| Modifier and Type | Interface and Description | 
|---|---|
interface  | 
BaseStream<T,S extends BaseStream<T,S>>
Base interface for streams, which are sequences of elements supporting
 sequential and parallel aggregate operations. 
 | 
interface  | 
DoubleStream
A sequence of primitive double-valued elements supporting sequential and parallel
 aggregate operations. 
 | 
interface  | 
IntStream
A sequence of primitive int-valued elements supporting sequential and parallel
 aggregate operations. 
 | 
interface  | 
LongStream
A sequence of primitive long-valued elements supporting sequential and parallel
 aggregate operations. 
 | 
interface  | 
Stream<T>
A sequence of elements supporting sequential and parallel aggregate
 operations. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
CheckedInputStream
An input stream that also maintains a checksum of the data being read. 
 | 
class  | 
CheckedOutputStream
An output stream that also maintains a checksum of the data being
 written. 
 | 
class  | 
DeflaterInputStream
Implements an input stream filter for compressing data in the "deflate"
 compression format. 
 | 
class  | 
DeflaterOutputStream
This class implements an output stream filter for compressing data in
 the "deflate" compression format. 
 | 
class  | 
GZIPInputStream
This class implements a stream filter for reading compressed data in
 the GZIP file format. 
 | 
class  | 
GZIPOutputStream
This class implements a stream filter for writing compressed data in
 the GZIP file format. 
 | 
class  | 
InflaterInputStream
This class implements a stream filter for uncompressing data in the
 "deflate" compression format. 
 | 
class  | 
InflaterOutputStream
Implements an output stream filter for uncompressing data stored in the
 "deflate" compression format. 
 | 
class  | 
ZipFile
This class is used to read entries from a zip file. 
 | 
class  | 
ZipInputStream
This class implements an input stream filter for reading files in the
 ZIP file format. 
 | 
class  | 
ZipOutputStream
This class implements an output stream filter for writing files in the
 ZIP file format. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
CipherInputStream
A CipherInputStream is composed of an InputStream and a Cipher so
 that read() methods return data that are read in from the
 underlying InputStream but have been additionally processed by the
 Cipher. 
 | 
class  | 
CipherOutputStream
A CipherOutputStream is composed of an OutputStream and a Cipher so
 that write() methods first process the data before writing them out
 to the underlying OutputStream. 
 | 
| Modifier and Type | Interface and Description | 
|---|---|
interface  | 
ImageInputStream
A seekable input stream interface for use by
  
ImageReaders. | 
interface  | 
ImageOutputStream
A seekable output stream interface for use by
  
ImageWriters. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
FileCacheImageInputStream
An implementation of  
ImageInputStream that gets its
 input from a regular InputStream. | 
class  | 
FileCacheImageOutputStream
An implementation of  
ImageOutputStream that writes its
 output to a regular OutputStream. | 
class  | 
FileImageInputStream
An implementation of  
ImageInputStream that gets its
 input from a File or RandomAccessFile. | 
class  | 
FileImageOutputStream
An implementation of  
ImageOutputStream that writes its
 output directly to a File or
 RandomAccessFile. | 
class  | 
ImageInputStreamImpl
An abstract class implementing the  
ImageInputStream interface. | 
class  | 
ImageOutputStreamImpl
An abstract class implementing the  
ImageOutputStream interface. | 
class  | 
MemoryCacheImageInputStream
An implementation of  
ImageInputStream that gets its
 input from a regular InputStream. | 
class  | 
MemoryCacheImageOutputStream
An implementation of  
ImageOutputStream that writes its
 output to a regular OutputStream. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
MLet
Allows you to instantiate and register one or several MBeans in the MBean server
 coming from a remote URL. 
 | 
class  | 
PrivateMLet
An MLet that is not added to the  
ClassLoaderRepository. | 
| Modifier and Type | Interface and Description | 
|---|---|
interface  | 
JMXConnector
The client end of a JMX API connector. 
 | 
| Modifier and Type | Interface and Description | 
|---|---|
interface  | 
RMIConnection
RMI object used to forward an MBeanServer request from a client
 to its MBeanServer implementation on the server side. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
RMIConnectionImpl
Implementation of the  
RMIConnection interface. | 
class  | 
RMIConnectionImpl_Stub  | 
class  | 
RMIConnector
A connection to a remote RMI connector. 
 | 
class  | 
RMIIIOPServerImpl
An  
RMIServerImpl that is exported through IIOP and that
 creates client connections as RMI objects exported through IIOP. | 
class  | 
RMIJRMPServerImpl
An  
RMIServer object that is exported through JRMP and that
 creates client connections as RMI objects exported through JRMP. | 
class  | 
RMIServerImpl
An RMI object representing a connector server. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
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. | 
class  | 
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. | 
| Modifier and Type | Interface and Description | 
|---|---|
interface  | 
MidiDevice
MidiDevice is the base interface for all MIDI devices. | 
interface  | 
MidiDeviceReceiver
MidiDeviceReceiver is a Receiver which represents
 a MIDI input connector of a MidiDevice
 (see MidiDevice.getReceiver()). | 
interface  | 
MidiDeviceTransmitter
MidiDeviceTransmitter is a Transmitter which represents
 a MIDI input connector of a MidiDevice
 (see MidiDevice.getTransmitter()). | 
interface  | 
Receiver
A  
Receiver receives  objects and
 typically does something useful in response, such as interpreting them to
 generate sound or raw MIDI output. | 
interface  | 
Sequencer
A hardware or software device that plays back a MIDI
  
 is known as a sequencer. | 
interface  | 
Synthesizer
A  
Synthesizer generates sound. | 
interface  | 
Transmitter
 | 
| Modifier and Type | Interface and Description | 
|---|---|
interface  | 
Clip
The  
Clip interface represents a special kind of data line whose
 audio data can be loaded prior to playback, instead of being streamed in
 real time. | 
interface  | 
DataLine
DataLine adds media-related functionality to its
 superinterface, . | 
interface  | 
Line
The  
Line interface represents a mono or multi-channel
 audio feed. | 
interface  | 
Mixer
A mixer is an audio device with one or more lines. 
 | 
interface  | 
Port
Ports are simple lines for input or output of audio to or from audio devices. 
 | 
interface  | 
SourceDataLine
A source data line is a data line to which data may be written. 
 | 
interface  | 
TargetDataLine
A target data line is a type of  
 from which
 audio data can be read. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
AudioInputStream
An audio input stream is an input stream with a specified audio format and
 length. 
 | 
| Modifier and Type | Interface and Description | 
|---|---|
interface  | 
RowSet
The interface that adds support to the JDBC API for the
 JavaBeans™ component model. 
 | 
| Modifier and Type | Interface and Description | 
|---|---|
interface  | 
CachedRowSet
The interface that all standard implementations of
  
CachedRowSet must implement. | 
interface  | 
FilteredRowSet
The standard interface that all standard implementations of
  
FilteredRowSet must implement. | 
interface  | 
JdbcRowSet
The standard interface that all standard implementations of
  
JdbcRowSet must implement. | 
interface  | 
JoinRowSet
The  
JoinRowSet interface provides a mechanism for combining related
 data from different RowSet objects into one JoinRowSet
 object, which represents an SQL JOIN. | 
interface  | 
WebRowSet
The standard interface that all implementations of a  
WebRowSet
 must implement. | 
| Modifier and Type | Interface and Description | 
|---|---|
interface  | 
SyncResolver
Defines a framework that allows applications to use a manual decision tree
 to decide what should be done when a synchronization conflict occurs. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
ProgressMonitorInputStream
Monitors the progress of reading from some InputStream. 
 | 
| Modifier and Type | Interface and Description | 
|---|---|
interface  | 
JavaFileManager
File manager for tools operating on Java™ programming language
 source and class files. 
 | 
interface  | 
StandardJavaFileManager
File manager based on java.io.File. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
ForwardingJavaFileManager<M extends JavaFileManager>
Forwards calls to a given file manager. 
 | 
 Submit a bug or feature 
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
 Copyright © 1993, 2017, Oracle and/or its affiliates.  All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.