• File Handling is used to create, read, write, and manage data in files.
• Java provides java.io classes like File, streams, buffered classes, and object streams.
• Common file flow: File (path/info) + Stream (read/write data).

1) File Class Usage (java.io.File)

• File represents a file/folder path (does not read/write by itself).
• Common methods: exists(), createNewFile(), mkdir(), delete(), length(), getName(), getPath(), listFiles()

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

class FileClassDemo {
    public static void main(String[] args) {
        try {
            File f = new File("notes.txt");

            System.out.println("Name: " + f.getName());
            System.out.println("Path: " + f.getPath());
            System.out.println("Exists: " + f.exists());

            if (!f.exists()) {
                boolean created = f.createNewFile();
                System.out.println("Created: " + created);
            }

            System.out.println("Size (bytes): " + f.length());
        } catch (IOException e) {
            System.out.println("File error: " + e.getMessage());
        }
    }
}

2) Streams Basics (Byte vs Character Streams)

• Stream is a flow of data.
• Byte Streams: read/write bytes (images, pdf, audio) using InputStream/OutputStream.
• Character Streams: read/write text using Reader/Writer.

3) Writing Text File (FileWriter)

• FileWriter writes characters to a file.
• Use true to append mode.

import java.io.FileWriter;
import java.io.IOException;

class FileWriteDemo {
    public static void main(String[] args) {
        try (FileWriter fw = new FileWriter("notes.txt", true)) {
            fw.write("Java File Handling Notes\n");
            fw.write("Name: Sourav\n");
            System.out.println("Write completed!");
        } catch (IOException e) {
            System.out.println("Write error: " + e.getMessage());
        }
    }
}

4) Reading Text File (FileReader)

• FileReader reads characters from a text file.

import java.io.FileReader;
import java.io.IOException;

class FileReadDemo {
    public static void main(String[] args) {
        try (FileReader fr = new FileReader("notes.txt")) {
            int ch;
            while ((ch = fr.read()) != -1) {
                System.out.print((char) ch);
            }
        } catch (IOException e) {
            System.out.println("Read error: " + e.getMessage());
        }
    }
}

5) BufferedReader and BufferedWriter (Fast Text I/O)

• BufferedReader reads text efficiently (supports readLine()).
• BufferedWriter writes text efficiently (supports newLine()).

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

class BufferedIO {
    public static void main(String[] args) {

        // Write using BufferedWriter
        try (BufferedWriter bw = new BufferedWriter(new FileWriter("data.txt"))) {
            bw.write("Student: Sourav");
            bw.newLine();
            bw.write("Course: Java");
            bw.newLine();
            bw.write("Marks: 88");
            System.out.println("Buffered write done!");
        } catch (IOException e) {
            System.out.println("Write error: " + e.getMessage());
        }

        // Read using BufferedReader
        try (BufferedReader br = new BufferedReader(new FileReader("data.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            System.out.println("Read error: " + e.getMessage());
        }
    }
}

6) Byte Streams (FileInputStream & FileOutputStream)

• Used for binary files (images, pdf) or raw bytes.
• FileInputStream reads bytes, FileOutputStream writes bytes.

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

class ByteStreamDemo {
    public static void main(String[] args) {
        try (FileOutputStream out = new FileOutputStream("raw.bin")) {
            out.write(65); // ASCII of A
            out.write(66); // B
            out.write(67); // C
            System.out.println("Bytes written!");
        } catch (IOException e) {
            System.out.println("Write error: " + e.getMessage());
        }

        try (FileInputStream in = new FileInputStream("raw.bin")) {
            int b;
            while ((b = in.read()) != -1) {
                System.out.print((char) b);
            }
        } catch (IOException e) {
            System.out.println("Read error: " + e.getMessage());
        }
    }
}

7) Serialization (Object to File)

• Serialization converts an object into a byte stream to save it in a file.
• Class must implement Serializable.
• Use ObjectOutputStream to write object.
• Use transient to skip a field during serialization (not saved).

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

class User implements Serializable {
    int id;
    String name;
    transient String password; // not saved in file

    User(int id, String name, String password) {
        this.id = id;
        this.name = name;
        this.password = password;
    }
}

class SerializeDemo {
    public static void main(String[] args) {
        try (ObjectOutputStream oos =
                     new ObjectOutputStream(new FileOutputStream("user.ser"))) {

            User u = new User(1, "Sourav", "1234");
            oos.writeObject(u);
            System.out.println("Object serialized!");
        } catch (Exception e) {
            System.out.println("Serialization error: " + e.getMessage());
        }
    }
}

8) Deserialization (File to Object)

• Deserialization converts saved byte stream back into an object.
• Use ObjectInputStream to read object.

import java.io.FileInputStream;
import java.io.ObjectInputStream;

class DeserializeDemo {
    public static void main(String[] args) {
        try (ObjectInputStream ois =
                     new ObjectInputStream(new FileInputStream("user.ser"))) {

            User u = (User) ois.readObject();
            System.out.println("ID: " + u.id);
            System.out.println("Name: " + u.name);
            System.out.println("Password: " + u.password); // null (transient)
        } catch (Exception e) {
            System.out.println("Deserialization error: " + e.getMessage());
        }
    }
}

9) Quick Notes

• Use try-with-resources to auto-close streams.
• Buffered classes improve performance for text I/O.
• Use Reader/Writer for text, InputStream/OutputStream for binary.
• Serialization is used for saving object state (e.g., session-like data).