Java - File I/O

 File I/O in Java

Java File I/O (Input/Output) is one of the most important concepts in Java programming, especially for developers who deal with reading, writing, creating, deleting, and managing files and directories. File I/O forms a core part of backend development, desktop applications, server-side applications, and real-world data-processing systems. Java provides a rich set of classes under the java.io and java.nio packages, allowing developers to perform file handling in an efficient, secure, and platform-independent way. This document covers all essential Java File I/O concepts, examples, explanations, and outputs to help students, developers, and interview candidates master this topic comprehensively.

Introduction to Java File I/O

Java File I/O refers to the process of handling files and streams to perform data input and output operations. Input means receiving data from a source, such as reading from a file, while output refers to sending data to a destination, such as writing to a file. Java uses a stream-based approach for File I/O, meaning data flows in a continuous sequence of bytes or characters. Java provides many classes like FileInputStream, FileOutputStream, FileReader, FileWriter, BufferedReader, BufferedWriter, and modern alternatives like Files and Paths from the NIO package. This section explains how Java processes data, how streams work, and why buffered input/output improves performance. Mastering File I/O helps developers handle logging, data persistence, configuration files, and data communication between applications. File I/O is also frequently asked in Java interviews, making this knowledge essential.

Understanding Java Streams

In Java, a stream represents a flow of data between a program and an external source like a file. Java provides two major types of streams: byte streams and character streams. Byte streams are used for handling binary data such as images, audio files, and executable files, while character streams are used for textual data like text files, logs, and configuration files. Streams follow a unidirectional flow, meaning data moves either from a source to a program (input) or from a program to a destination (output). Streams simplify complex file operations by providing methods for reading, writing, closing, and buffering data. Java also supports buffered streams to improve speed by reducing the number of disk access operations. Understanding streams is critical for building scalable and high-performance applications that rely on File I/O operations.

Working with the File Class

The java.io.File class is one of the foundational classes for file handling in Java. It represents both files and directories in the system and provides methods for checking existence, creating new files, deleting files, reading file properties, and listing directory contents. The File class does not deal with reading and writing file data; instead, it serves as a reference to the file system. Developers often use this class to validate file paths, create directories, check permissions, and manage overall file metadata. Understanding the File class is essential because most I/O operations begin by identifying a file using this class. Even though modern Java introduced the NIO package, File is still widely used in many applications for performing basic file management tasks easily and reliably.

Example: Creating and Checking a File

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

