# Uses of Interface
java.lang.AutoCloseable

Packages that use AutoCloseable
Package
Description
com.sun.net.httpserver
Provides a simple high-level Http server API, which can be used to build embedded HTTP servers.
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.foreign
Provides low-level access to memory and functions outside the Java runtime.
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.incubator.concurrent
Defines non-final APIs for concurrent programming.
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.management.jfr
This package contains classes to control and monitor Flight Recorder over Java Management Extensions (JMX).

- ## Uses of AutoCloseable in com.sun.net.httpserver

  Classes in com.sun.net.httpserver that implement AutoCloseable
  Modifier and Type
  Class
  Description
  `class`
  `HttpExchange`
  This class encapsulates a HTTP request received and a response to be generated in one exchange.
  `class`
  `HttpsExchange`
  This class encapsulates a HTTPS request received and a response to be generated in one exchange and defines the extensions to `HttpExchange` that are specific to the HTTPS protocol.

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

  Classes in com.sun.nio.sctp that implement AutoCloseable
  Modifier and Type
  Class
  Description
  `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
  Modifier and Type
  Class
  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.

- ## Uses of AutoCloseable in java.io

  Subinterfaces of AutoCloseable in java.io
  Modifier and Type
  Interface
  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.
  Classes in java.io that implement AutoCloseable
  Modifier and Type
  Class
  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 a 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` wraps 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.foreign

  Subinterfaces of AutoCloseable in java.lang.foreign
  Modifier and Type
  Interface
  Description
  `interface`
  `ArenaPREVIEW`
  Preview.
  An arena controls the lifecycle of memory segments, providing both flexible allocation and timely deallocation.

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

  Subinterfaces of AutoCloseable in java.lang.module
  Modifier and Type
  Interface
  Description
  `interface`
  `ModuleReader`
  Provides access to the content of a module.

- ## Uses of AutoCloseable in java.net

  Classes in java.net that implement AutoCloseable
  Modifier and Type
  Class
  Description
  `class`
  `DatagramSocket`
  This class represents a socket for sending and receiving datagram packets.
  `class`
  `MulticastSocket`
  A `MulticastSocket` is a datagram socket that is convenient for sending and receiving IP multicast datagrams.
  `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
  Modifier and Type
  Interface
  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.
  Classes in java.nio.channels that implement AutoCloseable
  Modifier and Type
  Class
  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.

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

  Classes in java.nio.channels.spi that implement AutoCloseable
  Modifier and Type
  Class
  Description
  `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
  Modifier and Type
  Interface
  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.
  Classes in java.nio.file that implement AutoCloseable
  Modifier and Type
  Class
  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.

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

  Classes in java.rmi.server that implement AutoCloseable
  Modifier and Type
  Class
  Description
  `class`
  `LogStream`
  Deprecated.
  no replacement

- ## Uses of AutoCloseable in java.security

  Classes in java.security that implement AutoCloseable
  Modifier and Type
  Class
  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.

- ## Uses of AutoCloseable in java.sql

  Subinterfaces of AutoCloseable in java.sql
  Modifier and Type
  Interface
  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.

