docs(JavaEvolution): summarize key Java features from 8 through 25

What
- Documented major Java releases and their landmark features:
  - **Java 8 (2014, LTS)**: Introduced functional programming with lambda expressions, Stream API, and default interface methods.
  - **Java 11 (2018, LTS)**: Added modern HTTP Client API and support for var in lambda parameters.
  - **Java 12 (2019)**: Previewed switch expressions; introduced Shenandoah GC as experimental.
  - **Java 14 (2020)**: Finalized switch expressions as standard.
  - **Java 21 (2023, LTS)**: Delivered virtual threads (Project Loom), pattern matching for switch, sequenced collections, and string templates (preview).
  - **Java 24 (2025)**: Introduced classfile API (preview), scoped values (standard), structured concurrency (2nd preview), and GC improvements.
  - **Java 25 (2025, latest)**: Previewed primitive types in generics (List<int>), advanced Valhalla/Panama work, virtual thread refinements, and GC optimizations.
- Added “Evolution in a Nutshell” section summarizing trajectory from Java 8 to 25.

Why
- Provides a historical and forward-looking overview of Java’s evolution across major versions.
- Highlights both language-level enhancements (lambdas, switch, generics with primitives) and runtime improvements (GC, concurrency).
- Helps developers track which features became standard vs preview/experimental.
- Serves as a quick reference for teams migrating between Java LTS versions.

How
- Organized features chronologically by version.
- Used concise code examples to illustrate major features like lambdas, streams, HTTP client, switch expressions, and virtual threads.
- Clarified preview/experimental vs finalized features.
- Summarized long-term evolution in one compact section.

Logic
- Inputs: chronological release data from Java 8 through Java 25.
- Outputs: curated summary of key features with example code and notes on stability (standard, preview, experimental).
- Flow:
  1. Establish baseline (Java 8’s functional shift).
  2. Show steady incremental updates (Java 11, 12, 14).
  3. Highlight major paradigms added in modern LTS (Java 21).
  4. Cover experimental/preview features in feature releases (Java 24).
  5. End with groundbreaking generics-with-primitives in Java 25.
- Edge cases:
  - Preview/experimental features require enabling JVM flags and may change.
- Complexity / performance:
  - Many features (streams, GCs, virtual threads, primitive generics) are designed to improve expressiveness or runtime efficiency.

Real-life applications
- Java 8 lambdas/streams: data processing pipelines, functional style APIs.
- Java 11 HTTP Client: modern REST clients.
- Java 14 switch expressions: cleaner business logic.
- Java 21 virtual threads: highly concurrent servers (chat, trading, messaging).
- Java 24 scoped values: safe per-task context propagation.
- Java 25 primitive generics: memory- and speed-efficient collections (e.g., List<int>).

Notes
- Java’s cadence of feature releases (every 6 months) plus LTS milestones shapes adoption strategy for enterprises.
- Preview features allow early experimentation but may change in syntax or semantics.
- With Java 25, long-standing limitations (boxed types in generics) are finally addressed.

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

Author: Someshdiwan

Java-Versions/Java Versions.txt

