feat: implement DataOutputStreamsExample22 for writing student data in binary format

WHAT:
- Added `DataOutputStreamsExample22` class to demonstrate serialization using `DataOutputStream`.
- Writes a student's details (roll number, name, department, average marks) into a binary file `Student2.txt`.

HOW:
- Used try-with-resources to safely handle `FileOutputStream` and `DataOutputStream`.
- Serialized fields in the following order:
  1. `writeInt(rollno)`
  2. `writeUTF(name)`
  3. `writeUTF(dept)`
  4. `writeFloat(avg)`
- Ensures the same order must be followed during deserialization.

WHY:
- Demonstrates **low-level manual serialization** of Java primitives and Strings.
- Provides a platform-independent binary representation of structured data.
- Shows safe resource management using Java’s try-with-resources.

REAL-WORLD APPLICATIONS:
- Storing student records, employee details, or configuration data in a lightweight binary format.
- Used in games and simulations for saving state efficiently.
- Provides a base for building custom serialization frameworks.
- Faster and more compact than plain text storage.

BENEFITS:
- Auto-closing of streams avoids memory/resource leaks.
- Compact binary format ensures efficiency in storage and retrieval.
- Maintains data integrity across JVMs and platforms.

NEXT IMPROVEMENTS:
- Add a matching `DataInputStreamsExample22` to deserialize and read back student data.
- Wrap serialization logic into reusable methods (e.g., `writeStudent(Student student)`).
- Consider using `Serializable` interface for more scalable object persistence.

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

Author: Someshdiwan

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

@@ -0,0 +1,75 @@
+import java.io.*;
+
+public class DataOutputStreamsExample22 {
+    public static void main(String[] args) {
+        String filePath = "/Users/somesh/Java SE/JavaEvolution-Learning-Growing-Mastering/Section23JavaIOStreams/src/MyJAVA/Student2.txt";
+
+        try (FileOutputStream fos = new FileOutputStream(filePath);
+             DataOutputStream dos = new DataOutputStream(fos))
+        {
+            int rollno = 101;
+            String name = "Somesh Diwan";
+            String dept = "Computer Science";
+            float avg = 87.5f;
+
+            // Serialisation: using DataInput and DataOutput Streams.
+            dos.writeInt(rollno);
+            dos.writeUTF(name);
+            dos.writeUTF(dept);
+            dos.writeFloat(avg);
+
+            System.out.println("Data written successfully.");
+
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+}
+
+/*
+1. DataInputStream:
+   - Ye stream primitive data types (int, float, double, char, UTF strings, etc.)
+     ko directly read/write karne ke liye hota hai.
+   - File se data ko ek particular "binary format" me read karta hai.
+   - Isko hamesha usi order me read karna padta hai jis order me DataOutputStream ne likha tha.
+
+2. Code Explanation:
+   - `FileInputStream fis = new FileInputStream("path")`
+     → File ko open karta hai.
+   - `DataInputStream dis = new DataInputStream(fis)`
+     → Primitive data types ko directly read karne ka wrapper stream.
+
+3. Object `Student1`:
+   - Ek custom class jisme rollno, name, dept, avg fields hain.
+   - Yahan tum binary file me saved student data ko read kar rahe ho.
+
+4. Read karne ka order:
+   - `dis.readInt()` → integer read karega.
+   - `dis.readUTF()` → ek UTF string read karega.
+   - `dis.readUTF()` → second UTF string read karega.
+   - `dis.readFloat()` → float read karega.
+   - Order **must match exactly** with the order used while writing using DataOutputStream.
+     Agar order change hua to data corrupt lagega ya exception throw hoga.
+
+5. Output:
+   - Roll No, Name, Average, Dept console par print hoga.
+   - Example:
+     ```
+     Roll No: 101
+     Name: Somesh
+     Average: 85.5
+     Dept: CS
+     ```
+
+6. Important Points:
+   - Tumhare code me `dis.close(); dis.close();` do baar likha hai → ek ko hata do.
+   - Always ensure matching order between DataOutputStream (writer) and DataInputStream (reader).
+   - Ye serialisation ka ek simpler form hai → but ye Java’s built-in `Serializable` interface se different hai.
+   - Agar multiple objects likhne hain → loop use karke likho aur read karte waqt same loop repeat karo.
+
+
+- Use `try-with-resources` to auto-close streams (Java 7+).
+- Pehle ek `DataOutputStream` program likho jo Student data file me likhe,
+  fir usko iss program se read karke verify karo.
+- Agar tumhe complex objects store karne hain to prefer `ObjectOutputStream` / `ObjectInputStream`.
+*/