public class FileCreationExample {
    public static void main(String[] args) {
        File file = new File("sample.txt");
        try {
            if (file.createNewFile()) {
                System.out.println("File Created Successfully");
            } else {
                System.out.println("File Already Exists");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Output:
File Created Successfully (or) File Already Exists

Reading Files Using FileInputStream

FileInputStream is a byte-based stream used to read binary data from files. It reads one byte at a time or an array of bytes. This makes it suitable for handling binary files such as PDFs, images, videos, and serialized objects. FileInputStream provides methods like read(), read(byte[]), and close(). It is often combined with BufferedInputStream for faster performance. Although not ideal for text files, FileInputStream is a powerful tool when dealing with raw data streams. It is also frequently used in network programming, data compression, and custom serialization mechanisms. The following example demonstrates reading file content byte by byte and converting it into characters for display.

Example: Reading a File Using FileInputStream

import java.io.FileInputStream;

public class FileInputStreamExample {
    public static void main(String[] args) {
        try {
            FileInputStream fis = new FileInputStream("sample.txt");
            int byteData;
            while ((byteData = fis.read()) != -1) {
                System.out.print((char) byteData);
            }
            fis.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Output:
(Displays the content of sample.txt)

Writing Files Using FileOutputStream

FileOutputStream is used to write byte data into files. This class is helpful for creating binary files or writing raw data into files. Developers commonly use FileOutputStream for exporting images, audio, or binary logs. It supports methods like write(int), write(byte[]), and close(). One key thing to remember is that FileOutputStream overwrites a file unless used in append mode. It is also useful for writing byte arrays that represent text after appropriate encoding. Combining FileOutputStream with BufferedOutputStream improves performance for large data outputs. The example shows how to write text into a file using FileOutputStream in a simple and effective way.

Example: Writing Data Using FileOutputStream

import java.io.FileOutputStream;

public class FileOutputStreamExample {
    public static void main(String[] args) {
        try {
            FileOutputStream fos = new FileOutputStream("output.txt");
            String data = "Java FileOutputStream Example";
            fos.write(data.getBytes());
            fos.close();
            System.out.println("Data Written Successfully");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Output:
Data Written Successfully

Reading Files Using FileReader

FileReader is a character-based stream used for reading text data efficiently. Unlike FileInputStream, it reads characters instead of bytes, making it ideal for reading files containing only textual information. FileReader supports methods like read(), read(char[]), and close(). Since it handles 16-bit Unicode characters, it provides better accuracy for multilingual text. FileReader is often used when building applications that process log files, text files, JSON files, XML configuration files, and script files. The example below demonstrates how FileReader reads characters and prints them to the console. It is also a good alternative to Scanner when reading simple text files without tokenizing.

Example: Reading a File Using FileReader

import java.io.FileReader;

public class FileReaderExample {
    public static void main(String[] args) {
        try {
            FileReader fr = new FileReader("sample.txt");
            int charData;
            while ((charData = fr.read()) != -1) {
                System.out.print((char) charData);
            }
            fr.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Output:
(Displays text content from sample.txt)

Writing Files Using FileWriter

FileWriter is a character-based stream used to write textual data into files. It writes characters instead of raw bytes, making it suitable for Unicode text handling. FileWriter supports writing single characters, arrays of characters, and entire strings. Developers use FileWriter to generate text files, logs, configuration files, and formatted documents. Using FileWriter in append mode allows adding data without overwriting existing content. FileWriter is often paired with BufferedWriter for improved writing performance. The example below demonstrates writing a string to a file using FileWriter in a simple and efficient way.

Example: Writing Data Using FileWriter

import java.io.FileWriter;

public class FileWriterExample {
    public static void main(String[] args) {
        try {
            FileWriter fw = new FileWriter("writer_output.txt");
            fw.write("Java FileWriter Example");
            fw.close();
            System.out.println("Data Written Successfully");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Output:
Data Written Successfully

BufferedReader and BufferedWriter

BufferedReader and BufferedWriter are high-performance classes used for reading and writing text efficiently. They use buffering techniques to reduce the number of I/O operations by storing data temporarily in memory. BufferedReader provides methods like read(), readLine(), and ready(), while BufferedWriter supports write(), newLine(), and flush(). These classes offer faster processing speed for large files and are preferred for real-world applications involving text parsing and file processing. BufferedReader is commonly used for reading log files, CSV files, and long text documents. BufferedWriter is ideal for writing formatted reports or large text blocks with better performance than FileWriter alone.

Example: Using BufferedReader and BufferedWriter

import java.io.*;

public class BufferedExample {
    public static void main(String[] args) {
        try {
            BufferedWriter bw = new BufferedWriter(new FileWriter("buffered.txt"));
            bw.write("Buffered Writing Example");
            bw.newLine();
            bw.write("Java BufferedWriter Demo");
            bw.close();

            BufferedReader br = new BufferedReader(new FileReader("buffered.txt"));
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
            br.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Output:
Buffered Writing Example
Java BufferedWriter Demo

Using Scanner for File Reading

The Scanner class is a convenient tool for reading text files, especially when you need token-based input. Scanner reads data line by line, word by word, or token by token. It supports parsing of integers, floating numbers, and strings. Developers commonly use Scanner when processing structured text data like CSV files, space-separated values, or user-generated data files. Scanner provides flexibility with delimiters and parsing methods like next(), nextLine(), nextInt(), and nextDouble(). However, Scanner is slower than BufferedReader for large files, so it is typically used for small to medium-sized textual data processing.

Example: Reading File Using Scanner

import java.io.File;
import java.util.Scanner;

public class ScannerFileExample {
    public static void main(String[] args) {
        try {
            Scanner sc = new Scanner(new File("sample.txt"));
            while (sc.hasNextLine()) {
                System.out.println(sc.nextLine());
            }
            sc.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Output:
(Prints each line of sample.txt)

File Operations Using Java NIO (Files & Paths)

Java NIO (New I/O), introduced in Java 7, provides modern, efficient, and more powerful ways to handle file operations. The Files and Paths classes replace many older file-handling techniques, offering methods for reading, writing, copying, moving, and deleting files. NIO supports improved error handling, better performance, and platform-independent path management. It simplifies operations like reading all lines at once, writing complete strings, and checking file types. NIO also offers advanced features like symbolic links, file permissions, and atomic operations, making it ideal for enterprise-level Java applications.

Example: Using Files and Paths

import java.nio.file.*;

public class NIOExample {
    public static void main(String[] args) {
        try {
            Path path = Paths.get("nio_file.txt");
            Files.write(path, "NIO File Writing Example".getBytes());
            
            String content = Files.readString(path);
            System.out.println(content);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Output:
NIO File Writing Example

Java File I/O is an essential part of Java programming and forms a core component of real-world applications. Whether you are reading user data, generating logs, processing large text documents, or managing binary files, Java provides a rich set of classes and APIs through both the java.io and java.nio packages. Understanding character streams, byte streams, buffering, Scanner, File class, FileReader, FileWriter, FileInputStream, FileOutputStream, and NIO utilities makes you a stronger and more efficient Java developer. These concepts also hold great importance in technical interviews, project development, and enterprise-level Java applications.