feat: implement ByteArrayOutputStream to write data into file

WHAT:
- Added `ByteStreamExample3` demonstrating usage of `ByteArrayOutputStream`.
- Wrote multiple characters (`a` to `e`) into a memory buffer.
- Converted the buffer into a byte array via `toByteArray()`.
- Used `writeTo()` to dump the in-memory stream directly into a file
  (`ByteStreamExample3.txt`).
- Included commented-out loop for debugging/printing the byte array contents.

WHY:
- `ByteArrayOutputStream` allows writing data into memory before committing
  to a file or other stream. This is efficient when:
  - Collecting and manipulating data in-memory.
  - Writing to multiple output streams at once.
  - Delaying file/network writes until all data is ready.
- Demonstrates how to bridge memory buffers and persistent storage.

HOW:
1. Created a `ByteArrayOutputStream` with an initial capacity of 20 bytes.
2. Wrote five characters (`a`–`e`) as bytes into the stream.
3. Used `toByteArray()` to obtain the raw byte representation.
4. Persisted the buffer into a file using `writeTo(FileOutputStream)`.
5. Optionally (commented) iterated over byte array to print characters.

REAL-WORLD USE CASES:
- Collecting logs or response data in memory before sending to a network socket.
- Generating reports or files in memory before saving to disk.
- Efficient data aggregation where final output can be streamed to multiple destinations.
- Used in frameworks (e.g., servlet containers) to buffer HTTP responses.

NOTES:
- Unlike `FileOutputStream`, `ByteArrayOutputStream` never throws `IOException`
  during writes (since it’s in-memory).
- Always close underlying file streams (though closing `ByteArrayOutputStream`
  is optional—it has no effect).
- For large data, beware of memory usage since everything is stored in RAM.

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

Author: Someshdiwan

Section23JavaIOStreams/src/ByteStreamExample3.java

@@ -4,20 +4,58 @@
 
 public class ByteStreamExample3 {
     public static void main(String[] args) throws Exception {
-
         ByteArrayOutputStream bos = new ByteArrayOutputStream(20);
         bos.write('a');
         bos.write('b');
         bos.write('c');
         bos.write('d');
+        bos.write('e');
 
         byte b[] = bos.toByteArray();
 
-        bos.writeTo(new FileOutputStream("C://Users//somes//Downloads//JAVA SE//Section23JavaIOStreams//src//MyJAVA//ByteStreamExample3.txt"));
-        /*for(byte x:b)
+        bos.writeTo(new FileOutputStream("/Users/somesh/Java SE/JavaEvolution-Learning-Growing-Mastering/Section23JavaIOStreams/src/MyJAVA/ByteStreamExample3.txt"));
+        /*
+        for(byte x:b)
             System.out.println((char)x); //Typecasted
-        bos.close();*/
-
-
+        bos.close();
+        */
     }
 }
+
+/*
+1. ByteArrayOutputStream (BAOS):
+   - Ye ek memory buffer (byte array) create karta hai.
+   - Hum isme `write(int b)` ya `write(byte[] b)` karke data daal sakte hain.
+   - Buffer automatically grow hota hai agar size exceed ho jaye (default size set kar sakte ho, jaise yaha 20 bytes).
+
+2. toByteArray():
+   - BAOS ka sara content ek `byte[]` array me return karta hai.
+   - Example: agar "abcde" likha → byte array {'a','b','c','d','e'}.
+
+3. writeTo(OutputStream out):
+   - Directly BAOS ka data kisi dusre OutputStream (file, socket, etc.) me likh deta hai.
+   - Yaha: `bos.writeTo(new FileOutputStream("ByteStreamExample3.txt"));`
+   - Matlab → jo "abcde" memory buffer me tha, ab file me store ho gaya.
+
+4. Code Flow:
+   - 20 bytes ka buffer banaya.
+   - Characters `'a'...'e'` likhe (ASCII values store hue).
+   - `toByteArray()` se ek normal byte array liya.
+   - `writeTo()` se file me dump kar diya.
+
+5. Output in file:
+   - File "ByteStreamExample3.txt" ke andar likha hoga:
+     ```
+     abcde
+     ```
+
+6. Best Practices:
+   - Always close the target stream (like FileOutputStream) after writeTo().
+   - BAOS ko close karna optional hai (kyunki ye memory-based hai), but karna good practice hai.
+   - Useful when → hume pehle memory me data collect karna hai, phir ek sath file, network, ya multiple streams me bhejna hai.
+
+✔ BAOS → data RAM me store hota hai.
+✔ toByteArray() → data ko byte array me convert karta hai.
+✔ writeTo() → data ko file/stream me likh deta hai.
+✔ Example output file → "abcde".
+*/

Section23JavaIOStreams/src/MyJAVA/ByteStreamExample3.txt

@@ -1 +1 @@
-abcd
+abcde