## Uses of Interface
java.lang.AutoCloseable

Packages that use AutoCloseable
com.sun.nio.sctp: A Java API for Stream Control Transport Protocol.
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.lang.module: Classes to support module descriptors and creating configurations of modules by means of resolution and service binding.
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 Java™ programming language.
java.util: Contains the collections framework, some internationalization support classes, a service loader, properties, random number generation, string parsing and scanning classes, base64 encoding and decoding, a bit array, and several miscellaneous utility classes.
java.util.concurrent: Utility classes commonly useful in concurrent programming.
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 Java™ 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.
jdk.jfr: This package provides classes to create events and control Flight Recorder.
jdk.jfr.consumer: This package contains classes for consuming Flight Recorder data.
jdk.jshell: Provides interfaces for creating tools, such as a Read-Eval-Print Loop (REPL), which interactively evaluate "snippets" of Java programming language code.
jdk.jshell.execution: Provides implementation support for building JShell execution engines.
jdk.jshell.spi: Defines the Service Provider Interface for pluggable JShell execution engines.
jdk.nashorn.api.scripting: This package provides the `javax.script` integration, which is the preferred way to use Nashorn.

### Uses of AutoCloseable in com.sun.nio.sctp

Classes in com.sun.nio.sctp that implement AutoCloseable
`class` `SctpChannel` A selectable channel for message-oriented connected SCTP sockets.
`class` `SctpMultiChannel` A selectable channel for message-oriented SCTP sockets.
`class` `SctpServerChannel` A selectable channel for message-oriented listening SCTP sockets.

### Uses of AutoCloseable in java.beans

Classes in java.beans that implement AutoCloseable
`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.

### Uses of AutoCloseable in java.io

Subinterfaces of AutoCloseable in java.io
`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.

Classes in java.io that implement AutoCloseable
`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` Reads text from character files using a default buffer size.
`class` `FileWriter` Writes text to character files using a default buffer size.
`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.
`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" bytes, by storing pushed-back bytes in an internal buffer.
`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.
`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.

### Uses of AutoCloseable in java.lang.module

Subinterfaces of AutoCloseable in java.lang.module
`interface` `ModuleReader` Provides access to the content of a module.

### Uses of AutoCloseable in java.net

Classes in java.net that implement AutoCloseable
`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.

### Uses of AutoCloseable in java.nio.channels

Subinterfaces of AutoCloseable in java.nio.channels
`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.

Classes in java.nio.channels that implement AutoCloseable
`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.

### Uses of AutoCloseable in java.nio.channels.spi

Classes in java.nio.channels.spi that implement AutoCloseable
`class` `AbstractInterruptibleChannel` Base implementation class for interruptible channels.
`class` `AbstractSelectableChannel` Base implementation class for selectable channels.
`class` `AbstractSelector` Base implementation class for selectors.

### Uses of AutoCloseable in java.nio.file

Subinterfaces of AutoCloseable in java.nio.file
`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.

Classes in java.nio.file that implement AutoCloseable
`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.

### Uses of AutoCloseable in java.rmi.server

Classes in java.rmi.server that implement AutoCloseable
`class` `LogStream` Deprecated. no replacement

### Uses of AutoCloseable in java.security

Classes in java.security that implement AutoCloseable
`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.

### Uses of AutoCloseable in java.sql

Subinterfaces of AutoCloseable in java.sql
`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.

### Uses of AutoCloseable in java.util

Classes in java.util that implement AutoCloseable
`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.

### Uses of AutoCloseable in java.util.concurrent

Classes in java.util.concurrent that implement AutoCloseable
`class` `SubmissionPublisher<T>` A `Flow.Publisher` that asynchronously issues submitted (non-null) items to current subscribers until it is closed.

### Uses of AutoCloseable in java.util.jar

Classes in java.util.jar that implement AutoCloseable
`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.

### Uses of AutoCloseable in java.util.stream

Subinterfaces of AutoCloseable in java.util.stream
`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.

### Uses of AutoCloseable in java.util.zip

Classes in java.util.zip that implement AutoCloseable
`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.

### Uses of AutoCloseable in javax.crypto

Classes in javax.crypto that implement AutoCloseable
`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.

### Uses of AutoCloseable in javax.imageio.stream

Subinterfaces of AutoCloseable in javax.imageio.stream
`interface` `ImageInputStream` A seekable input stream interface for use by `ImageReader`s.
`interface` `ImageOutputStream` A seekable output stream interface for use by `ImageWriter`s.

Classes in javax.imageio.stream that implement AutoCloseable
`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`.

### Uses of AutoCloseable in javax.management.loading

Classes in javax.management.loading that implement AutoCloseable
`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`.

### Uses of AutoCloseable in javax.management.remote

