feat: implement basic file writing example using FileOutputStream

WHAT:
- Added `FileExample` to demonstrate writing data into a file using `FileOutputStream`.
- Writes a full string directly to a file using `fos.write(str.getBytes())`.
- Included commented alternatives:
  - Writing bytes one-by-one in a loop.
  - Writing a substring portion using `fos.write(byte[], offset, length)`.

WHY:
- `FileOutputStream` is one of the core classes in Java I/O for writing raw bytes into files.
- Understanding byte-level writing is important before working with higher-level abstractions like `BufferedWriter` or `PrintWriter`.

HOW:
1. Opened a file at the given path (`Test.txt`) using `FileOutputStream`.
2. Converted a string into a byte array with `getBytes()`.
3. Wrote the byte array to the file in one go.
4. Closed the stream to release system resources.

ERROR HANDLING:
- Caught `FileNotFoundException` (e.g., if the path is invalid).
- Caught general `IOException` for any unexpected I/O issues.

REAL-WORLD USE CASES:
- Writing logs or reports directly into a file.
- Saving application data (text or binary) at runtime.
- Building utilities that generate configuration or result files.
- Basis for advanced file operations (serialization, buffering, streaming large datasets).

NOTES:
- Always close the stream (`fos.close()`) to avoid resource leaks.
- Better approach: use try-with-resources (`try(FileOutputStream fos = ...) { ... }`) for auto-closing.
- For character-specific writing, `FileWriter` or `BufferedWriter` is more convenient.
- For frequent writes, consider `BufferedOutputStream` for performance improvements.

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

Author: Someshdiwan

Section23JavaIOStreams/src/FileExample.java

@@ -4,8 +4,8 @@
 public class FileExample {
     public static void main(String[] args) {
         try {
-            FileOutputStream fos = new FileOutputStream("C://Users//somes//Downloads//JAVA SE//Section23JavaIOStreams//src//MyJAVA/Test.txt");
-            String str = "Learn JAVA Programming";
+            FileOutputStream fos = new FileOutputStream("/Users/somesh/Java SE/JavaEvolution-Learning-Growing-Mastering/Section23JavaIOStreams/src/MyJAVA/Test.txt");
+            String str = "Learn JAVA Programming From Abdul Bari Sir and Engineering Digest YT";
 
             /*
             other methods try in other-program.
@@ -25,4 +25,35 @@ public static void main(String[] args) {
             System.out.println(r);
         }
     }
-}
+}
+
+/*
+1. FileOutputStream:
+   - Stream jo file ke andar data likhne (write) ke liye use hota hai.
+   - Data binary format me write hota hai (characters ko bhi byte array me convert karke likhta hai).
+   - Agar file exist nahi karti → nayi file create ho jaati hai.
+   - Agar file already exist karti hai → purana content overwrite ho jaata hai.
+
+2. Important Methods:
+   - fos.write(int b) → ek single byte likhta hai.
+   - fos.write(byte[] b) → poora byte array likhta hai.
+   - fos.write(byte[] b, int off, int len) → array ke ek portion ko write karta hai.
+   - fos.close() → stream band karna zaroori hai taaki resources release ho jayein.
+
+3. is program me:
+   - `FileOutputStream fos = new FileOutputStream("path.../Test.txt");`
+     → File open/create kiya writing ke liye.
+   - `str.getBytes()` → String ko byte array me convert kiya.
+   - `fos.write(str.getBytes());` → pura string file me write kiya.
+   - `fos.close();` → file properly close ki gayi.
+
+4. Use Cases:
+   - Text ya binary file banani ho.
+   - Logs, reports ya serialized data likhne ke liye.
+   - Agar character-based writing chahiye toh `FileWriter` use karna better.
+
+
+✔ FileOutputStream = binary write stream.
+✔ getBytes() → String → byte array.
+✔ Overwrites file by default (append karna ho toh `new FileOutputStream(path, true)`).
+*/

Section23JavaIOStreams/src/MyJAVA/Test.txt

@@ -1 +1 @@
-Learn JAVA Programming
+Learn JAVA Programming From Abdul Bari Sir and Engineering Digest YT