Java FileInputStream

One byte, then a chunk

The one-argument form of the idea is read(). It returns the next byte as an int, or -1 at the end of the file. Teaching code looks like this. A large file should not be read this way, because each call does a small amount of work for a single byte.

try (FileInputStream input = new FileInputStream("data.bin")) {
    int value;
    while ((value = input.read()) != -1) {
        // value is 0 through 255
    }
}

The working form reads into an array. The return value is a count, and the last successful read is often a partial read. Process chunk[0] through chunk[count - 1], then loop.

byte[] chunk = new byte[8192];
try (FileInputStream input = new FileInputStream("data.bin")) {
    int count;
    while ((count = input.read(chunk)) != -1) {
        consume(chunk, count);
    }
}

Text is a layer on top

When the bytes are UTF-8 text, wrap the stream. InputStreamReader decodes. BufferedReader then fills a character buffer so readLine() can run from memory. The charset belongs on the reader that touches the bytes.

try (BufferedReader reader = new BufferedReader(
        new InputStreamReader(new FileInputStream("notes.txt"), StandardCharsets.UTF_8))) {
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
}

readLine() returns null at the end. That null is the character-stream end, the partner of -1 on the byte stream. An empty line is an empty string, because the line ending was there and the line had no characters.

The same buffer that makes reading cheap can hide a failure on the way out. This page only reads, so the file position moves as bytes arrive. The matching writer page is where a BufferedWriter accepts characters, returns, and throws only when flush or close pushes them. If you later write a copy through a buffered writer, a short write can look done while the new file is still unchanged.

Who closes the file

try-with-resources is the close. The variable declared in the parentheses is closed when the block ends. In the text example the variable is the BufferedReader. Its close() closes the InputStreamReader, which closes the FileInputStream, which releases the descriptor.

You opened the stack, so you close it. A helper that receives an already-open InputStream should read and return, and leave the close to the caller, unless the method's contract says it takes ownership. Closing a wrapper you built around a borrowed stream closes the caller's file too.