- ## Uses of AutoCloseable in java.util

  Classes in java.util that implement AutoCloseable
  Modifier and Type
  Class
  Description
  `final class`
  `Formatter`
  An interpreter for printf-style format strings.
  `final class`
  `Scanner`
  A simple text scanner which can parse primitive types and strings using regular expressions.

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

  Subinterfaces of AutoCloseable in java.util.concurrent
  Modifier and Type
  Interface
  Description
  `interface`
  `ExecutorService`
  An `Executor` that provides methods to manage termination and methods that can produce a `Future` for tracking progress of one or more asynchronous tasks.
  `interface`
  `ScheduledExecutorService`
  An `ExecutorService` that can schedule commands to run after a given delay, or to execute periodically.
  Classes in java.util.concurrent that implement AutoCloseable
  Modifier and Type
  Class
  Description
  `class`
  `AbstractExecutorService`
  Provides default implementations of `ExecutorService` execution methods.
  `class`
  `ForkJoinPool`
  An `ExecutorService` for running `ForkJoinTask`s.
  `class`
  `ScheduledThreadPoolExecutor`
  A `ThreadPoolExecutor` that can additionally schedule commands to run after a given delay, or to execute periodically.
  `class`
  `SubmissionPublisher<T>`
  A `Flow.Publisher` that asynchronously issues submitted (non-null) items to current subscribers until it is closed.
  `class`
  `ThreadPoolExecutor`
  An `ExecutorService` that executes each submitted task using one of possibly several pooled threads, normally configured using `Executors` factory methods.

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

  Classes in java.util.jar that implement AutoCloseable
  Modifier and Type
  Class
  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, which extends `ZipInputStream`, is used to read the contents of a JAR file from an 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
  Modifier and Type
  Interface
  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.

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

  Classes in java.util.zip that implement AutoCloseable
  Modifier and Type
  Class
  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`
  An input stream for reading compressed and uncompressed ZIP file entries from a stream of bytes 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
  Modifier and Type
  Class
  Description
  `class`
  `CipherInputStream`
  A `CipherInputStream` is composed of an `InputStream` and a `Cipher` object so that read() methods return data that are read in from the underlying `InputStream` but have been additionally processed by the `Cipher` object.
  `class`
  `CipherOutputStream`
  A `CipherOutputStream` is composed of an `OutputStream` and a `Cipher` object 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
  Modifier and Type
  Interface
  Description
  `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
  Modifier and Type
  Class
  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`.

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

  Classes in javax.management.loading that implement AutoCloseable
  Modifier and Type
  Class
  Description
  `class`
  `MLet`
  Deprecated, for removal: This API element is subject to removal in a future version.
  This API is part of Management Applets (m-lets), which is a legacy feature that allows loading of remote MBeans.
  `class`
  `PrivateMLet`
  Deprecated, for removal: This API element is subject to removal in a future version.
  This API is part of Management Applets (m-lets), which is a legacy feature that allows loading of remote MBeans.

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

  Subinterfaces of AutoCloseable in javax.management.remote
  Modifier and Type
  Interface
  Description
  `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
  Modifier and Type
  Interface
  Description
  `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
  Modifier and Type
  Class
  Description
  `class`
  `RMIConnectionImpl`
  Implementation of the `RMIConnection` interface.
  `final class`
  `RMIConnectionImpl_Stub`
  RMIConnectionImpl remote 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
  Modifier and Type
  Class
  Description
  `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
  Modifier and Type
  Interface
  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 `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
  Modifier and Type
  Interface
  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, `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
  Modifier and Type
  Class
  Description
  `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
  Modifier and Type
  Interface
  Description
  `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
  Modifier and Type
  Interface
  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.

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

  Subinterfaces of AutoCloseable in javax.sql.rowset.spi
  Modifier and Type
  Interface
  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.

- ## Uses of AutoCloseable in javax.swing

  Classes in javax.swing that implement AutoCloseable
  Modifier and Type
  Class
  Description
  `class`
  `ProgressMonitorInputStream`
  Monitors the progress of reading from some InputStream.

- ## Uses of AutoCloseable in javax.tools

  Subinterfaces of AutoCloseable in javax.tools
  Modifier and Type
  Interface
  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` and `java.nio.file.Path`.
  Classes in javax.tools that implement AutoCloseable
  Modifier and Type
  Class
  Description
  `class`
  `ForwardingJavaFileManager<M extends JavaFileManager>`
  Forwards calls to a given file manager.

- ## Uses of AutoCloseable in jdk.incubator.concurrent

  Classes in jdk.incubator.concurrent that implement AutoCloseable
  Modifier and Type
  Class
  Description
  `class`
  `StructuredTaskScope<T>`
  A basic API for structured concurrency.
  `static final class`
  `StructuredTaskScope.ShutdownOnFailure`
  A `StructuredTaskScope` that captures the exception of the first subtask to complete abnormally.
  `static final class`
  `StructuredTaskScope.ShutdownOnSuccess<T>`
  A `StructuredTaskScope` that captures the result of the first subtask to complete successfully.

- ## Uses of AutoCloseable in jdk.jfr

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

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

  Subinterfaces of AutoCloseable in jdk.jfr.consumer
  Modifier and Type
  Interface
  Description
  `interface`
  `EventStream`
  Represents a stream of events.
  Classes in jdk.jfr.consumer that implement AutoCloseable
  Modifier and Type
  Class
  Description
  `final class`
  `RecordingFile`
  A recording file.
  `final class`
  `RecordingStream`
  A recording stream produces events from the current JVM (Java Virtual Machine).

- ## Uses of AutoCloseable in jdk.jshell

  Classes in jdk.jshell that implement AutoCloseable
  Modifier and Type
  Class
  Description
  `class`
  `JShell`
  The JShell evaluation state engine.

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

  Classes in jdk.jshell.execution that implement AutoCloseable
  Modifier and Type
  Class
  Description
  `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
  Modifier and Type
  Interface
  Description
  `interface`
  `ExecutionControl`
  This interface specifies the functionality that must provided to implement a pluggable JShell execution engine.

- ## Uses of AutoCloseable in jdk.management.jfr

  Classes in jdk.management.jfr that implement AutoCloseable
  Modifier and Type
  Class
  Description
  `final class`
  `RemoteRecordingStream`
  An implementation of an `EventStream` that can serialize events over the network using an `MBeanServerConnection`.