Java has evolved significantly from Java 8 to Java 21 with key improvements in language features, APIs, performance, and tooling; developers should upgrade to modern LTS versions like Java 17 or 21 to benefit from cleaner syntax, enhanced safety, and better performance. 2. Key language features include var for local-variable type inference, switch expressions for safer and more concise code, records for immutable data carriers without boilerplate, and pattern matching to eliminate explicit casting. 3. Important API enhancements include Stream.toList() for shorter stream collection, Optional.isEmpty() for improved readability, the modern HttpClient for HTTP/2 and async support, and new String methods like isBlank(), lines(), strip(), and repeat(). 4. Performance and tooling improvements include low-latency garbage collectors like ZGC and Shenandoah, strong encapsulation via the module system requiring --add-opens for internal API access, and the ability to run single-file source code directly without compilation. 5. To modernize from Java 8, start with Java 17 or 21, adopt var and records where appropriate, use updated APIs, test with modern GCs for low-latency needs, scan for deprecated APIs using jdeprscan, and ensure build tools are updated for seamless integration, resulting in safer, cleaner, and more maintainable code.

Java has evolved significantly from Java 8—the long-standing favorite among developers—to the modern, feature-rich Java 21. If you're still writing Java 8-style code or just catching up, here’s a practical guide to the key changes and improvements that matter most to developers.

1. Language Features: Beyond Lambdas

Java 8 introduced lambdas and functional interfaces, revolutionizing how we write collections code. But newer versions have added syntax that makes code cleaner and safer.

Local-Variable Type Inference (var) – Java 10

You no longer need to repeat types in local variable declarations:

// Before
Map<String, List<Integer>> userData = new HashMap<>();

// Now
var userData = new HashMap<String, List<Integer>>();

var improves readability, especially with complex generics. Just remember: it’s still statically typed—no dynamic typing here.

Switch Expressions – Java 14 (Standard in 17)

Switch statements got a major upgrade:

// Old way
String dayType;
switch (day) {
    case "MON", "TUE": dayType = "Weekday"; break;
    case "SAT", "SUN": dayType = "Weekend"; break;
    default: dayType = "Invalid";
}

// New way
String dayType = switch (day) {
    case "MON", "TUE" -> "Weekday";
    case "SAT", "SUN" -> "Weekend";
    default -> "Invalid";
};

It’s expression-based, safer (exhaustiveness checks), and avoids fall-through bugs.

Records – Java 16

Need a simple data carrier? Records eliminate boilerplate:

public record User(String name, int age) { }

Auto-generates constructor, accessors, equals(), hashCode(), and toString(). Great for DTOs, REST payloads, or immutable data.

Pattern Matching (instanceof & switch) – Java 16/17/21

No more casting after instanceof:

// Before
if (obj instanceof String) {
    String s = (String) obj;
    System.out.println(s.toUpperCase());
}

// Now
if (obj instanceof String s) {
    System.out.println(s.toUpperCase());
}

And with switch (Java 21):

String result = switch (shape) {
    case Circle c -> "Radius: "   c.radius();
    case Rectangle r -> "Area: "   r.width() * r.height();
    default -> "Unknown";
};

Less boilerplate, fewer bugs.

2. API & Library Improvements

New APIs in java.util and java.util.stream

• Stream.toList() – Java 16: Shorter than collect(Collectors.toList())

  List<String> names = users.stream().map(User::name).toList();

• Optional.isEmpty() – Java 11: More readable than !opt.isPresent()

  if (userOptional.isEmpty()) { ... }

HttpClient – Java 11 (Standard in 17)

Replaces the old, clunky HttpURLConnection. Supports HTTP/2 and async:

var client = HttpClient.newHttpClient();
var request = HttpRequest.newBuilder(URI.create("https://api.example.com/users"))
        .GET()
        .build();

var response = client.send(request, BodyHandlers.ofString());
System.out.println(response.body());

Also supports async with sendAsync().

String Enhancements

• isBlank(), lines(), strip(), repeat() – Java 11/12

  "hello".repeat(3); // "hellohellohello"
  text.lines().forEach(System.out::println); // Stream of lines

3. Performance, Security, and Tooling

Garbage Collectors (G1, ZGC, Shenandoah)

• G1GC became default in Java 9, better for large heaps.
• ZGC (Java 11 , production-ready in 15): Low-latency GC, pauses under 10ms, scales to TBs.
• Shenandoah (Java 12 ): Similar to ZGC, independent of heap size.

Enable ZGC:

java -XX: UseZGC MyApp

Strong Encapsulation with --illegal-access (Java 16 )

Java tightened module encapsulation. Direct access to internal APIs (like sun.misc.Unsafe) is blocked by default. If you rely on reflection or internal APIs, you may need:

--add-opens java.base/java.lang=YOUR_MODULE

Best practice: migrate off internal APIs.

Launch Single-File Source Code – Java 11

Run Java files directly without compiling:

java MyScript.java

Great for scripts, learning, or small utilities.

4. What You Should Do Now

If you're on Java 8, upgrading doesn’t mean rewriting everything. Here’s how to move forward:

• Start with Java 17 (LTS): Long-term support, solid, widely adopted.
• Then consider Java 21 (Latest LTS): Better performance, more features.
• Use var wisely: Only when type is obvious.
• Replace POJOs with records where appropriate.
• Modernize streams and collections with new APIs.
• Test with newer GCs if low latency matters.
• Use jdeprscan to find deprecated APIs in your code.

Also, build tools like Maven and Gradle have excellent Java 17 /21 support now, so CI/CD updates are usually smooth.

Upgrading from Java 8 to 21 isn’t just about new syntax—it’s about writing safer, cleaner, and more maintainable code with better tooling and performance. The ecosystem has moved on, and so should you.

Basically: start small, use LTS versions, and embrace the quality-of-life improvements. It’s not a revolution, but the evolution makes a real difference.

The above is the detailed content of From Java 8 to Java 21: A Developer's Guide. For more information, please follow other related articles on the PHP Chinese website!