added examples of Java 19 features

Author: wesleyegberto

java-19/README.md

@@ -7,12 +7,12 @@ To run each example use: `java --enable-preview --source 19 <FileName.java>`
 ### Language
 
 * Pattern matching for `switch`
-  * Minor improvements from JDK 18:
+  * minor improvements from JDK 18:
     * changed guarded pattern from `&&` to `when` keyword
     * definition: guard is the boolean expression, guarded pattern is the case with guard
       * guarded pattern: `case Hero h when h.getCity() == Cities.NEW_YORK`
       * guard: `h.getCity() == Cities.NEW_YORK`
-* Virtual Threads
+* Virtual Threads:
   * also called user-mode threads or [fiber](https://en.wikipedia.org/wiki/Fiber_(computer_science))
   * more notes about Project Loom [here](../java-loom/)
   * `Virtual threads are lightweight threads that dramatically reduce the effort of writing, maintaining, and observing high-throughput concurrent applications`
@@ -54,8 +54,10 @@ To run each example use: `java --enable-preview --source 19 <FileName.java>`
     * has normal priority;
     * is not member of any thread group;
     * supports concurrent lock API;
-    * supports thread-local variables and interruption;
+    * supports thread-local variables (be careful cause we will tend to use a lot of virtual threads, using too much thread-local variables could easily increase de memory footprint)
+    * interruption and LockSupport;
     * can opt-out from having a thread locals (using Builder);
+    * doesn't supports ThreadGroup (deprecated in favor of structured concurrency);
   * scenarios where it can significantly improve throughput when:
     * number of concurrent tasks is high, and
     * work is not CPU-bound.
@@ -65,14 +67,22 @@ To run each example use: `java --enable-preview --source 19 <FileName.java>`
     * `Thread.ofPlatform().start(() -> {})`;
     * **do not use** any cached method from `Executors`.
   * [here](platform-thread-vs-virtual-thread.md) is some details about the Platform Thread vs Virtual Thread examples
+* Record patterns
+  * added suport to deconstruct record values in pattern matcher
+    * record pattern: `Point(int x, int y)`
+  * now we can use type pattern and record pattern together
+  * we can check the type and extract the record components using `instanceof` operator
+    * `o instanceOf Point(int x, int y)`
 
 ## JEPs
 
+* [405](https://openjdk.java.net/jeps/405) - Record Patterns (Preview)
 * [422](https://openjdk.java.net/jeps/422) - Linux/RISC-V Port
 * [424](https://openjdk.java.net/jeps/424) - Foreign Function & Memory API (Preview)
 * [425](https://openjdk.java.net/jeps/425) - Virtual Threads (Preview)
 * [426](https://openjdk.java.net/jeps/426) - Vector API (Fourth Incubator)
 * [427](https://openjdk.java.net/jeps/427) - Pattern Matching for switch (Third Preview)
+* [428](https://openjdk.java.net/jeps/428) - Structured Concurrency (Incubator)
 
 ## Links
 

java-19/RecordPatternsTest.java

@@ -0,0 +1,65 @@
+/**
+ * Run: `java --enable-preview --source 19 RecordPatternsTest.java`
+ */
+public class RecordPatternsTest {
+	public static void main(String[] args) {
+		var p1 = new Point(10, 10);
+		var p2 = new ColoredPoint(new Point(10, 10), Color.GREEN);
+
+		System.out.println("Has collision: " + checkCollisionIfs(p1, p2));
+		System.out.println("Has collision: " + checkCollisionSwitches(p1, p2));
+	}
+
+	static boolean checkCollisionIfs(Object p1, Object p2) {
+		if (p1 instanceof Point(int x1, int y1) && p2 instanceof Point(int x2, int y2)) {
+			return x1 == x2 && y1 == y2;
+		}
+		if (p1 instanceof Point(int x1, int y1) && p2 instanceof ColoredPoint(Point(int x2, int y2), Color c)) {
+			return x1 == x2 && y1 == y2;
+		}
+		if (p1 instanceof ColoredPoint(Point(int x1, int y1), Color c) && p2 instanceof Point(int x2, int y2)) {
+			return x1 == x2 && y1 == y2;
+		}
+		if (p1 instanceof ColoredPoint(Point(int x1, int y1), Color c1)
+			&& p2 instanceof ColoredPoint(Point(int x2, int y2), Color c2)) {
+			return x1 == x2 && y1 == y2;
+		}
+		throw new IllegalArgumentException("Invalid type");
+	}
+
+	static boolean checkCollisionSwitches(Object p1, Object p2) {
+		int x1, y1, x2, y2;
+
+		// Record pattern on switch should be exhaustive (careful with generics on record)
+		switch (p1) {
+			case Point(int px1, int py1) -> {
+				x1 = px1;
+				y1 = py1;
+			}
+			case ColoredPoint(Point(int px1, int py1), Color c) -> {
+				x1 = px1;
+				y1 = py1;
+			}
+			case null, default -> throw new IllegalArgumentException("Invalid type");
+		}
+
+		switch (p2) {
+			case Point(int px2, int py2) -> {
+				x2 = px2;
+				y2 = py2;
+			}
+			case ColoredPoint(Point(int px2, int py2), Color c) -> {
+				x2 = px2;
+				y2 = py2;
+			}
+			case null, default -> throw new IllegalArgumentException("Invalid type");
+		}
+		return x1 == x2 && y1 == y2;
+	}
+}
+
+record Point(int x, int y) {}
+
+enum Color { RED, GREEN, BLUE }
+
+record ColoredPoint(Point p, Color c) {}

java-19/SwitchWithPatternMatchingThirdPreview.java

@@ -0,0 +1,41 @@
+import java.time.LocalDate;
+import java.time.YearMonth;
+import java.time.ZoneOffset;
+import java.time.temporal.ChronoUnit;
+import java.util.stream.Stream;
+
+/**
+ * This preview changed `&&` to `when` in guarded clause.
+ *
+ * Run: `java --enable-preview --source 19 SwitchWithPatternMatchingThirdPreview.java`
+ */
+public class SwitchWithPatternMatchingThirdPreview {
+	public static void main(String[] args) {
+		System.out.println(stringify(42));
+		System.out.println(stringify(-42));
+		System.out.println(stringify("Some text"));
+		System.out.println(stringify(""));
+		System.out.println(stringify(null));
+	}
+
+	static String stringify(Object value) {
+		return switch (value) {
+			// the constant must be before the guarded pattern (otherwise it will never hit)
+			case Integer i when i == 42 -> "42 is the answer";
+			case Integer i when i > 0 -> "positive number";
+			case Integer i when i < 0 -> "negative number";
+			// this must be after because it will match all integers
+			case Integer i -> "should be 0";
+
+			case String s when s.isEmpty() -> "empty string";
+			case String s when s.length() > 50 -> "long string";
+			// this must be after because it will match all strings
+			case String s -> "non-empty string";
+			// same here
+			case CharSequence cs -> "any other CharSequence";
+
+			case null -> "null =s";
+			default -> "unhandled type";
+		};
+	}
+}