Unit 12: I/O Fundamentals & Generics

Opening Hook — Every Aadhaar Record Travels Through Java I/O

Learning Outcomes — Bloom's Taxonomy Mapped (12 Outcomes)

Concept Explanation — I/O Fundamentals & Generics

Part A — Java I/O (Input / Output)

1. Byte Streams — InputStream & OutputStream Hierarchy

Java I/O is built on the concept of streams — an ordered sequence of data. Think of a stream like a water pipe: data flows through it in one direction, byte by byte (or character by character). Byte streams handle raw binary data — images, audio, serialized objects, PDFs.

Java
// Copy a file byte-by-byte using FileInputStream / FileOutputStream
import java.io.*;

public class ByteCopyDemo {
    public static void main(String[] args) {
        try (
            FileInputStream fis = new FileInputStream("input.jpg");
            FileOutputStream fos = new FileOutputStream("output.jpg")
        ) {
            int byteData;
            while ((byteData = fis.read()) != -1) {
                fos.write(byteData);
            }
            System.out.println("File copied successfully!");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2. Character Streams — Reader & Writer Hierarchy

Byte streams handle raw bytes. But text files use characters (Unicode). Reading a Hindi text file with FileInputStream can corrupt characters because it doesn't understand encoding. That's why Java provides character streams — they handle encoding/decoding automatically.

Java
// Reading and writing text files using FileReader / FileWriter
import java.io.*;

public class CharStreamDemo {
    public static void main(String[] args) {
        // Writing to a file
        try (FileWriter fw = new FileWriter("greeting.txt")) {
            fw.write("नमस्ते! Welcome to Java I/O.\n");
            fw.write("This handles Unicode perfectly.\n");
            System.out.println("File written successfully.");
        } catch (IOException e) {
            e.printStackTrace();
        }

        // Reading from a file
        try (FileReader fr = new FileReader("greeting.txt")) {
            int ch;
            while ((ch = fr.read()) != -1) {
                System.out.print((char) ch);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3. Buffered Streams — BufferedReader & BufferedWriter

Analogy: Imagine filling a water tank. You can carry water one glass at a time (unbuffered — 1000 trips), or carry a full bucket each time (buffered — 50 trips). Buffered streams read/write large chunks internally, dramatically reducing disk I/O calls.

BufferedReader wraps a FileReader and provides the essential readLine() method — the most commonly used I/O method in real Java applications.

Java
// Reading a file line-by-line with BufferedReader
import java.io.*;

public class BufferedDemo {
    public static void main(String[] args) {
        // Writing with BufferedWriter
        try (BufferedWriter bw = new BufferedWriter(
                new FileWriter("students.csv"))) {
            bw.write("Name,Roll,CGPA"); bw.newLine();
            bw.write("Arjun Patel,101,8.5"); bw.newLine();
            bw.write("Sneha Iyer,102,9.2"); bw.newLine();
            bw.write("Rahul Verma,103,7.8"); bw.newLine();
        } catch (IOException e) { e.printStackTrace(); }

        // Reading with BufferedReader
        try (BufferedReader br = new BufferedReader(
                new FileReader("students.csv"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) { e.printStackTrace(); }
    }
}

The File Class — Inspect Before You Read

The java.io.File class doesn't read or write — it represents a file path and provides metadata operations:

Java
import java.io.File;

public class FileOps {
    public static void main(String[] args) {
        File f = new File("students.csv");
        System.out.println("Exists: " + f.exists());       // true
        System.out.println("Name: " + f.getName());       // students.csv
        System.out.println("Size: " + f.length() + " bytes");
        System.out.println("Readable: " + f.canRead());  // true
        System.out.println("Writable: " + f.canWrite()); // true
        System.out.println("Path: " + f.getAbsolutePath());

        // Create a directory
        File dir = new File("backup");
        if (dir.mkdir()) System.out.println("Directory created!");

        // List files
        File cwd = new File(".");
        for (String name : cwd.list()) {
            System.out.println("  → " + name);
        }
    }
}

Scanner vs BufferedReader — Which to Use?

4. Serialization & Deserialization

Serialization = converting a Java object into a byte stream (so it can be saved to a file or sent over a network). Deserialization = reverse — byte stream back to a Java object.

Full Code: StudentSerializer

Java
import java.io.*;

// Step 1: Implement Serializable
class Student implements Serializable {
    private static final long serialVersionUID = 1L;
    String name;
    int rollNo;
    double cgpa;
    transient String password; // Will NOT be serialized

    Student(String name, int rollNo, double cgpa, String password) {
        this.name = name;
        this.rollNo = rollNo;
        this.cgpa = cgpa;
        this.password = password;
    }

    public String toString() {
        return "Student{" + name + ", Roll:" + rollNo
             + ", CGPA:" + cgpa + ", Pass:" + password + "}";
    }
}

public class StudentSerializer {
    public static void main(String[] args) {
        Student s1 = new Student("Arjun Patel", 101, 8.5, "secret123");
        Student s2 = new Student("Sneha Iyer", 102, 9.2, "pass456");

        // SERIALIZE — write objects to file
        try (ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream("students.ser"))) {
            oos.writeObject(s1);
            oos.writeObject(s2);
            System.out.println("✅ Students serialized to students.ser");
        } catch (IOException e) { e.printStackTrace(); }

        // DESERIALIZE — read objects back
        try (ObjectInputStream ois = new ObjectInputStream(
                new FileInputStream("students.ser"))) {
            Student d1 = (Student) ois.readObject();
            Student d2 = (Student) ois.readObject();
            System.out.println("📖 Deserialized:");
            System.out.println(d1);
            System.out.println(d2);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

Full Code: CSVFileReader

Java
import java.io.*;

public class CSVFileReader {
    public static void main(String[] args) {
        String csvFile = "students.csv";
        String delimiter = ",";

        System.out.println("╔══════════════════════════════════════════╗");
        System.out.println("║       STUDENT RECORDS FROM CSV           ║");
        System.out.println("╚══════════════════════════════════════════╝");

        try (BufferedReader br = new BufferedReader(
                new FileReader(csvFile))) {
            String header = br.readLine(); // skip header
            System.out.printf("%-20s %-10s %-8s%n",
                "NAME", "ROLL", "CGPA");
            System.out.println("─".repeat(38));

            String line;
            int count = 0;
            while ((line = br.readLine()) != null) {
                String[] parts = line.split(delimiter);
                if (parts.length == 3) {
                    System.out.printf("%-20s %-10s %-8s%n",
                        parts[0], parts[1], parts[2]);
                    count++;
                }
            }
            System.out.println("─".repeat(38));
            System.out.println("Total records: " + count);
        } catch (IOException e) {
            System.err.println("Error reading file: " + e.getMessage());
        }
    }
}

Part B — Java Generics

5. Why Generics? — Type Safety at Compile Time

Before Java 5, collections stored Object types. You could put a String and an Integer in the same ArrayList, and it would only crash at runtime with a ClassCastException. Generics fix this — they catch type errors at compile time.

Java
// WITHOUT generics (Java 4 style) — DANGEROUS
ArrayList list = new ArrayList();
list.add("Hello");
list.add(42);  // No compile error!
String s = (String) list.get(1); // 💥 ClassCastException at RUNTIME!

// WITH generics (Java 5+) — SAFE
ArrayList<String> safeList = new ArrayList<>();
safeList.add("Hello");
// safeList.add(42);  ❌ Compile error! Caught early.
String s2 = safeList.get(0); // No cast needed ✅

Generic Class: Box<T>

Java
class Box<T> {
    private T item;

    public void put(T item) { this.item = item; }
    public T get() { return item; }
    public String toString() { return "Box[" + item + "]"; }
}

// Usage:
Box<String> nameBox = new Box<>();
nameBox.put("Arjun");
String name = nameBox.get(); // No cast needed!

Box<Integer> ageBox = new Box<>();
ageBox.put(22);
int age = ageBox.get(); // Auto-unboxing

Generic Method: <T> T getFirst(T[] arr)

Java
public class GenericMethodDemo {
    // Generic method — works with any array type
    public static <T> T getFirst(T[] arr) {
        if (arr == null || arr.length == 0) return null;
        return arr[0];
    }

    public static void main(String[] args) {
        String[] names = {"Arjun", "Sneha", "Rahul"};
        Integer[] marks = {85, 92, 78};

        System.out.println(getFirst(names));  // Arjun
        System.out.println(getFirst(marks));  // 85
    }
}

Full Code: GenericStack<T>

Java
import java.util.ArrayList;

class GenericStack<T> {
    private ArrayList<T> stack = new ArrayList<>();

    public void push(T item) {
        stack.add(item);
        System.out.println("Pushed: " + item);
    }

    public T pop() {
        if (stack.isEmpty()) throw new RuntimeException("Stack empty!");
        return stack.remove(stack.size() - 1);
    }

    public T peek() {
        if (stack.isEmpty()) throw new RuntimeException("Stack empty!");
        return stack.get(stack.size() - 1);
    }

    public boolean isEmpty() { return stack.isEmpty(); }
    public int size() { return stack.size(); }

    public String toString() { return "Stack" + stack.toString(); }
}

public class StackDemo {
    public static void main(String[] args) {
        GenericStack<String> bookStack = new GenericStack<>();
        bookStack.push("Java: The Complete Reference");
        bookStack.push("Head First Java");
        bookStack.push("Effective Java");

        System.out.println("Top: " + bookStack.peek());
        System.out.println("Popped: " + bookStack.pop());
        System.out.println(bookStack);

        GenericStack<Integer> markStack = new GenericStack<>();
        markStack.push(85);
        markStack.push(92);
        System.out.println("Marks stack: " + markStack);
    }
}

Full Code: GenericPair<K,V>

Java
class GenericPair<K, V> {
    private K key;
    private V value;

    public GenericPair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public K getKey()   { return key; }
    public V getValue() { return value; }

    public String toString() {
        return "(" + key + " → " + value + ")";
    }
}

public class PairDemo {
    public static void main(String[] args) {
        // Roll number → Student name
        GenericPair<Integer, String> p1 =
            new GenericPair<>(101, "Arjun Patel");

        // Subject → Marks
        GenericPair<String, Double> p2 =
            new GenericPair<>("Java", 92.5);

        // Aadhaar → Phone
        GenericPair<String, String> p3 =
            new GenericPair<>("XXXX-XXXX-1234", "+91-98765-43210");

        System.out.println(p1);
        System.out.println(p2);
        System.out.println(p3);
    }
}

6. Bounded Types & Wildcards

Bounded Type: <T extends Comparable<T>>

Sometimes you need to restrict what types can be used. <T extends Comparable<T>> means "T must implement Comparable" — this lets you compare and sort.

Full Code: BoundedSorter

Java
import java.util.Arrays;

class BoundedSorter {
    // Only types that implement Comparable can use this method
    public static <T extends Comparable<T>> T findMax(T[] arr) {
        T max = arr[0];
        for (T item : arr) {
            if (item.compareTo(max) > 0) {
                max = item;
            }
        }
        return max;
    }

    public static <T extends Comparable<T>> void bubbleSort(T[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (arr[j].compareTo(arr[j+1]) > 0) {
                    T temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        Integer[] marks = {78, 92, 85, 64, 97};
        System.out.println("Max mark: " + findMax(marks));
        bubbleSort(marks);
        System.out.println("Sorted: " + Arrays.toString(marks));

        String[] cities = {"Mumbai", "Ahmedabad", "Chennai", "Delhi"};
        System.out.println("Max city: " + findMax(cities));
        bubbleSort(cities);
        System.out.println("Sorted: " + Arrays.toString(cities));
    }
}

Wildcards: ?, ? extends T, ? super T (PECS Rule)

Java
import java.util.*;

public class WildcardDemo {
    // Producer Extends — reads from the list
    public static double sumOfList(List<? extends Number> list) {
        double sum = 0;
        for (Number n : list) {
            sum += n.doubleValue();
        }
        return sum;
    }

    // Consumer Super — writes to the list
    public static void addIntegers(List<? super Integer> list) {
        list.add(10);
        list.add(20);
        list.add(30);
    }

    public static void main(String[] args) {
        List<Integer> intList = Arrays.asList(10, 20, 30);
        List<Double> dblList = Arrays.asList(1.5, 2.5, 3.5);

        System.out.println("Int sum: " + sumOfList(intList));  // 60.0
        System.out.println("Dbl sum: " + sumOfList(dblList));  // 7.5

        List<Number> numList = new ArrayList<>();
        addIntegers(numList); // Works — Number is super of Integer
        System.out.println("Numbers: " + numList); // [10, 20, 30]
    }
}

Diamond Operator <> — Type Inference

Since Java 7, you don't need to repeat the type on the right side:

Java
// Before Java 7:
Map<String, List<Integer>> map = new HashMap<String, List<Integer>>();

// Java 7+ with diamond operator:
Map<String, List<Integer>> map = new HashMap<>(); // Compiler infers types ✅

Learn by Doing — 3-Tier Lab: Student Record File Serializer

Problem Set — Syntax, Programming, Industry & Interview

Syntax Questions (5)

1. Write the syntax to create a FileReader object that reads from "data.txt".
2. Write the syntax for declaring a generic class Container with type parameter T.
3. Write the statement to serialize an object emp using ObjectOutputStream oos.
4. Write the syntax for a bounded generic method that accepts only Comparable types.
5. Write a try-with-resources statement that creates a BufferedReader wrapping a FileReader.

Programming Problems (8)

1. File Word Counter: Write a program that reads a text file using BufferedReader and counts the total number of words, lines, and characters.
2. File Copy Utility: Write a program that copies a text file from source to destination using BufferedReader and BufferedWriter. Display byte count after copy.
3. Student Serializer: Create a Student class with 5 fields (one transient). Serialize an array of 5 students to a file, then deserialize and display them.
4. CSV Parser: Read a CSV file containing employee records (Name, Dept, Salary). Parse each line, calculate total salary, and write a summary report to a new file.
5. Generic Stack: Implement a GenericStack<T> with push, pop, peek, isEmpty, size, and display. Test with String and Integer types.
6. Generic Pair: Implement a GenericPair<K,V> class. Write a method that accepts an array of pairs and returns the pair with the maximum value (V must extend Comparable).
7. Bounded Sorter: Write a generic method sort(T[] arr) where T extends Comparable<T>. Use insertion sort. Test with Integer[] and String[].
8. File-Based Phone Book: Build a phone book that saves contacts to a file using serialization. Support: add, search, delete, display all, save, load.

Industry-Level Problems (3)

1. Log File Analyzer: Given a server log file (timestamp, level, message), read it using BufferedReader, count ERROR vs WARN vs INFO entries, and write a summary report. Use GenericPair<String, Integer> to store level-count pairs.
2. Config File Reader: Build a generic config reader that reads key=value pairs from a .properties file and stores them in a Map<String, String>. Support type-safe getters: getInt(key), getString(key), getBoolean(key).
3. Data Pipeline: Read student records from CSV → validate (remove invalid rows) → serialize valid records → deserialize and generate a marks report → write report to a text file. Use generics for the validation step.

Interview Questions (3)

1. TCS/Infosys: "What is the difference between Serializable and Externalizable? When would you use each?" Write a comparison with code examples.
2. Amazon/Flipkart: "Explain the PECS rule with a real-world example. Why can't you add elements to a List<? extends Number>?" Provide code that demonstrates the compiler error.
3. Wipro/HCL: "What is type erasure in Java generics? What are its limitations? Can you create a generic array? Why or why not?"

MCQ Assessment Bank — 30 Questions (Bloom's Mapped)

Remember / Identify (Q1–Q6)

Understand / Explain (Q7–Q12)

Apply / Implement (Q13–Q18)

Analyze / Compare (Q19–Q24)

Evaluate / Create (Q25–Q30)

Short Answer Questions (8)

Long Answer Questions (3)

Java
// Byte stream example: copying an image file
try (FileInputStream fis = new FileInputStream("photo.jpg");
     FileOutputStream fos = new FileOutputStream("backup.jpg")) {
    byte[] buffer = new byte[4096];
    int bytesRead;
    while ((bytesRead = fis.read(buffer)) != -1) {
        fos.write(buffer, 0, bytesRead);
    }
}

Java
// Character stream example: reading a text file
try (BufferedReader br = new BufferedReader(new FileReader("notes.txt"))) {
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
}

Java
import java.io.*;

class Employee implements Serializable {
    private static final long serialVersionUID = 2L;
    String name;
    int empId;
    double salary;
    transient String sessionToken;

    Employee(String name, int empId, double salary, String token) {
        this.name = name; this.empId = empId;
        this.salary = salary; this.sessionToken = token;
    }

    public String toString() {
        return name + " | ID:" + empId + " | ₹" + salary
             + " | Token:" + sessionToken;
    }
}

public class SerializationDemo {
    public static void main(String[] args) throws Exception {
        Employee e = new Employee("Priya", 1001, 85000, "abc-xyz-123");

        // Serialize
        ObjectOutputStream oos = new ObjectOutputStream(
            new FileOutputStream("emp.ser"));
        oos.writeObject(e);
        oos.close();

        // Deserialize
        ObjectInputStream ois = new ObjectInputStream(
            new FileInputStream("emp.ser"));
        Employee d = (Employee) ois.readObject();
        ois.close();

        System.out.println(d);
        // Output: Priya | ID:1001 | ₹85000.0 | Token:null
    }
}

Java
class Container<T> {
    private T data;
    public void set(T data) { this.data = data; }
    public T get() { return data; }
}

Java
public static <T> void printArray(T[] arr) {
    for (T item : arr) System.out.print(item + " ");
}

Java
import java.util.*;

class SortedList<T extends Comparable<T>> {
    private List<T> items = new ArrayList<>();

    public void add(T item) {
        items.add(item);
        Collections.sort(items);
    }

    public T getMin() { return items.get(0); }
    public T getMax() { return items.get(items.size()-1); }
    public String toString() { return items.toString(); }
}

// Works with Integer, String, or any Comparable type!
SortedList<Integer> marks = new SortedList<>();
marks.add(78); marks.add(92); marks.add(65);
System.out.println(marks); // [65, 78, 92]

Lab Program 10 — Java I/O: Console & File Operations

Java
import java.io.*;
import java.util.Scanner;

public class Lab10_JavaIO {

    // ── PART 1: Console Input with Scanner ──
    public static void consoleWithScanner() {
        Scanner sc = new Scanner(System.in);
        System.out.println("═══ PART 1: Console Input (Scanner) ═══");

        System.out.print("Enter your name: ");
        String name = sc.nextLine();

        System.out.print("Enter your age: ");
        int age = sc.nextInt();

        System.out.print("Enter your CGPA: ");
        double cgpa = sc.nextDouble();

        System.out.println("\n📋 Scanner Output:");
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
        System.out.println("CGPA: " + cgpa);
        sc.close();
    }

    // ── PART 2: Console Input with BufferedReader ──
    public static void consoleWithBufferedReader() throws IOException {
        BufferedReader br = new BufferedReader(
            new InputStreamReader(System.in));
        System.out.println("\n═══ PART 2: Console Input (BufferedReader) ═══");

        System.out.print("Enter city name: ");
        String city = br.readLine();

        System.out.print("Enter pincode: ");
        int pin = Integer.parseInt(br.readLine());

        System.out.println("\n📋 BufferedReader Output:");
        System.out.println("City: " + city + ", PIN: " + pin);
    }

    // ── PART 3: File Write with FileWriter ──
    public static void writeWithFileWriter() throws IOException {
        System.out.println("\n═══ PART 3: Writing with FileWriter ═══");
        FileWriter fw = new FileWriter("lab10_output.txt");
        fw.write("Line 1: Welcome to Java I/O Lab.\n");
        fw.write("Line 2: FileWriter writes character by character.\n");
        fw.write("Line 3: नमस्ते — Unicode works!\n");
        fw.close();
        System.out.println("✅ Written to lab10_output.txt using FileWriter.");
    }

    // ── PART 4: File Read with FileReader ──
    public static void readWithFileReader() throws IOException {
        System.out.println("\n═══ PART 4: Reading with FileReader ═══");
        FileReader fr = new FileReader("lab10_output.txt");
        int ch;
        while ((ch = fr.read()) != -1) {
            System.out.print((char) ch);
        }
        fr.close();
    }

    // ── PART 5: File Write with BufferedWriter ──
    public static void writeWithBufferedWriter() throws IOException {
        System.out.println("\n═══ PART 5: Writing with BufferedWriter ═══");
        try (BufferedWriter bw = new BufferedWriter(
                new FileWriter("lab10_students.csv"))) {
            bw.write("Name,Roll,CGPA,City"); bw.newLine();
            bw.write("Arjun Patel,101,8.5,Ahmedabad"); bw.newLine();
            bw.write("Sneha Iyer,102,9.2,Chennai"); bw.newLine();
            bw.write("Rahul Verma,103,7.8,Lucknow"); bw.newLine();
            bw.write("Priya Sharma,104,8.9,Delhi"); bw.newLine();
            bw.write("Kiran Das,105,7.2,Kolkata"); bw.newLine();
        }
        System.out.println("✅ Written to lab10_students.csv using BufferedWriter.");
    }

    // ── PART 6: File Read with BufferedReader ──
    public static void readWithBufferedReader() throws IOException {
        System.out.println("\n═══ PART 6: Reading CSV with BufferedReader ═══");
        try (BufferedReader br = new BufferedReader(
                new FileReader("lab10_students.csv"))) {
            String header = br.readLine();
            System.out.printf("%-18s %-8s %-8s %-12s%n",
                "NAME", "ROLL", "CGPA", "CITY");
            System.out.println("━".repeat(46));

            String line;
            int count = 0;
            double totalCgpa = 0;
            while ((line = br.readLine()) != null) {
                String[] parts = line.split(",");
                if (parts.length == 4) {
                    System.out.printf("%-18s %-8s %-8s %-12s%n",
                        parts[0], parts[1], parts[2], parts[3]);
                    totalCgpa += Double.parseDouble(parts[2]);
                    count++;
                }
            }
            System.out.println("━".repeat(46));
            System.out.printf("Total: %d students | Avg CGPA: %.2f%n",
                count, totalCgpa / count);
        }
    }

    // ── MAIN METHOD ──
    public static void main(String[] args) throws IOException {
        System.out.println("╔══════════════════════════════════════════════╗");
        System.out.println("║      LAB 10 — JAVA I/O OPERATIONS           ║");
        System.out.println("╚══════════════════════════════════════════════╝\n");

        // Uncomment to test console input:
        // consoleWithScanner();
        // consoleWithBufferedReader();

        // File operations (no console input needed):
        writeWithFileWriter();
        readWithFileReader();
        writeWithBufferedWriter();
        readWithBufferedReader();

        System.out.println("\n🎉 Lab 10 complete!");
    }
}

Industry Spotlight — A Day in the Life

Earn With It — File Automation Scripts ₹5K–₹15K/month

⏱️ Time to First Earning: 2–4 weeks (complete the lab programs + build one real project + create Fiverr/Internshala profile)

Chapter Summary

Checkpoint — Self-Assessment

✅ Unit 12 complete. MCQs: 30. Lab 10 covered. Ready for Unit 13!

[QR: Link to EduArtha video tutorial — Java I/O Fundamentals & Generics]