Java 21 Programs

Author: lokeshgupta1981

src/main/java/com/howtodoinjava/newFeatures/java21/README.md

@@ -0,0 +1,11 @@
+# Java 21 Tutorials
+
+- [Java 21 Unnamed Patterns and Variables (with Examples)](https://howtodoinjava.com/java/unnamed-patterns-and-variables/)
+- [Java 21 Scoped Values: A Deep Dive with Examples](https://howtodoinjava.com/java/multi-threading/java-scoped-values/)
+- [Java Record Patterns and Pattern Matching](https://howtodoinjava.com/java/record-patterns-and-pattern-matching/)
+- [Java Unnamed Classes and Instance Main Methods](https://howtodoinjava.com/java/java-unnamed-class-instance-method/)
+- [Java 21 Sequenced Collections](https://howtodoinjava.com/java/sequenced-collections/)
+- [Java 21 Features: Practical Examples and Insights](https://howtodoinjava.com/java/java-21-new-features/)
+- [Java 21 String Templates](https://howtodoinjava.com/java/java-string-templates/)
+- [Java 21 Structured Concurrency: StructuredTaskScope](https://howtodoinjava.com/java/multi-threading/structured-concurrency/)
+- [Java Virtual Threads – Project Loom](https://howtodoinjava.com/java/multi-threading/virtual-threads/)

src/main/java/com/howtodoinjava/newFeatures/java21/ScopedValueTest.java

@@ -1,66 +1,58 @@
 package com.howtodoinjava.newFeatures.java21;
 
-//import java.util.concurrent.StructuredTaskScope;
+import java.util.concurrent.StructuredTaskScope;
 
 public class ScopedValueTest {
 
   //public static ThreadLocal<String> CONTEXT = ThreadLocal.withInitial(() -> null);
-  //public static InheritableThreadLocal<String> CONTEXT = new InheritableThreadLocal();
-
-  //private static final ScopedValue<String> CONTEXT = ScopedValue.newInstance();
-
-
+  //public static InheritableThreadLocal<String> CONTEXT = new InheritableThreadLocal<>();
+  private static final ScopedValue<String> CONTEXT = ScopedValue.newInstance();
 
   public static void main(String[] args) {
 
-
-
-    /*ScopedValue.runWhere(CONTEXT, "TestValue", () -> {
+    ScopedValue.runWhere(CONTEXT, "TestValue", () -> {
 
       doSomething();
 
       try (var scope = new StructuredTaskScope<String>()) {
 
-        scope.fork(() -> insideChildThread());
+        scope.fork(() -> doSomethingInChildThread());
 
-        try{
+        try {
           scope.join();
         } catch (InterruptedException ex) {
           //...
         }
-        
+
       }
-    });*/
+    });
+  }
+
+  static void doSomething() {
+    System.out.println("Scoped Value in doSomething(): " + CONTEXT.get());
+  }
+
+  static String doSomethingInChildThread() {
+    System.out.println("Scoped Value in insideChildThread(): " + CONTEXT.get());
+    return CONTEXT.get();
+  }
 
 
-    ScopedValueTest instance = new ScopedValueTest();
+    /*ScopedValueTest instance = new ScopedValueTest();
 
-    /*ScopedValue.runWhere(CONTEXT, "Test Value", () -> {
+    ScopedValue.runWhere(CONTEXT, "Test Value", () -> {
 
       System.out.println("In parent thread start the scoped value is: " + CONTEXT.get());
       instance.doSomething();
       System.out.println("In parent thread end the scoped value is: " + CONTEXT.get());
     });
 
     System.out.println("Outside bounded scope isBound() is: " + CONTEXT.isBound()); 
-    System.out.println("Outside bounded scope the scoped value is: " + CONTEXT.orElse(null));*/
-  
-
-  
-
-
+    System.out.println("Outside bounded scope the scoped value is: " + CONTEXT.orElse(null));
 
+    Thread parentThread = new Thread(() -> {
 
-
-
-
-
-
-
-
-    /*Thread parentThread = new Thread(() -> {
-
-      CONTEXT.set("TestValue");
+      //CONTEXT.set("TestValue");
       insideParentThread_1();
 
       Thread childThread = new Thread(() -> {
@@ -71,22 +63,22 @@ public static void main(String[] args) {
       insideParentThread_2();
     });
 
-    parentThread.start();*/
-  }
+    parentThread.start();
+  }*/
 
   /*public void doSomething() {
     System.out.println("In doSomething() and parent scope: " + CONTEXT.get());
     ScopedValue.runWhere(CONTEXT, "Changed Value", () -> {
       System.out.println("In doSomething() and child scope: " + CONTEXT.get());
       doSomethingAgain();
     });
-  }*/
+  }
 
-  /*public void doSomethingAgain() {
+  public void doSomethingAgain() {
     System.out.println("In doSomethingAgain() and child scope: " + CONTEXT.get());
-  }*/
+  }
 
-  /*static void doSomething() {
+  static void doSomething1() {
       System.out.println("Scoped Value in doSomething(): " + CONTEXT.get());
   }
 

src/main/java/com/howtodoinjava/newFeatures/java21/SequencedCollectionExamples.java

@@ -0,0 +1,78 @@
+package com.howtodoinjava.newFeatures.java21;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeSet;
+
+public class SequencedCollectionExamples {
+
+  public static void main(String[] args) {
+    ArrayList<Integer> arrayList = new ArrayList<>();
+
+    arrayList.add(1); 	// List contains: [1]
+
+    arrayList.addFirst(0);	// List contains: [0, 1]
+    arrayList.addLast(2);		// List contains: [0, 1, 2]
+
+    Integer firstElement = arrayList.getFirst();	// 0
+    Integer lastElement = arrayList.getLast();	// 2
+
+    List<Integer> reversed = arrayList.reversed();
+    System.out.println(reversed); // Prints [2, 1, 0]
+
+    //
+
+    LinkedHashSet<Integer> linkedHashSet = new LinkedHashSet<>(List.of(1, 2, 3));
+
+    firstElement = linkedHashSet.getFirst();   // 1
+    lastElement = linkedHashSet.getLast();    // 3
+
+    linkedHashSet.addFirst(0);  //List contains: [0, 1, 2, 3]
+    linkedHashSet.addLast(4);   //List contains: [0, 1, 2, 3, 4]
+
+    System.out.println(linkedHashSet.reversed());   //Prints [5, 3, 2, 1, 0]
+
+    //
+
+    LinkedHashMap<Integer, String> map = new LinkedHashMap<>();
+
+    map.put(1, "One");
+    map.put(2, "Two");
+    map.put(3, "Three");
+
+    map.firstEntry();   //1=One
+    map.lastEntry();    //3=Three
+
+    System.out.println(map);  //{1=One, 2=Two, 3=Three}
+
+    Map.Entry<Integer, String> first = map.pollFirstEntry();   //1=One
+    Map.Entry<Integer, String> last = map.pollLastEntry();    //3=Three
+
+    System.out.println(map);  //{2=Two}
+
+    map.putFirst(1, "One");     //{1=One, 2=Two}
+    map.putLast(3, "Three");    //{1=One, 2=Two, 3=Three}
+
+    System.out.println(map);  //{1=One, 2=Two, 3=Three}
+    System.out.println(map.reversed());   //{3=Three, 2=Two, 1=One}
+
+    //
+    List<Integer> list = List.of(1, 2, 3);
+    //list.addLast(4);  //Exception in thread "main" java.lang.UnsupportedOperationException
+
+    TreeSet<Integer> set = new TreeSet<>(List.of(1, 2, 3));
+    //set.addFirst(4);  //Exception in thread "main" java.lang.UnsupportedOperationException
+
+    List<Integer> list1 = List.of();
+    //list1.getFirst();  //Exception in thread "main" java.lang.NoSuchElementException
+
+    //Collections Class
+    //Collections.unmodifiableSequencedCollection(sequencedCollection);
+    //Collections.unmodifiableSequencedSet(sequencedSet);
+    //Collections.unmodifiableSequencedMap(sequencedMap);
+  }
+
+}

src/main/java/com/howtodoinjava/newFeatures/java21/StringTemplates.java

@@ -0,0 +1,17 @@
+package com.howtodoinjava.newFeatures.java21;
+
+public class StringTemplates {
+
+  public static void main(String[] args) {
+    String name = "Alex";
+    String message = STR."Greetings \{name}!";
+    System.out.println(message);
+
+    /*//FMT
+    message = FMT."Greetings %-12s\{name}.";
+
+    //RAW
+    StringTemplate st = RAW."Greetings \{name}.";
+    String message = STR.process(st);*/
+  }
+}

src/main/java/com/howtodoinjava/newFeatures/java21/StructuredConcurrency.java

@@ -0,0 +1,107 @@
+package com.howtodoinjava.newFeatures.java21;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.StructuredTaskScope;
+import java.util.function.Supplier;
+
+public class StructuredConcurrency {
+
+  public static void main(String[] args) {
+    StructuredConcurrency instance = new StructuredConcurrency();
+    DemographicData data = instance.getClientDetails(1001L);
+    //Response response = instance.getClientById(1001L);
+  }
+
+  public DemographicData getClientDetails(Long id) {
+
+    System.out.println("Forking new threads...");
+
+    try (var scope = new StructuredTaskScope.ShutdownOnSuccess<>()) {
+
+      scope.fork(() -> fetchUserDetails(id));
+      scope.fork(() -> fetchUserDetailsNew(id));
+
+      scope.join();
+
+      System.out.println("Response is received from a worker...");
+      //Any one task has been completed
+      return (DemographicData) scope.result();
+    } catch (Exception e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  public Response getClientById(Long id) {
+
+    System.out.println("Forking new threads...");
+
+    try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
+
+      Supplier<AccountDetails> accountDetailsFuture = scope.fork(() -> getAccountDetails(id));
+      Supplier<LinkedAccounts> linkedAccountsFuture = scope.fork(() -> fetchLinkedAccounts(id));
+      Supplier<DemographicData> userDetailsFuture = scope.fork(() -> fetchUserDetails(id));
+
+      System.out.println("Joining all threads...");
+      scope.join();  // Join all subtasks
+      scope.throwIfFailed(WebApplicationException::new);  //Handle error when any subtask fails
+
+      System.out.println("Response is received from all workers...");
+      //The subtasks have completed by now so process the result
+      return new Response(accountDetailsFuture.get(),
+          linkedAccountsFuture.get(),
+          userDetailsFuture.get());
+    } catch (InterruptedException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  private DemographicData fetchUserDetails(Long id) throws InterruptedException {
+    Thread.sleep(2000L);
+    System.out.println("Retrieved DemographicData.");
+    return new DemographicData();
+  }
+
+  private DemographicData fetchUserDetailsNew(Long id) throws InterruptedException {
+    Thread.sleep(1000L);
+    System.out.println("Retrieved DemographicData from fetchUserDetailsNew.");
+    return new DemographicData();
+  }
+
+  private LinkedAccounts fetchLinkedAccounts(Long id) throws InterruptedException {
+    Thread.sleep(3000L);
+    System.out.println("Retrieved LinkedAccounts.");
+    return new LinkedAccounts();
+  }
+
+  private AccountDetails getAccountDetails(Long id) throws InterruptedException {
+    Thread.sleep(4000L);
+    System.out.println("Retrieved AccountDetails.");
+    return new AccountDetails();
+  }
+}
+
+class AccountDetails {
+
+}
+
+class LinkedAccounts {
+
+}
+
+class DemographicData {
+
+}
+
+class Response {
+
+  public Response(AccountDetails accountDetails, LinkedAccounts linkedAccounts,
+      DemographicData demographicData) {
+  }
+}
+
+class WebApplicationException extends RuntimeException {
+
+  public WebApplicationException(Throwable e) {
+    super(e);
+  }
+}

src/main/java/com/howtodoinjava/newFeatures/java21/UnnamedClassAndInstanceMainMethod.java

@@ -0,0 +1,3 @@
+void main() {
+  System.out.println("Hello, World!");
+}

src/main/java/com/howtodoinjava/newFeatures/java21/UnnamedPatterns.java

@@ -0,0 +1,38 @@
+package com.howtodoinjava.newFeatures.java21;
+
+import java.time.LocalDate;
+
+public class UnnamedPatterns {
+
+  public static void main(String[] args) {
+    Department department = new Department(1L, "HR", true);
+    Employee employee = new Employee(101L, "John Doe", LocalDate.of(1990, 5, 15), true, department);
+
+    //With unused pattern variables
+    if (employee instanceof Employee(Long id, String name, LocalDate dateOfBirth, Boolean status,
+                                     Department(Long depId, String depName, Boolean depStatus))) {
+
+      System.out.printf("Employee %d works in department %s.", id, depName);
+    }
+
+    if (department instanceof Department(_, String name, _)) {
+      System.out.println("Department Name is : " + name);  // Prints 'Department Name is : HR'
+    }
+
+    if (employee instanceof Employee(Long id, _, _, _, Department(_, String depName, _))) {
+      System.out.printf("Employee %d works in department %s.", id, depName);
+    }
+
+    if (employee instanceof Employee(Long id, _, _, _, _)) {
+      System.out.println("Employee Id is : " + id);  // Prints 'Employee Id is : 101'
+    }
+  }
+}
+
+record Department(Long id, String name, Boolean status) {
+  // Constructor and methods (if any)
+}
+
+record Employee(Long id, String name, LocalDate dateOfBirth, Boolean status, Department department) {
+  // Constructor and methods (if any)
+}