All Classes and Interfaces
Class
Description
This is the base class for implementing an output stream in which the data
 is written into a byte array.
Constructor for an InputStream subclass.
A filter reader that filters out characters where subclasses decide which characters to filter out.
Abstracts the implementation of the 
FileFilter (IO), FilenameFilter (IO), PathFilter (NIO)
 interfaces via our own IOFileFilter interface.Abstracts some InputStream operations for implementations in this package.
Abstracts the origin of data for builders like a 
File, Path, Reader, Writer, InputStream, OutputStream, and
 URI.A 
RandomAccessFile origin.A 
byte[] origin.A 
CharSequence origin.A 
File origin.An 
InputStream origin.A 
IORandomAccessFile origin.An 
OutputStream origin.A 
Path origin.A 
RandomAccessFile origin.A 
Reader origin.A 
URI origin.A 
Writer origin.Abstracts building an instance of 
T.Abstracts building a typed instance of 
T.Abstracts supplying an instance of 
T.Accumulates normalized paths during visitation.
Builds instances of 
AccumulatorPathVisitor.Filters files based on a cutoff time, can filter either newer files or files equal to or older.
A 
FileFilter providing conditional AND logic across a list of
 file filters.OutputStream implementation that writes the data to an 
Appendable
 Object.Writer implementation that writes the data to an 
Appendable
 Object.Proxy stream that closes and discards the underlying stream as soon as the end of input has been reached or when the stream is explicitly closed.
Builds a new 
AutoCloseInputStream instance.This class is used to wrap a stream that includes an encoded 
ByteOrderMark as its first bytes.Builds a new 
BOMInputStream.Reads bytes up to a maximum count and stops once reached.
Builds a new 
BoundedInputStream.A reader that imposes a limit to the number of characters that can be read from an underlying reader, returning EOF
 when this limit is reached, regardless of state of underlying reader.
Always throws an exception from all 
InputStream methods where IOException is declared.Always throws an exception from all 
OutputStream methods where IOException is declared.Always throws an exception from all 
Reader methods where IOException is declared.Always throws an exception from all 
Writer methods where IOException is declared.InputStream implementation which uses direct buffer to read a file to avoid extra copy of data between Java and native memory which happens when
 using BufferedInputStream.Builds a new 
BufferedFileChannelInputStream.Implements a ThreadSafe version of 
AbstractByteArrayOutputStream using instance synchronization.Manufactures 
ByteBuffer instances.Byte Order Mark (BOM) representation.
Converts Strings to 
ByteOrder instances.This filter accepts 
Files that can be executed.This filter accepts 
Files that can be read.This filter accepts 
Files that can be written to.A filter reader that filters out a given character represented as an 
int code point, handy to remove
 known junk characters from CSV files for example.A filter reader that removes a given set of characters represented as 
int code points, handy to remove known
 junk characters from CSV files for example.Implements an 
InputStream to read bytes from String, StringBuffer, StringBuilder or CharBuffer,
 encoded using the specified Charset.Builds a new 
CharSequenceInputStream.Reader implementation that can read from String, StringBuffer,
 StringBuilder or CharBuffer.Works with 
CharsetDecoder.Works with 
CharsetEncoder.Charsets required of every implementation of the Java platform.
Automatically verifies a 
Checksum value once the stream is exhausted or the count threshold is reached.Builds a new 
ChecksumInputStream.OutputStream which breaks larger output blocks into chunks.
Builds a new 
UnsynchronizedByteArrayOutputStream.Writer which breaks larger output blocks into chunks.
Implements a buffered input stream, which is internally based on a 
CircularByteBuffer.A buffer, which doesn't need reallocation of byte arrays, because it
 reuses a single byte array.
An 
InputStream that repeats provided bytes for given target byte count.A special ObjectInputStream that loads a class based on a specified
 
