feat(TokenizerDemo): demonstrate StringTokenizer with different delimiters

What
- Added `TokenizerDemo` class showing multiple delimiter use cases with `StringTokenizer`.
- Supports parsing key-value pairs separated by `;`, `\n`, or spaces.
- Demonstrates behavior when only `=` is specified as a delimiter vs multiple delimiters.

Why
- To illustrate how `StringTokenizer` handles delimiters in real-world text parsing scenarios.
- Helps understand default whitespace handling (space, tab, newline).
- Useful for parsing config files, logs, or simple structured input.

How
- Declared sample `data` strings with `;`, `\n`, or space as separators.
- Created `StringTokenizer` with delimiters `"="` (Example B) or `"=;"` (Example A).
- Iterated over tokens with `hasMoreTokens()` and `nextToken()`.
- Printed each token to verify splitting behavior.

Logic
- `StringTokenizer` breaks the input string into tokens based on specified delimiters.
- If no delimiter provided, default delimiters = whitespace characters.
- Tokens are sequentially retrieved until no more remain.

Real-life applications
- Splitting config or `.properties` file content (`key=value`).
- Parsing command-line or user input strings.
- Tokenizing logs or metadata separated by `;`, newline, or spaces.

Summary
- `TokenizerDemo` shows how to tokenize strings with custom delimiters.
- Demonstrates default whitespace handling.
- Practical for learning string parsing using `StringTokenizer`.

Signed-off-by: https://github.com/Someshdiwan <someshdiwan369@gmail.com>

Author: Someshdiwan

Section23JavaIOStreams/String Tokenizer/src/Package2/ToenizerDemo.java

@@ -0,0 +1,68 @@
+package Package2;
+
+import java.util.StringTokenizer;
+
+public class ToenizerDemo {
+    public static void main(String[] args) {
+        // Example 1: Using semicolon (;) as delimiter between pairs
+        // String data = "name=Vijay; address=delhi; country=india; dept=cse";
+
+        // Example 2: Using newline (\n) as delimiter between pairs
+        String data = "name=Vijay\naddress=delhi\ncountry=india\ndept=cse";
+
+        // Example 3: Using space as a delimiter between pairs
+        // String data = "name=Vijay address=delhi country=india dept=cse";
+
+        // Creating StringTokenizer
+        // Example A: Using "=" and ";" as delimiters
+        // StringTokenizer stk = new StringTokenizer(data, "=;");
+
+        // Example B: Using "=" only as a delimiter
+        StringTokenizer stk = new StringTokenizer(data, "=");
+
+        // Note: In Example 2, "\n" also acts as a delimiter automatically
+        // because StringTokenizer treats whitespace characters (space, tab, newline) as default delimiters
+        // unless explicitly told otherwise.
+
+        // Extracting tokens
+        String s;
+        while (stk.hasMoreTokens()) {
+            s = stk.nextToken(); // fetches next token
+            System.out.println(s);
+        }
+    }
+}
+
+/*
+1. Input String
+   - The string contains structured key-value pairs separated by delimiters.
+   - Example: "name=Vijay; address=delhi; country=india; dept=cse"
+
+2. Delimiters
+   - Characters like '=', ';', '\n', or space are used to break the string.
+   - "=" → separates keys from values.
+   - ";" → separates multiple key-value pairs.
+   - "\n" → separates pairs by newlines.
+   - If no delimiters are explicitly given, StringTokenizer uses default (whitespace).
+
+3. StringTokenizer Object
+   - Constructor: StringTokenizer(String str, String delimiters)
+   - It scans the string and splits it into tokens based on the provided delimiters.
+
+4. Methods
+   - hasMoreTokens() → returns true if more tokens are available.
+   - nextToken() → returns the next token.
+   - countTokens() → returns number of tokens left.
+
+5. Example Outputs
+   - For data = "name=Vijay; address=delhi"
+   - With delimiters "=;" → tokens: [name, Vijay, address, delhi]
+   - With delimiter "=" → tokens: [name, Vijay; address, delhi]
+     (because ";" is treated as part of value if not given as delimiter)
+
+6. Important Notes
+   - Tokens are sequentially extracted; order matters.
+   - Delimiters themselves are not returned (unless explicitly configured).
+   - StringTokenizer is simple but considered **legacy** (since JDK 1.0).
+   - Modern alternatives: `String.split(regex)` or `Scanner`.
+*/