feat(Java11): add demo showcasing HTTP Client, var in lambdas, and BiFunction

What
- Added JAVA11 class in package Java11 to demonstrate new Java 11 features.
- Included:
  - HTTP Client API example with synchronous request/response.
    - Sends GET request to https://jsonplaceholder.typicode.com/posts/1.
    - Prints response body as string.
  - Local-variable syntax for lambda parameters using var.
    - Iterates names list with forEach((var name) -> ...).
  - BiFunction<Integer, Integer, Integer> with var syntax in lambda.
    - Adds two integers and prints result (30).

Why
- Shows modernized features introduced in Java 11.
- Demonstrates usage of standard, built-in HTTP client replacing older libraries.
- Highlights var keyword in lambda parameters, improving consistency with local variable declarations.
- Provides example of BiFunction with explicit var parameter typing.

How
- Created HttpClient with HttpClient.newHttpClient().
- Built request using HttpRequest.newBuilder().uri(...).build().
- Sent request synchronously using client.send(request, BodyHandlers.ofString()).
- Printed response body.
- Created list ["Alice","Bob","Charlie"] and iterated with forEach((var name) -> ...).
- Defined BiFunction with (var x, var y) -> x + y and applied with inputs 10 and 20.

Logic
- Inputs:
  - HTTP GET request URI: https://jsonplaceholder.typicode.com/posts/1.
  - List of names ["Alice","Bob","Charlie"].
  - Integers 10 and 20.
- Outputs:
  - Prints response body from API.
  - Prints greetings: Hello, Alice / Hello, Bob / Hello, Charlie.
  - Prints "Sum using BiFunction with var: 30".
- Flow:
  1. Construct HTTP request and send.
  2. Print API response.
  3. Iterate list with lambda using var parameter.
  4. Execute BiFunction add with var parameters.
- Edge cases:
  - Network errors may throw IOException/InterruptedException.
  - API response may vary or be unavailable.
- Complexity / performance:
  - HTTP request cost depends on network latency.
  - List iteration and BiFunction execution are O(n) and O(1), respectively.
- Concurrency / thread-safety:
  - HttpClient is immutable and thread-safe.
  - Lambdas are stateless; safe to run concurrently.
- Error handling:
  - Method declares IOException and InterruptedException for safe propagation.

Real-life applications
- HTTP Client API for REST API calls in microservices, integrations, or data fetching.
- var in lambda improves readability and reduces boilerplate in functional programming.
- BiFunction with var shows flexible lambda typing in modern Java.

Notes
- In production, prefer proper error handling instead of throwing exceptions from main.
- Method reference System.out::println could simplify forEach example.
- For asynchronous HTTP calls, HttpClient provides sendAsync() for non-blocking requests.

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

Author: Someshdiwan

Java-Versions/Java 11/src/JAVA11.java

@@ -0,0 +1,37 @@
+package Java11;
+
+import java.io.IOException;
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.net.http.HttpResponse.BodyHandlers;
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.BiFunction;
+
+public class JAVA11 {
+    public static void main(String[] args) throws IOException, InterruptedException {
+        // HTTP Client API Example (Synchronous)
+        System.out.println("Java 11 HTTP Client Example:");
+
+        HttpClient client = HttpClient.newHttpClient();
+        HttpRequest request = HttpRequest.newBuilder()
+                .uri(URI.create("https://jsonplaceholder.typicode.com/posts/1"))
+                .build();
+
+        HttpResponse<String> response = client.send(request, BodyHandlers.ofString());
+        System.out.println("Response from API:\n" + response.body());
+
+        // Local-variable syntax for lambda parameters (var)
+        System.out.println("\nUsing 'var' in lambda parameters:");
+
+        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
+        names.forEach((var name) -> System.out.println("Hello, " + name));
+
+        // BiFunction with var in lambda
+        BiFunction<Integer, Integer, Integer> add = (var x, var y) -> x + y;
+        int result = add.apply(10, 20);
+        System.out.println("Sum using BiFunction with var: " + result);
+    }
+}