Subinterfaces of AutoCloseable in javax.management.remote
`interface` `JMXConnector` The client end of a JMX API connector.

### Uses of AutoCloseable in javax.management.remote.rmi

Subinterfaces of AutoCloseable in javax.management.remote.rmi
`interface` `RMIConnection` RMI object used to forward an MBeanServer request from a client to its MBeanServer implementation on the server side.

Classes in javax.management.remote.rmi that implement AutoCloseable
`class` `RMIConnectionImpl` Implementation of the `RMIConnection` interface.
`class` `RMIConnectionImpl_Stub`
`class` `RMIConnector` A connection to a remote RMI connector.
`class` `RMIIIOPServerImpl` Deprecated. This transport is no longer supported.
`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.

### Uses of AutoCloseable in javax.net.ssl

Classes in javax.net.ssl that implement AutoCloseable
`class` `SSLServerSocket` This class extends `ServerSocket` 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 `Socket` and provides secure sockets using protocols such as the "Secure Sockets Layer" (SSL) or IETF "Transport Layer Security" (TLS) protocols.

### Uses of AutoCloseable in javax.sound.midi

Subinterfaces of AutoCloseable in javax.sound.midi
`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 `MidiEvent` 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 `sequence` is known as a sequencer.
`interface` `Synthesizer` A `Synthesizer` generates sound.
`interface` `Transmitter` A `Transmitter` sends `MidiEvent` objects to one or more `Receivers`.

### Uses of AutoCloseable in javax.sound.sampled

Subinterfaces of AutoCloseable in javax.sound.sampled
`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, `Line`.
`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 `DataLine` from which audio data can be read.

Classes in javax.sound.sampled that implement AutoCloseable
`class` `AudioInputStream` An audio input stream is an input stream with a specified audio format and length.

### Uses of AutoCloseable in javax.sql

Subinterfaces of AutoCloseable in javax.sql
`interface` `RowSet` The interface that adds support to the JDBC API for the JavaBeans™ component model.

### Uses of AutoCloseable in javax.sql.rowset

Subinterfaces of AutoCloseable in javax.sql.rowset
`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.

### Uses of AutoCloseable in javax.sql.rowset.spi

Subinterfaces of AutoCloseable in javax.sql.rowset.spi
`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.

### Uses of AutoCloseable in javax.swing

Classes in javax.swing that implement AutoCloseable
`class` `ProgressMonitorInputStream` Monitors the progress of reading from some InputStream.

### Uses of AutoCloseable in javax.tools

Subinterfaces of AutoCloseable in javax.tools
`interface` `JavaFileManager` File manager for tools operating on Java™ programming language source and class files.
`interface` `StandardJavaFileManager` File manager based on java.io.File and java.nio.file.Path.

Classes in javax.tools that implement AutoCloseable
`class` `ForwardingJavaFileManager<M extends JavaFileManager>` Forwards calls to a given file manager.

### Uses of AutoCloseable in jdk.jfr

Classes in jdk.jfr that implement AutoCloseable
`class` `Recording` Provides means to configure, start, stop and dump recording data to disk.

### Uses of AutoCloseable in jdk.jfr.consumer

Classes in jdk.jfr.consumer that implement AutoCloseable
`class` `RecordingFile` A recording file.

### Uses of AutoCloseable in jdk.jshell

Classes in jdk.jshell that implement AutoCloseable
`class` `JShell` The JShell evaluation state engine.

### Uses of AutoCloseable in jdk.jshell.execution

Classes in jdk.jshell.execution that implement AutoCloseable
`class` `DirectExecutionControl` An `ExecutionControl` implementation that runs in the current process.
`class` `JdiDefaultExecutionControl` The implementation of `ExecutionControl` that the JShell-core uses by default.
`class` `JdiExecutionControl` Abstract JDI implementation of `ExecutionControl`.
`class` `LocalExecutionControl` An implementation of `ExecutionControl` which executes in the same JVM as the JShell-core.
`class` `RemoteExecutionControl` The remote agent runs in the execution process (separate from the main JShell process).
`class` `StreamingExecutionControl` An implementation of the `ExecutionControl` execution engine SPI which streams requests to a remote agent where execution takes place.

### Uses of AutoCloseable in jdk.jshell.spi

Subinterfaces of AutoCloseable in jdk.jshell.spi
`interface` `ExecutionControl` This interface specifies the functionality that must provided to implement a pluggable JShell execution engine.

### Uses of AutoCloseable in jdk.nashorn.api.scripting

Classes in jdk.nashorn.api.scripting that implement AutoCloseable
`class` `URLReader` Deprecated, for removal: This API element is subject to removal in a future version. Nashorn JavaScript script engine and APIs, and the jjs tool are deprecated with the intent to remove them in a future release.