refactor: add try-with-resources for safer file writing with FileOutputStream

WHAT:
- Implemented `FileExample2` demonstrating file writing using `FileOutputStream` inside a try-with-resources block.
- Wrote a string ("With Using Resources.") to a file after converting it into a byte array.
- Replaced manual `fos.close()` with automatic resource management.
- Included commented alternatives:
  - Writing each byte individually in a loop.
  - Writing partial content using `fos.write(byte[], offset, length)`.

WHY:
- Ensures automatic closing of the stream, reducing the risk of resource leaks.
- Simplifies error handling and makes the code cleaner.
- Encourages best practices in modern Java (Java 7+).

HOW:
1. Opened file using `try(FileOutputStream fos = new FileOutputStream(path)) { ... }`.
2. Converted string to bytes (`str.getBytes()`).
3. Wrote the byte array directly with `fos.write(b)`.
4. Stream automatically closed at the end of the try block.

BENEFITS:
- No need for explicit `close()` calls.
- Even if an exception occurs, the resource will be closed properly.
- Cleaner, more concise code compared to manual try-catch-finally.

REAL-WORLD USE CASES:
- Writing logs, reports, or configuration files.
- Safely handling file I/O in enterprise applications where resource leaks can be costly.
- Recommended for modern Java development wherever streams are used.

NOTES:
- Multiple resources (e.g., FileInputStream + BufferedInputStream) can be opened in the same try-with-resources block.
- For text-heavy operations, `FileWriter`/`BufferedWriter` may be preferable.
- For performance with large data, combine with `BufferedOutputStream`.

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

Author: Someshdiwan

Section23JavaIOStreams/src/FileExample2.java

@@ -1,34 +1,68 @@
 import java.io.*;
 
 public class FileExample2 {
-
-    public static void main(String[] args) throws Exception
-    {
-
-        try(FileOutputStream fos=new FileOutputStream("C://Users//somes//Downloads//JAVA SE//Section23JavaIOStreams//src//MyJAVA/WithResources.txt");)
+    public static void main(String[] args) throws Exception {
+        try(FileOutputStream fos=new FileOutputStream("/Users/somesh/Java SE/JavaEvolution-Learning-Growing-Mastering/Section23JavaIOStreams/src/MyJAVA/WithResources.txt");)
         {
-            String str="With Using Resources";
-
+            String str = "With Using Resources.";
             byte b[]=str.getBytes();
 
         /*
         //fos.write(str.getBytes());
+
         for(byte x:b)
-            fos.write(x);*/
+            fos.write(x);
+        */
             //fos.write(b, 6, str.length()-6);
-
             fos.write(b);
-
             //fos.close();
-
         }
+
         /*catch(FileNotFoundException e)
         {
             System.out.println(e);
         }
         catch(IOException e)
         {
             System.out.println(e);
-        }*/
+        }
+        */
     }
-}
+}
+
+/*
+1. try-with-resources:
+   - Java feature jisme try block ke andar declare kiya gaya resource
+     (jaise FileOutputStream) automatically close ho jaata hai.
+   - `fos.close()` likhne ki zaroorat nahi hoti, JVM khud handle kar leti hai.
+   - Safer aur clean code likhne ke liye prefer karte hain.
+
+2. FileOutputStream:
+   - Stream jo file ke andar data write karne ke liye use hota hai.
+   - Data binary form me likhta hai (String ko bhi bytes me convert karna padta hai).
+   - Agar file exist nahi hai → nayi file create ho jaati hai.
+   - Agar file already exist hai → purana content overwrite ho jaata hai.
+
+3. Important Methods:
+   - fos.write(int b) → ek single byte likhta hai.
+   - fos.write(byte[] b) → pura byte array likhta hai.
+   - fos.write(byte[] b, int off, int len) → array ke ek specific portion ko write karta hai.
+   - fos.close() → normally zaroori hota hai, par yaha auto-close ho gaya (try-with-resources).
+
+4. is program me kya ho raha hai:
+   - `FileOutputStream fos = new FileOutputStream(".../WithResources.txt");`
+     → File ko open/create kiya writing ke liye.
+   - `str.getBytes()` → String ko byte array me convert kiya.
+   - `fos.write(b);` → pura string file me write kiya.
+   - Stream auto-close ho gaya because of try-with-resources.
+
+5. Use Cases:
+   - Text ya binary file banani ho.
+   - Logs, reports ya raw byte data likhne ke liye.
+   - Agar sirf characters write karne ho toh `FileWriter` ka use karna better.
+
+✔ try-with-resources = auto close, no need for finally block.
+✔ FileOutputStream = binary write stream.
+✔ getBytes() = String → byte array conversion.
+✔ Overwrites file by default (append karna ho toh `new FileOutputStream(path, true)` use karo).
+*/

Section23JavaIOStreams/src/MyJAVA/WithResources.txt

@@ -1 +1 @@
-With Using Resources
+With Using Resources.