ClassLoader rather than the system default.An object that matches a Class name to a condition.
Deletes files but not directories as a visit proceeds.
Always returns 
IOUtils.EOF to all attempts to read something from an input stream.Throws an IOException on all attempts to write to the stream.
Always returns 
IOUtils.EOF to all attempts to read something from it.Throws an IOException on all attempts to write with 
ClosedWriter.close() implemented as a noop.Proxy stream that prevents the underlying input stream from being closed.
Proxy stream that prevents the underlying output stream from being closed.
Proxy reader that prevents the underlying reader from being closed.
Proxy writer that prevents the underlying writer from being closed.
Compare two files using a set of delegate file 
Comparator.Defines operations for conditional file filters.
Copies a source directory to a target directory.
Deprecated.
Use IOUtils.
Provides counters for files, directories, and sizes, as a visit proceeds.
Counts using a number.
Counts files, directories, and sizes, as a visit proceeds.
Deprecated.
Use 
BoundedInputStream (unbounded by default).A decorating output stream that counts the number of bytes that have passed
 through.
Counts files, directories, and sizes, as a visit proceeds.
Builds instances of 
CountingPathVisitor.Builds instances of 
CountingPathVisitor.Compares two files using the default 
File.compareTo(File) method.An output stream which will retain data in memory until a specified threshold is reached, and only then commit it to disk.
Builds a new 
DeferredFileOutputStream.This class turns a Java FileFilter or FilenameFilter into an IO FileFilter.
An object that configures how to delete a file.
Deletes files and directories as a visit proceeds.
Data written to this stream is forwarded to a stream that has been associated with this thread.
Forwards data to a stream that has been associated with this thread.
Compare two files using the 
File.isDirectory() method.This filter accepts 
Files that are directories.A 
DirectoryStream.Filter that delegates to a PathFilter.Deprecated.
Apache Commons IO no longer uses this class.
CancelException is thrown in DirectoryWalker to cancel the current
 processing.
This filter accepts files or directories that are empty.
Helps with reading and writing primitive numeric types (
short,
 int, long, float, and double) that are
 encoded in little endian using two's complement or unsigned representations.Erases 
IOException for the compiler but still throws that exception at runtime.Compare the file name extensions for order
 (see 
FilenameUtils.getExtension(String)).A file filter that always returns false.
Receives events of file system modifications.
Convenience 
FileAlterationListener implementation that does nothing.A runnable that spawns a monitoring thread triggering any
 registered 
FileAlterationObserver at a specified interval.FileAlterationObserver represents the state of files below a root directory, checking the file system and notifying listeners of create, change or delete
 events.
Builds instances of 
FileAlterationObserver.Works with 
FileChannel.Deprecated.
Keeps track of files awaiting deletion, and deletes them when an associated
 marker object is reclaimed by the garbage collector.
Strategy for deleting files.
The state of a file or directory, capturing the following 
File attributes at a point in time.Accepts only an exact 
File object match.Indicates that a file already exists.
This filter accepts 
Files that are files (not directories).Useful utilities for working with file filters.
General file name and file path manipulation utilities.
Abstracts an OS' file system details, currently supporting the single use case of converting a file name String to a
 legal file name with 
FileSystem.toLegalFileName(String, char).Helps to work with 
FileSystemProvider.Deprecated.
As of 2.6 deprecated without replacement.
Helps use 
FileTime and interoperate Date and NTFS times.General file manipulation utilities.
Writer of files that allows the encoding to be set.
Builds a new 
FileWriterWithEncoding.Abstract class for writing filtered character streams to a 
Collection of writers.Dumps data in hexadecimal format.
This filter accepts 
Files that are hidden.An 
InputStream that infinitely repeats the provided bytes.Like 
BaseStream but throws IOException.Like 
BiConsumer but throws IOException.Like 
BiFunction but throws IOException.Like 
BinaryOperator but throws IOException.Like 
BooleanSupplier but throws IOException.Enumeration of IO case sensitivity.
Like 
Comparator but throws IOException.Like 
Consumer but throws IOException.An IOException based on a list of Throwable causes.
Deprecated.
(since 2.5) use 
IOException insteadAn interface which brings the 
FileFilter, FilenameFilter, PathFilter, and PathMatcher interfaces together.Like 
Function but throws IOException.A IOException associated with a source index.
Like 
IntConsumer but throws IOException.Like 
IntSupplier but throws IOException.Like 
Iterable but throws IOException.Like 
Iterator but throws IOException.Like 
LongSupplier but throws IOException.Like 
Predicate but throws IOException.Represents a function that accepts four arguments and produces a result.
Like 
Runnable but throws IOException.Like 
Spliterator but throws IOException.Like 
Stream but throws IOException.Like 
Supplier but throws IOException.Like 
BiConsumer but throws IOException.Represents a function that accepts three arguments and produces a result.
Like 
UnaryOperator but throws IOException.General IO stream manipulation utilities.
Compare the last modified date/time of two files for order
 (see 
FileUtils.lastModifiedUnchecked(File)).An Iterator over the lines in a 
Reader.FileWriter that will create and honor lock files to allow simple cross thread file lock handling.
Builds a new 
LockableFileWriter.
 File filter for matching files containing a "magic number".
