How to Simplify Control Flow with Enhanced Switch Statements in Java 25

By I Wayan Saryada in Basic, Java 25 0 Comment

Java 25 introduced Enhanced switch Statements to simplify control flow, making type checks, value comparisons, and complex branching cleaner and more expressive.

Here’s a guide to simplify control flow using this feature:

Key Enhancements in switch

  1. Type Pattern Matching: Directly match and work with variable types in patterns.
  2. Guarded Patterns: Add conditions (when) to patterns for finer control.
  3. Exhaustive Matching: Ensures all possible branches are accounted for (especially useful with sealed classes).
  4. Simplified Null Handling: Handles null without redundant checks.
  5. Nested Patterns: Combine patterns within switch for complex logic.
  6. Constant Matching: Patterns can match constants, combining value comparison and type matching.

How switch is Enhanced

1. Type Pattern Matching

No need for explicit type casting; switch can directly match types and assign to variables.

public static String handleInput(Object input) {
    return switch (input) {
        case String s -> "It's a String: " + s;
        case Integer i -> "It's an Integer: " + (i + 5);
        case Double d -> "It's a Double: " + (d * 2);
        case null -> "Input is null!";
        default -> "Unknown type";
    };
}
  • Why? Simplifies logic by avoiding explicit instanceof checks and casting.

2. Guarded Patterns

Patterns now include when clauses for additional checks within cases.

public static String analyzeNumber(Number number) {
    return switch (number) {
        case Integer i when i > 0 -> "Positive Integer: " + i;
        case Integer i -> "Non-Positive Integer: " + i;
        case Double d when d.isNaN() -> "It's NaN";
        case Double d -> "A Double: " + d;
        default -> "Unknown type of Number";
    };
}
  • Why? Adds flexibility to handle sub-conditions in patterns.

3. Exhaustiveness with sealed Classes

Combining sealed class hierarchies with switch enforces completeness at compile-time by covering all subclasses.

public sealed interface Shape permits Circle, Rectangle {}

public record Circle(double radius) implements Shape {}
public record Rectangle(double width, double height) implements Shape {}

public static String describeShape(Shape shape) {
    return switch (shape) {
        case Circle c -> "Circle with radius: " + c.radius();
        case Rectangle r -> "Rectangle: " + r.width() + "x" + r.height();
    };
}
  • Why? Ensures all cases are handled, or the compiler alerts you of missing subclasses.

4. Null Handling Simplification

Design cases explicitly for null without separate checks.

public static void handleString(String str) {
    switch (str) {
        case null -> System.out.println("String is null!");
        case "Hello" -> System.out.println("Greeting identified!");
        default -> System.out.println("Unrecognized input.");
    }
}
  • Why? Eliminates external if (str == null) checks, merging all logic into switch.

5. Nested Patterns for Complex Scenarios

switch supports nested patterns for deeper matching logic.

public static String processNested(Object obj) {
    return switch (obj) {
        case Circle(double r) when r > 10 -> "Large Circle, radius: " + r;
        case Rectangle(double w, double h) when w == h -> "Square with side: " + w;
        case Rectangle(double w, double h) -> "Rectangle: " + w + "x" + h;
        default -> "Unknown Shape";
    };
}
  • Why? Makes complex decision trees concise and readable.

Advantages of Enhanced switch

  • Cleaner Syntax: Removes verbose if-else or legacy switch cases.
  • More Declarative: Focus on what you’re branching on, not how.
  • Compile-Time Safety: Ensures all branches are accounted for with exhaustive checks.
  • Improved Null Safety: Explicit null cases reduce runtime errors.
  • Seamless with Modern Java Features: Works beautifully with records, sealed classes, and type inference.

When to Use Enhanced switch

  • Type-based control flows where type and values matter (e.g., handling polymorphism elegantly).
  • Complex branching conditions are consolidated into a clean declarative structure.
  • Improved readability and maintainability for large branching logic.

This feature is a step toward making Java code more concise, safer, and expressive!

How to Write Cleaner Code with String Templates in Java

By I Wayan Saryada in Basic, Java 25 0 Comment

String templates in Java 25 introduce a cleaner, more efficient, and safer way to work with strings. They allow embedding expressions inside strings without relying on concatenation or external APIs. Using string templates can lead to code that is easier to understand and maintain.

Here’s how you can write cleaner and more efficient code with string templates in Java 25:

