feat: merge multiple files using SequenceInputStream and transform character data

WHAT:
- Implemented SCIO2 class to demonstrate the use of `SequenceInputStream`.
- Combined data from two input files (`Source1.txt` and `Source3.txt`) into a single destination file.
- Applied transformation to convert certain characters (A–Z, a–x) by shifting ASCII values.

HOW:
1. Opened two `FileInputStream` objects for the source files.
2. Used `SequenceInputStream(fis, fis2)` to create a continuous input stream
   that reads from the first file until EOF, then continues from the second file.
3. Read byte by byte (`sis.read()`), writing results into `Destination.txt`.
4. Transformation applied:
   - If byte value is between 65 and 120 (inclusive), write `(b + 32)`.
   - Else, write the byte unchanged.
5. Closed all streams to release system resources.

WHY:
- `SequenceInputStream` allows seamless concatenation of multiple input streams.
- This is useful when combining or merging files, such as concatenating logs,
  combining chunks of data, or merging text segments.
- Demonstrates applying processing logic (case conversion / transformation) during file merging.

REAL-WORLD APPLICATIONS:
- Merging multiple small text or log files into a single output file.
- Preprocessing combined data with transformations (e.g., case conversion, encryption).
- Handling large file chunks sequentially when stored across different files.

NOTES:
- Transformation logic `(b + 32)` does not strictly map uppercase letters to lowercase
  (since ASCII uppercase A–Z is 65–90 and lowercase is 97–122).
  A more accurate transformation would use `Character.toLowerCase((char) b)`.
- Consider using `try-with-resources` for safer resource handling.
- For merging more than two files, `SequenceInputStream` can also take an `Enumeration<InputStream>`.

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

Author: Someshdiwan

Section23JavaIOStreams/src/MyJAVA/Destination.txt

@@ -1 +1 @@
-copying this file into another file.���y��� ���� ���� ���� ������� ����.
+copying this file into another file. ��� ���������� ��� ����� ���� �� �� ����� ���� ������.���y��� ���� ���� ���� ������� ����. ��� ���������� ��� ����� ���� �� �� ����� ���� ������.

Section23JavaIOStreams/src/SCIO2.java

@@ -4,21 +4,52 @@
 
 public class SCIO2 {
     public static void main(String[] args) throws Exception {
-        FileInputStream fis = new FileInputStream("C://Users//somes//Downloads//JAVA SE//Section23JavaIOStreams//src//MyJAVA//Source1.txt");
-        FileInputStream fis2 = new FileInputStream("C://Users//somes//Downloads//JAVA SE//Section23JavaIOStreams//src//MyJAVA//Source3.txt");
+        FileInputStream fis = new FileInputStream("/Users/somesh/Java SE/JavaEvolution-Learning-Growing-Mastering/Section23JavaIOStreams/src/MyJAVA/Source1.txt");
+        FileInputStream fis2 = new FileInputStream("/Users/somesh/Java SE/JavaEvolution-Learning-Growing-Mastering/Section23JavaIOStreams/src/MyJAVA/Source3.txt");
 
-        FileOutputStream fos = new FileOutputStream("C://Users//somes//Downloads//JAVA SE//Section23JavaIOStreams//src//MyJAVA//Destination.txt");
-        SequenceInputStream sis = new SequenceInputStream(fis,fis2);
+        FileOutputStream fos = new FileOutputStream("/Users/somesh/Java SE/JavaEvolution-Learning-Growing-Mastering/Section23JavaIOStreams/src/MyJAVA/Destination.txt");
+        SequenceInputStream sis = new SequenceInputStream(fis, fis2);
 
         int b;
-        while((b= sis.read())!=-1)
-           /*-1 means finishing completing reading both files.
-             after second file reading it become -1.*/
+        while ((b = sis.read()) != -1)
+            /* -1 means finishing completing reading both files. after the second file reading, it becomes -1. */
         {
-            if(b>=65 && b<=120)fos.write(b+32);
+            if (b >= 65 && b <= 120) fos.write(b + 32);
             else fos.write(b);
         }
         fis.close();
         fos.close();
     }
-} 
+}
+
+/*
+1. FileInputStream (fis, fis2):
+   - Dono alag-alag source files (`Source1.txt` aur `Source3.txt`) se data read karte hain.
+   - Ye byte-by-byte read karte hain aur ASCII values return karte hain.
+
+2. SequenceInputStream (sis):
+   - `SequenceInputStream(fis, fis2)` dono streams ko combine karta hai.
+   - Pehle `fis` (Source1) se poora data read karega.
+   - Fir automatically `fis2` (Source3) par switch karega.
+   - End of both files ke baad `read()` -1 return karega.
+
+3. FileOutputStream (fos):
+   - Target file (`Destination.txt`) me final data likhne ke liye use hota hai.
+   - Jo bhi bytes sis se read hote hain, wahi fos me write kiye jaate hain.
+
+4. Logic (Case Transformation):
+   - `if (b >= 65 && b <= 120)` → ASCII range uppercase letters (A–X tak cover karta hai).
+   - Agar uppercase letter hai → usko `b + 32` karke lowercase me convert kar deta hai.
+     - Example: 'A' → 'a', 'B' → 'b', ...
+   - Baaki characters as-it-is copy hote hain.
+
+5. Close Streams:
+   - `fis.close(); fis2.close(); fos.close();` → sabhi streams properly close karne chahiye.
+   - Resources release hote hain aur memory leaks avoid hote hain.
+
+✔ SequenceInputStream → multiple input streams ko **ek continuous stream** banata hai.
+✔ Pehle file1 → fir file2 sequentially read hoti hai.
+✔ Output file me dono files ka combined content likha jaata hai.
+✔ Logic add kiya gaya hai uppercase → lowercase conversion ke liye.
+✔ Useful jab tumhe multiple files ko merge + transform** karna ho ek single file me.
+*/