This is an alternative to 
ByteArrayInputStream
 which removes the synchronization overhead for non-concurrent
 access; as such this class is not thread-safe.An 
InputStream that utilizes memory mapped files to improve performance.Builds a new 
MemoryMappedFileInputStream.Deprecated.
Builds a new 
MessageDigestCalculatingInputStream.Maintains the message digest.
This class is an example for using an 
ObservableInputStream.Builds new 
MessageDigestInputStream.Maintains the message digest.
Compare the names of two files for order (see 
File.getName()).Filters file names for a certain name.
A noop path visitor.
This filter produces a logical NOT of the filters specified.
Appends all data to the famous /dev/null.
A lightweight 
InputStream that emulates a stream of a specified size.Never writes data.
Never prints data.
A functional, lightweight 
Reader that emulates
 a reader of a specified size.Never writes data.
A predicate (boolean-valued function) of one argument to accept and reject classes.
The 
ObservableInputStream allows, that an InputStream may be consumed by other receivers, apart from the
 thread, which is reading it.For subclassing builders from 
BoundedInputStream subclassses.Builds instances of 
ObservableInputStream.Abstracts observer callback for 
ObservableInputStreams.A 
FileFilter providing conditional OR logic across a list of file filters.Accepts only an exact 
Path object match.Compare the path of two files for order (see 
File.getPath()).A filter for 
Paths.Delegates matching to a 
PathMatcher.NIO Path utilities.
A 
FileVisitor typed to a Path.A file filter backed by a path visitor.
Implements a buffered input stream, which allows to peek into the buffers first bytes.
Filters file names for a certain prefix.
A Proxy stream collection which acts as expected, that is it passes the method calls on to the proxied streams and
 doesn't change which methods are being called.
A proxy stream which acts as a 
FilterInputStream, by passing all method calls on to the proxied stream, not changing which methods are called.Abstracts builder properties for subclasses.
A Proxy stream which acts as expected, that is it passes the method
 calls on to the proxied stream and doesn't change which methods are
 being called.
Builds instances of 
ProxyOutputStream.A Proxy stream which acts as expected, that is it passes the method
 calls on to the proxied stream and doesn't change which methods are
 being called.
A Proxy stream which acts as expected, that is it passes the method calls on to the proxied stream and doesn't
 change which methods are being called.
Simple alternative to JDK 
PipedInputStream; queue input stream provides what's written in queue output stream.Builds a new 
QueueInputStream.Simple alternative to JDK 
PipedOutputStream; queue input stream provides what's written in queue
 output stream.Streams data from a 
RandomAccessFile starting at its current position.Builds a new 
RandomAccessFileInputStream.Enumerates access modes for 
RandomAccessFile with factory methods.An 
OutputStream that writes to a RandomAccessFile.Builds a new 
RandomAccessFileOutputStream.Works with 
RandomAccessFile.Implements 
InputStream to asynchronously read ahead from an underlying input stream when a specified amount of data has been read from the current
 buffer.Builds a new 