@@ -0,0 +1,100 @@
+Java 8:
+Released in March 2014, Java 8 was a landmark release that introduced true functional programming constructs to the language.
+
+- Lambda Expressions:
+  Treat functionality as data, passing behavior directly into methods for more concise, readable code.
+
+  List<String> list = Arrays.asList("a", "b", "c");
+  list.forEach(element -> System.out.println(element));
+
+- Stream API:
+  Process collections in a declarative, pipeline-oriented style—filtering, mapping, and reducing with ease.
+
+  List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
+  int sum = numbers.stream()
+                   .filter(n -> n % 2 == 0)
+                   .mapToInt(Integer::intValue)
+                   .sum();
+
+- Default Methods in Interfaces:
+  Add new methods to interfaces without breaking existing implementations, enabling library evolution.
+
+
+Java 11:
+Released in September 2018 as a Long-Term Support (LTS) version, Java 11 modernized I/O and refined syntax.
+
+- HTTP Client API:
+  A new, fluent API (sync and async) to replace the legacy HttpURLConnection.
+
+  HttpClient client = HttpClient.newHttpClient();
+  HttpRequest request = HttpRequest.newBuilder()
+      .uri(URI.create("https://example.com"))
+      .build();
+  HttpResponse<String> response =
+      client.send(request, BodyHandlers.ofString());
+  System.out.println(response.body());
+
+- var in Lambda Parameters:
+  Use local-variable type inference (`var`) for lambda parameters, improving consistency with local declarations.
+
+  BiFunction<Integer, Integer, Integer> sum = (var x, var y) -> x + y;
+
+
+Java 12:
+Released in March 2019 as a feature-release (non-LTS), Java 12 introduced experimental and preview features.
+
+- Switch Expressions (Preview):
+  Treat switch as an expression that returns a value, with concise `->` labels and optional `yield`.
+
+  int day = 2;
+  String dayType = switch (day) {
+      case 1, 2, 3, 4, 5 -> "Weekday";
+      case 6, 7          -> "Weekend";
+      default            -> "Invalid day";
+  };
+  System.out.println(dayType);
+
+- Shenandoah GC (Experimental):
+  A low-pause garbage collector targeting large heaps and minimal stop-the-world pauses.
+
+
+Java 14:
+Released in March 2020 (non-LTS), Java 14 finalized several preview features.
+
+- Switch Expressions (Standard):
+  The previewed switch expressions from Java 12 were refined and officially added to the language.
+  The syntax remains the same, with `yield` used for multi-statement branches when necessary.
+
+Java 21 (2023, LTS)
+	•	Virtual Threads (Project Loom): Lightweight threads for massive concurrency.
+	•	Pattern Matching for switch (Standard): More expressive switch with type patterns.
+	•	Sequenced Collections: Preserve element encounter order.
+	•	String Templates (Preview): Safer, cleaner string interpolation.
+
+⸻
+
+Java 24 (2025, Feature)
+	•	Classfile API (Preview): Programmatic manipulation of .class files.
+	•	Scoped Values (Standard): Safer alternative to thread-local storage.
+	•	Structured Concurrency (2nd Preview): Simplified concurrent task management.
+	•	Faster G1/Parallel GC improvements.
+
+⸻
+
+Java 25 (2025, Latest Release - Sep 2025)
+	•	Key Feature:
+	•	Primitive Types in Generics (Preview) – finally allows generics like List<int> (instead of List<Integer>), a huge performance and memory improvement.
+	•	Ongoing Project Valhalla and Project Panama enhancements (value objects, better native interop).
+	•	Virtual Thread refinements for even better performance.
+	•	Latest GC tuning for very large heaps.
+
+Evolution in a Nutshell:
+- Java 8: Brought functional paradigms—lambdas, streams, and interface evolution.
+- Java 11: Modernized HTTP communication and allowed `var` in lambdas.
+- Java 12: Previewed switch expressions and experimented with Shenandoah GC.
+- Java 14: Cemented switch expressions as a core language feature.
+- Java 21 (LTS) → Virtual threads and powerful pattern matching.
+- Java 24 → Scoped values, structured concurrency.
+- Java 25 → Generics with primitives + performance boosts.
+
+Each release builds incrementally on its predecessors, enhancing expressiveness, performance, and modern API support.

Java-Versions/src/Test.java

@@ -0,0 +1,23 @@
+public class Test {
+    public static void main(String[] args) {
+        System.out.println(
+                "Java Versions Repository\n" +
+                        "-------------------------\n" +
+                        "This project is organized by major Java releases (Java 8, 11, 17, 21, etc).\n" +
+                        "Each folder contains examples, notes, and code snippets for features introduced in that version.\n\n" +
+
+                        "Purpose:\n" +
+                        "1. Track Java evolution across versions.\n" +
+                        "2. Provide practical examples for each new feature.\n" +
+                        "3. Help developers quickly learn what changed from one version to another.\n\n" +
+
+                        "Contributions:\n" +
+                        "- Anyone can add new code examples or explanations.\n" +
+                        "- When a new Java version is released, create a new folder (e.g., Java-24) and add examples.\n" +
+                        "- Improve existing notes, add real-world use cases, or fix bugs.\n\n" +
+
+                        "Goal:\n" +
+                        "To build a complete open-source reference of Java features, starting from Java 8 onward."
+        );
+    }
+}