feat: implement FileExample3 to demonstrate reading files with FileInputStream and try-with-resources

WHAT:
- Added FileExample3 showcasing different ways to read data from a file using FileInputStream.
- Implemented primary logic using a `do-while` loop to read bytes sequentially and cast them to characters.
- Included alternative approaches (commented):
  - Using a `while` loop for compact reading.
  - Reading all bytes into a byte array (`fis.available()`, `fis.read(b)`) and converting to a String.

WHY:
- Demonstrates how FileInputStream works for reading text data as raw bytes.
- Highlights the immutability of stream operations and different reading strategies.
- Introduces try-with-resources to ensure proper resource management without needing explicit `close()` calls.

HOW:
1. Opened the file `WithResources.txt` with FileInputStream inside try-with-resources.
2. Used `fis.read()` in a loop to read one byte at a time until end-of-file (`-1`).
3. Printed each byte after casting to a character.
4. Added commented examples showing:
   - Compact `while` loop approach.
   - Reading entire file into a byte array, converting to String, and printing.

BENEFITS:
- Provides clear understanding of low-level file reading in Java.
- Demonstrates different use cases: sequential reading, bulk reading, and character conversion.
- Ensures automatic closing of streams, avoiding resource leaks.

REAL-WORLD APPLICATIONS:
- Reading binary/text files where raw byte processing is needed.
- Useful in file parsers, network protocols, and when working with custom file formats.
- Educational example for beginners learning Java I/O streams.

NOTES:
- For larger files, buffered streams (`BufferedInputStream` or `BufferedReader`) are recommended for efficiency.
- `fis.available()` only provides an estimate of available bytes, not always exact.

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

Author: Someshdiwan

Section23JavaIOStreams/src/FileExample3.java

@@ -2,32 +2,79 @@
 
 public class FileExample3 {
     public static void main(String[] args)throws Exception {
-        try(FileInputStream fis = new FileInputStream("C://Users//somes//Downloads//JAVA SE//Section23JavaIOStreams//src//MyJAVA/WithResources.txt");)
+        try(FileInputStream fis = new FileInputStream("/Users/somesh/Java SE/JavaEvolution-Learning-Growing-Mastering/Section23JavaIOStreams/src/MyJAVA/WithResources.txt");)
         {
             //Reading bytes from file and letter by letter.
             int x;
-            /* other ways to do. without do while. we can use simple while loop
+
+            /* other ways to do. without do while. we can use a simple while loop.
             while((x=fis.read())!=-1)
             {
                 System.out.println((char)x);
-            }*/
+            }
+            */
 
-            do{
-                x=fis.read();
-                if(x!=-1)
+            do
+            {
+                x = fis.read();
+                if (x!=-1)
                     System.out.print((char)x);
-            }while(x!=-1);
+            } while(x!=-1);
+
+            /*
+            Creating a-array of Byte.
 
-            /* Creating a-array of Byte.
+            byte b[]=new byte[fis.available()];
+            */
 
-            byte b[]=new byte[fis.available()]; *//*Checking how many bytes available in, input file.*//*
+            /* Checking how many bytes available in, an input file. */
 
+            /*
             fis.read(b);
             //Byte array converting into a string.
             String str = new String(b);
 
             //Read from file and print.
-            System.out.println(str);*/
+            System.out.println(str);
+            */
         }
     }
 }
+
+/*
+1. FileInputStream:
+   - Stream jo file se data read karne ke liye use hota hai.
+   - Data binary form (bytes) me read hota hai.
+   - Agar text file read karna ho → bytes ko char/string me convert karna padta hai.
+   - Agar file exist nahi hai → `FileNotFoundException` throw hota hai.
+
+2. try-with-resources:
+   - Yaha `FileInputStream fis = new FileInputStream("path");`
+     ko try block me declare kiya gaya hai.
+   - try-with-resources ka benefit → `fis.close()` automatically call ho jaata hai.
+
+3. Important Methods:
+   - `fis.read()` → ek byte read karta hai, -1 return karta hai jab end of file (EOF) aata hai.
+   - `fis.available()` → bataata hai kitne bytes abhi read ke liye bache hue hain.
+   - `fis.read(byte[] b)` → ek baar me pura byte array fill kar deta hai.
+
+4. is program me kya ho raha hai:
+   - File open hui WithResources.txt ke liye.
+   - `do-while` loop ke andar ek-ek byte read ho raha hai.
+   - `(char)x` cast karke output me letter print kiya gaya hai.
+   - Alternative approach bhi diya hai:
+     - Simple `while((x=fis.read())!=-1)` loop.
+     - Ya phir `fis.available()` se byte array banakar ek hi baar me pura content read karke `new String(b)` se
+       print karna.
+
+5. Use Cases:
+   - Binary files (images, audio, executables) read karna.
+   - Text files character by character read karna.
+   - Agar character-stream handling (encoding safe) chahiye toh `FileReader` use karo.
+
+
+✔ FileInputStream = binary read stream.
+✔ read() → byte by byte read, -1 = EOF.
+✔ available() → kitne bytes pending hain.
+✔ try-with-resources = auto close, no need to call `fis.close()`.
+*/