ReadAheadInputStream.InputStream implementation that reads a character stream from a Reader and transforms it to a byte stream using a specified charset encoding.Builds a new 
ReaderInputStream.Filters files using supplied regular expression(s).
Reads lines in a file reversely (similar to a BufferedReader, but starting at the last line).
Builds a new 
ReversedLinesFileReader.Provides the contents of multiple 
Readers in sequence.A 
SimpleFileVisitor typed to a Path.Abstracts builder for subclasses.
Compare the length/size of two files for order (see
 
File.length() and FileUtils.sizeOfDirectory(File)).Filters files based on size, can filter either smaller files or
 files equal to or larger than a given threshold.
Defines the standard delete options.
Enumerates standard line separators: 
StandardLineSeparator.CR, StandardLineSeparator.CRLF, StandardLineSeparator.LF.Wraps and presents a 
Stream as a AutoCloseable Iterator resource that automatically closes itself when reaching the end of stream.Writer implementation that outputs to a StringBuilder.Filters files based on the suffix (what the file name ends with).
DataInput for systems relying on little-endian data formats.
This filter accepts 
Files that are symbolic links.An input stream decorator that tags potential exceptions so that the
 stream that caused the exception can easily be identified.
An 
IOException decorator that adds a serializable tag to the
 wrapped exception.An output stream decorator that tags potential exceptions so that the
 stream that caused the exception can easily be identified.
A reader decorator that tags potential exceptions so that the reader that caused the exception can easily be
 identified.
A writer decorator that tags potential exceptions so that the
 reader that caused the exception can easily be identified.
Simple implementation of the Unix "tail -f" functionality.
Builds a new 
Tailer.Bridges access to a resource for random access, normally a file.
A tailable resource like a file.
Listens to events from a 
Tailer.TailerListener Adapter.InputStream proxy that transparently writes a copy of all bytes read
 from the proxied stream to a given OutputStream.
Classic splitter of 
OutputStream.Reader proxy that transparently writes a copy of all characters read from the proxied reader to a given Reader.
Classic splitter of 
Writer.Helps work with threads.
An output stream which triggers an event on the first write that causes
 the total number of bytes written to the stream to exceed a configured threshold,
 and every subsequent write.
Provides bandwidth throttling on an InputStream as a filter input stream.
Builds a new 
ThrottledInputStream.An observer with timestamps.
A file filter that always returns true.
Unchecks calls by throwing 
UncheckedIOException instead of IOException.Builds a new 
UncheckedBufferedReader.Builds a new 
UncheckedFilterInputStream.Builds a new 
UncheckedFilterOutputStream.Builds a new 
UncheckedFilterReader.Builds a new 
UncheckedFilterWriter.A filtering input stream that ensures the content will have UNIX-style line endings, LF.
An unsynchronized version of 
BufferedInputStream, not thread-safe.Builds a new 
UnsynchronizedBufferedInputStream.Wraps an existing 
Reader and buffers the input without any synchronization.This is an alternative to 
ByteArrayInputStream which removes the synchronization overhead for non-concurrent access; as such this class is
 not thread-safe.Builds a new 
UnsynchronizedByteArrayInputStream.Implements a version of 
AbstractByteArrayOutputStream without any concurrent thread safety.Builds a new 
UnsynchronizedByteArrayOutputStream.An unsynchronized version of 
FilterInputStream, not thread-safe.Builds a new 
UnsynchronizedFilterInputStream.A 
Reader without any of the superclass' synchronization.An 
ObjectInputStream that's restricted to deserialize a limited set of classes.Builds a new 
ValidatingObjectInputStream.Filters files using the supplied wildcards.
Builds a new 
WildcardFileFilter instance.Deprecated.
Use WildcardFileFilter.
A filtering input stream that ensures the content will have Windows line endings, CRLF.
OutputStream implementation that transforms a byte stream to a character stream using a specified charset encoding and writes the resulting stream to
 a Writer.Builds a new 
WriterOutputStream.Character stream that handles all the necessary Voodoo to figure out the charset encoding of the XML document within the stream.
Builds a new 
XmlStreamWriter.The XmlStreamReaderException is thrown by the XmlStreamReader constructors if
 the charset encoding cannot be determined according to the XML 1.0
 specification and RFC 3023.
Character stream that handles all the necessary work to figure out the charset encoding of the XML document written to the stream.
Builds a new 
XmlStreamWriter.