Java File I/O: Byte Streams, Character Streams & the File Class

Input/Output (I/O) in Java allows your application to interact with external sources: files on disk, network sockets, keyboard inputs, and printer streams. In Java, all data transport is modeled through Streams — an ordered sequence of data flowing from a producer (source) to a consumer (destination).

The Stream Hierarchy in java.io

Java divides I/O streams into two fundamentally distinct hierarchies based on data granularity:

1. The java.io.File Class

The File class represents an abstract pathname of a file or directory on the file system. It does not read or write data inside the file; it inspects and manages file metadata (existence, length, permissions, deletion, directory creation).

import java.io.File;
import java.io.IOException;

public class FileDemo {
    public static void main(String[] args) {
        File file = new File("veewom-notes.txt");
        
        try {
            if (file.createNewFile()) {
                System.out.println("File created: " + file.getName());
            } else {
                System.out.println("File already exists on disk.");
            }
            
            System.out.println("Absolute Path: " + file.getAbsolutePath());
            System.out.println("Can Read: " + file.canRead());
            System.out.println("Can Write: " + file.canWrite());
            System.out.println("File Size (bytes): " + file.length());
            System.out.println("Is Directory: " + file.isDirectory());
        } catch (IOException e) {
            System.err.println("I/O Error: " + e.getMessage());
        }
    }
}

2. Byte Streams: FileInputStream & FileOutputStream

Byte streams read and write raw 8-bit bytes. Use byte streams whenever you transfer non-text binary assets (e.g., JPEG images, ZIP archives) or need raw binary compatibility.

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamCopy {
    public static void main(String[] args) {
        // Copying an image byte-by-byte with try-with-resources
        try (FileInputStream in = new FileInputStream("input.png");
             FileOutputStream out = new FileOutputStream("copy.png")) {
            
            byte[] buffer = new byte[4096]; // 4 KB chunk buffer
            int bytesRead;
            
            while ((bytesRead = in.read(buffer)) != -1) {
                out.write(buffer, 0, bytesRead);
            }
            System.out.println("Binary file copied successfully!");
        } catch (IOException e) {
            System.err.println("File copy failed: " + e.getMessage());
        }
    }
}

3. Character Streams: FileReader & FileWriter

Character streams read and write 16-bit Unicode characters. In modern Java (Java 11+), you can explicitly specify the StandardCharsets.UTF_8 encoding to avoid platform-dependent encoding bugs (e.g., Windows CP-1252 vs Linux UTF-8).

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class CharStreamDemo {
    public static void main(String[] args) {
        String data = "Welcome to Veewom Java Tutorials!\nLearn Java 21 LTS.";
        
        // Writing text using FileWriter
        try (FileWriter writer = new FileWriter("greeting.txt", StandardCharsets.UTF_8)) {
            writer.write(data);
            System.out.println("Data successfully written to greeting.txt");
        } catch (IOException e) {
            e.printStackTrace();
        }

        // Reading text using FileReader
        try (FileReader reader = new FileReader("greeting.txt", StandardCharsets.UTF_8)) {
            int ch;
            while ((ch = reader.read()) != -1) {
                System.out.print((char) ch); // cast int to character
            }
            System.out.println();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Dry-Run & Memory Execution Trace