feat: implement reading student data using DataInputStream

WHAT:
- Added `PrintInputStreamExample` to demonstrate deserialization of primitive data types using `DataInputStream`.
- Reads a `Student1` object’s fields in the same order they were written with `DataOutputStream`.

HOW:
- Used `FileInputStream` wrapped with `DataInputStream` for reading binary data.
- Read fields sequentially:
  - `rollno` (int)
  - `name` (UTF string)
  - `dept` (UTF string)
  - `avg` (float)
- Printed the values to verify correctness.

WHY:
- Ensures consistent reading of binary data across different runs.
- Demonstrates importance of maintaining the same read/write order during serialization.

REAL-WORLD APPLICATIONS:
- Storing and retrieving structured records (students, employees, transactions) in lightweight systems.
- Useful for applications where performance and storage efficiency are prioritized over human readability.
- Can serve as a foundation for building simple binary-based data persistence layers.

NOTES:
- The file `Student2.txt` must have been written using `DataOutputStream` with the same field order.
- Misalignment in read/write order can cause corrupted or invalid data reads.
- Unlike object serialization (`ObjectOutputStream`), this approach works only with primitive types and strings.

NEXT IMPROVEMENTS:
- Add error handling for `EOFException` to gracefully detect end-of-file.
- Wrap streams in `try-with-resources` for automatic closing.
- Extend program to handle arrays or lists of `Student1` records.

Signed-off-by: https://github.com/Someshdiwan <[email protected]>

Author: Someshdiwan

Section23JavaIOStreams/Serialisation Storing Data in a File/src/PrintInputStreamExample.java

@@ -1,24 +1,55 @@
 import java.io.*;
 
-class PrintInputStreamExample {
+public class PrintInputStreamExample {
     public static void main(String[] args) throws Exception {
-        FileInputStream fis = new FileInputStream("C:\\Users\\somes\\Downloads\\JAVA SE\\Section23JavaIOStreams\\Serialisation Storing Data in a File\\MyJAVA\\Student1.txt");
-        BufferedReader br = new BufferedReader(new InputStreamReader(fis));
+        FileInputStream fis = new FileInputStream("/Users/somesh/Java SE/JavaEvolution-Learning-Growing-Mastering/Section23JavaIOStreams/src/MyJAVA/Student2.txt");
+        DataInputStream dis = new DataInputStream(fis);
 
-        // Creating a Student object
-        Student s = new Student();
+        // Read binary data in the correct order.
+        Student1 s = new Student1();
+        s.rollno = dis.readInt();
+        s.name = dis.readUTF();
+        s.dept = dis.readUTF();
+        s.avg = dis.readFloat();
 
-        // Reading data from file
-        s.rollno = Integer.parseInt(br.readLine()); // Reading roll number
-        s.name = br.readLine(); // Reading name
-        s.dept = br.readLine(); // Reading department
-
-        // Printing Student details
         System.out.println("Roll No: " + s.rollno);
         System.out.println("Name: " + s.name);
         System.out.println("Dept: " + s.dept);
+        System.out.println("Average: " + s.avg);
 
-        // Closing the reader
-        br.close();
+        dis.close();
+        fis.close();
     }
-}
+}
+
+/*
+1. DataInputStream:
+   - Binary data ko read karne ke liye use hota hai (not plain text).
+   - Must read in the same order jisme write kiya tha (DataOutputStream se).
+
+2. Student1 object fields
+   - `s.rollno = dis.readInt();`
+   - `s.name = dis.readUTF();`
+   - `s.dept = dis.readUTF();`
+   - `s.avg = dis.readFloat();`
+   Agar order change karoge to `EOFException` ya corrupted data milega.
+
+3. Streams ka use
+   - `FileInputStream` → raw bytes read karta hai.
+   - `DataInputStream` → high-level methods deta hai (readInt, readUTF, readFloat).
+
+4. Close order
+   - Always `dis.close();` phir `fis.close();` (ya try-with-resources use karna best hai).
+
+5. Serialization vs Data Streams
+   - Yaha tumne `DataInputStream` use kiya hai → manually field by field write & read karna hota hai.
+   - Agar tum `ObjectInputStream` use karte ho → pura object ek shot me read/write ho sakta hai
+(provided class implements Serializable).
+
+- Agar tumne `DataOutputStream` se likha hai:
+  ```java
+  dos.writeInt(rollno);
+  dos.writeUTF(name);
+  dos.writeUTF(dept);
+  dos.writeFloat(avg);
+*/