1. Basics of String Templates

String templates allow you to define a string that contains placeholders for expressions. These placeholders are evaluated at runtime. In Java 25, this is done using the STR.""" syntax (or StringTemplate API).

Example:

String name = "John";
int age = 30;

String greeting = STR."""
    Hello, my name is \{name} and I am \{age} years old.
    """;
System.out.println(greeting);

Output:

Hello, my name is John and I am 30 years old.

2. Key Features

  • Dynamic Expressions
    You can embed any expression within the \{} placeholders inside the template.

    int x = 10;
int y = 20;

String result = STR."""
    Sum of x and y is \{x + y}.
    """;
System.out.println(result);
  • Multiline Support
    String templates natively support multiline strings and formatting, making it easier to work with larger templates.

    String paragraph = STR."""
    This is a multiline
    string template with
    expressions like \{"Java " + 25}.
    """;

3. Benefits Over Traditional String Handling

a. Eliminates Boilerplate

Previously, concatenating variables into strings required explicit concatenation or String.format(). This is no longer needed.

// Before Java 25 - verbose
String name = "Alice";
String message = "Hello, " + name + "!";
// or
String message = String.format("Hello, %s!", name);

// Java 25
String message = STR."Hello, \{name}!";

b. Improved Readability

String templates allow templates to resemble the final output, improving readability.

c. Type-Safe

String templates are type-safe, ensuring that runtime errors related to improper formatting are minimized.

4. Compatibility with Existing APIs

String templates can simplify working with APIs like SQL or HTML without extensive external libraries.

Example (SQL):

String tableName = "users";
String query = STR."""
    SELECT * FROM \{tableName}
    WHERE age > 18
    ORDER BY name;
    """;
System.out.println(query);

Example (HTML):

String title = "Welcome";
String template = STR."""
    <html>
        <head><title>\{title}</title></head>
        <body><h1>Hello, \{title}</h1></body>
    </html>
    """;
System.out.println(template);

5. Advanced Use Cases

a. Use with External Formatting Libraries

String templates integrate well with JSON or XML serialization/deserialization.

Example (JSON):

String username = "john_doe";
int userID = 123;

String json = STR."""
    {{
        "username": "\{username}",
        "id": \{userID}
    }}
    """;
System.out.println(json);

b. Avoid Code Injection

String templates are safer, as they encourage proper escaping of user-provided data when combined with API interactions such as SQL or HTML. Proper escaping ensures no code injection vulnerabilities.

6. Custom Formatters

String templates in Java 25 can leverage custom formatters for advanced needs. This allows developers to define how specific types (like dates or numbers) are formatted in the string.

Custom formatting is achieved by extending the template processor.

Example: Formatting a date into a readable format:

import java.time.LocalDate;

LocalDate today = LocalDate.now();

String message = STR."""
   Today's date is \{today.toString()}.
   """;
System.out.println(message);

To include formatting logic, custom processors can modify such outputs.

7. Example: Building APIs with Readable Responses

Here’s an example of using string templates for building responses in web APIs:

public String buildUserResponse(String username, String email) {
    return STR."""
        {
            "username": "\{username}",
            "email": "\{email}"
        }
        """;
}

// Usage
String response = buildUserResponse("alice", "[email protected]");
System.out.println(response);

8. Combining String Templates with Switch Expressions

Java 25 also brings improvements to switch expressions, which can combine well with string templates.

int code = 404;

String message = STR."""
    Status: \{
        switch (code) {
            case 200 -> "Success";
            case 404 -> "Not Found";
            case 500 -> "Server Error";
            default -> "Unknown";
        }
    }
    """;
System.out.println(message);

Summary: Cleaner Code with String Templates

  • Readability: Cleaner and less verbose syntax.
  • Efficiency: Reduces reliance on external formatting libraries or manual concatenation.
  • Safety: Minimized risk of runtime errors and injection vulnerabilities.
  • Integration: Seamlessly used with existing APIs and libraries.

Adopting Java 25 string templates improves the workflow significantly, making your apps cleaner and less error-prone.

How to use record patterns with instanceof in Java 25

By I Wayan Saryada in Basic, Java 25 0 Comment

Java 25 introduces improvements such as record patterns with instanceof, which allow more concise and expressive type matching and data extraction in one step. Here’s a guide on how to use them:

What are record patterns?

A record pattern enables matching and extracting components of a record class, which is essentially a class with immutable data. Record patterns simplify operations by combining type checking and field extraction syntactically.

Using instanceof with Record Patterns

In Java 25, you can use a record pattern directly with instanceof to both:
1. Match the type of the object.
2. Decompose its contents in a single expression.

Example of Record Patterns with instanceof

record Point(int x, int y) {}

public class Main {
    public static void main(String[] args) {
        Object obj = new Point(10, 20);

        // Using instanceof with a record pattern
        if (obj instanceof Point(int x, int y)) {
            System.out.println("Point coordinates: x = " + x + ", y = " + y);
        } else {
            System.out.println("Not a Point object");
        }
    }
}

Explanation

  • obj instanceof Point(int x, int y):
    • Pattern Matching: Verifies if obj is an instance of the Point record.
    • Decomposition: Extracts the x and y fields of the record into variables x and y.

As a result:

  • If obj matches the type, the fields are extracted automatically in the same step.
  • There’s no need to cast obj to Point explicitly or manually call getters.

Nesting Record Patterns

Record patterns can also be nested for more complex records containing other records or collections.

Example: Nested Record Patterns

record Rectangle(Point topLeft, Point bottomRight) {}

public class Main {
    public static void main(String[] args) {
        Object obj = new Rectangle(new Point(0, 0), new Point(10, 10));

        if (obj instanceof Rectangle(Point(int x1, int y1), Point(int x2, int y2))) {
            System.out.println("Rectangle corners: (" + x1 + ", " + y1 + ") to (" + x2 + ", " + y2 + ")");
        } else {
            System.out.println("Not a Rectangle object");
        }
    }
}

Explanation

  • Rectangle(Point(int x1, int y1), Point(int x2, int y2)) is a nested pattern:
    • Matches top-level Rectangle.
    • Decomposes its topLeft and bottomRight fields into Point objects.
    • Further extracts x and y coordinates from each Point.

Benefits

  1. Conciseness: Eliminates the need for explicit casting or redundant getter calls.
  2. Readability: Patterns declaratively show what is being matched and extracted.
  3. Flexibility: Works seamlessly with nested structures.

Good-to-Know Details

  1. Exhaustive Matching: Combine switch with record patterns for exhaustive, cleaner matching: 
    void printShapeInfo(Object shape) {
   switch (shape) {
       case Point(int x, int y) -> System.out.println("Point: (" + x + ", " + y + ")");
       case Rectangle(Point topLeft, Point bottomRight) -> System.out.println("Rectangle with corners: " +
               topLeft + " to " + bottomRight);
       default -> System.out.println("Unknown shape");
   }
}
  2. Null Handling: instanceof with patterns doesn’t match null values directly. An explicit null check is still required.

  3. Restrictions: The immutability of records ensures safety and predictability when decomposing data and matching patterns.

Conclusion

The introduction of record patterns in Java 25 significantly enhances pattern matching and makes working with immutable objects far more intuitive and concise. Whether you’re matching simple records or nested structures, this feature saves you from boilerplate code and improves code readability.

How to use improved pattern matching for switch in Java 25

By I Wayan Saryada in Basic, Java 25 0 Comment

Java 25 introduces an improved feature for pattern matching with switch, further streamlining type checks, instance checks, and value comparisons.

Here’s how you can effectively use the enhanced pattern matching for switch in Java 25:

Key Features

  1. Exhaustive Matching: Ensures that all possible branches are accounted for.
  2. Simplification of Null Handling: Handles null conditions without extra boilerplate.
  3. Nested Patterns in Switch: Allows patterns to be nested for cleaner and more expressive logical flows.
  4. Constant Matching: Can combine constants with patterns.
  5. Sealed Class Support: Works seamlessly with sealed classes, auto-detecting subclasses for exhaustive pattern checks.

Syntax Examples

1. Type Pattern Matching

Allows you to handle specific types directly in a switch.

public static String process(Object obj) {
    return switch (obj) {
        case String s -> "It's a String: " + s;
        case Integer i -> "It's an Integer: " + (i + 10);
        case null -> "It's null!";
        default -> "Unknown type!";
    };
}

2. Guarded Patterns

You can add additional conditions to patterns with when clauses.

public static String process(Number num) {
    return switch (num) {
        case Integer i when i > 0 -> "Positive Integer: " + i;
        case Integer i -> "Other Integer: " + i;
        case Double d -> "Double: " + d;
        default -> "Unknown Number type!";
    };
}

3. Exhaustive Matching with sealed Classes

For sealed class hierarchies, switch ensures all subclasses are accounted for.

public sealed interface Shape permits Circle, Rectangle {}

public record Circle(double radius) implements Shape {}
public record Rectangle(double length, double width) implements Shape {}

public static String shapeInfo(Shape shape) {
    return switch (shape) {
        case Circle c -> "Circle with radius: " + c.radius();
        case Rectangle r -> "Rectangle with dimensions: " + r.length() + " x " + r.width();
    };
}

In this case, if you miss a subclass (like Rectangle), the compiler will throw an exhaustiveness error.

4. Null Handling Simplification

Switch patterns now handle null explicitly or exclude it in non-nullable cases.

public static void handleInput(String input) {
    switch (input) {
        case null -> System.out.println("Input is null!");
        case "SpecificValue" -> System.out.println("Matched SpecificValue");
        default -> System.out.println("Fallback case");
    }
}

Benefits of Improved Pattern Matching

  • Cleaner Code: Avoid type casts and complex if-else chains.
  • More Readable: Logic becomes more declarative and expressive.
  • Compile-Time Safety: Exhaustive checking ensures safer code.
  • Null-Safety: Simplifies handling of null values in branching.

These improvements make switch not just a control-flow statement but a powerful tool for type- and value-based pattern matching.

How to Write Simplified Entry Points with Java 25

By I Wayan Saryada in Basic, Java 25 0 Comment

Java 25 introduces several advancements focusing on simplified and modernized entry points to write cleaner main methods for applications. Here’s an overview of how to leverage these improvements to write simplified entry points:

Understanding Unnamed Classes and Instance Main

Java 25 introduces new features that make defining the main entry point of an application more flexible and concise.

1. Classless Main

You no longer need to define a named class with a main method. Instead, you can use a file containing only the main method logic by employing Unnamed Classes. This simplifies bootstrapping small Java programs.

Example:

void main() {
    System.out.println("Hello, World!");
}

Key Points:

  • The void main() behaves as a class-free entry point.
  • This reduces boilerplate (public class wrappers), improving readability for small programs and scripts.

2. Instance Main

The traditional static void main() requirement is relaxed to allow instance-level main methods. Instance main methods simplify cases when state or instance-specific contexts need initialization.

Example:

void main(String... args) {
    System.out.println("Arguments: " + String.join(", ", args));
}

Benefits:

  • No need to initialize a separate main instance for flexibility.
  • Useful for parameter handling or lightweight application state management.

Improved Argument Handling

Another subtle improvement is streamlined handling of command-line arguments. Java natively supports String... args expansions in a cleaner way with instance-level flexibility.

Example with arguments:

void main(String... args) {
    for (var arg : args) {
        System.out.printf("Received Arg: %s%n", arg);
    }
}

Better Alignment with Scripting Use Cases

Java 25 aims to make it easier to use Java for scripting-style tasks. The addition of Unnamed Classes combined with simplified main points brings Java closer to languages like Python or Kotlin for lightweight scripting purposes.

Example use case: A simple utility script:

void main() {
    int sum = java.util.stream.IntStream.range(1, 10).sum();
    System.out.println("Sum: " + sum);
}

How to Compile and Execute Simplified Java 25 Entry Points

  1. Save the code to a file (e.g., MyScript.java).
  2. Compile the code: 
    javac MyScript.java
  3. Run the compiled file: 
    java MyScript

For unnamed classes, simply use:

java MyScript.java

This eliminates the need for compiling separately before execution.

Advantages of Java 25 Simplified Entry Points

  • Less Boilerplate: No need for class wrappers or public static void definitions for lightweight applications.
  • Script-Like Usage: Java becomes better suited for quick, single-purpose scripts.
  • Enhanced Readability: Especially useful for quick prototyping or teaching Java.

Use Cases for Modern Java Entry Points

  • Scripting: Replace or complement command-line scripts.
  • Tiny CLI Tools: Build simple tools with minimal boilerplate effort.
  • Teaching Java: Simplify examples for teaching or early onboarding for new developers.

Java 25’s enhancements complement the move toward modern and developer-friendly Java programming. By introducing these features, Java bridges the gap between strict static typing and lightweight flexible scripting needs.