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.

How to Leverage Unnamed Classes and Instance Main in Java 25

By I Wayan Saryada in Basic, Java 25 0 Comment

In Java 25, the introduction of classless main methods and unnamed classes significantly simplifies writing small programs, scripts, and experiments. Here’s how you can leverage these features effectively:

Classless Main Methods

This functionality is aimed at reducing boilerplate for small Java applications. You can now define a main method directly without wrapping it in a class. Here’s how it works:

Example:

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

How to Run:

  • Save the code in a file (e.g., Hello.java).
  • Run it directly using the java command:
java Hello.java
  • Java 25 will automatically recognize the main method as the program entry point.

Unnamed Classes

Unnamed classes provide a way to write anonymous, throwaway code especially suited for quick scripts, utilities, or debugging. Unlike traditional classes, unnamed classes:

  • Do not require a name.
  • Are suitable for containing small amounts of logic that you don’t intend to reuse elsewhere.

Unnamed Class Example:

// Define a main method in an unnamed class
void main() {
    System.out.println("Hello from an unnamed class!");
    Runnable task = () -> System.out.println("Running a task!");
    task.run();
}

This code can live directly in a file like Program.java. Since unnamed classes aren’t intended to have reuse or complex naming, they simplify writing quick logic.

Benefits of Classless Main and Unnamed Classes

  1. Reduced Boilerplate:
    • No need to wrap the main method in a class when running scripts.
    • Great for beginners, scripts, or prototyping.
  2. Script-Like Feel:
    • The execution of .java files directly gives Java a more “script-like” experience.
  3. Quick Experiments:
    • Faster development loop for testing code snippets without creating entire project structures.
  4. Simplified Learning Curve:
    • Removes the complexity of classes for writing basic programs, aiding new learners.

Use Cases

  1. Prototyping:
    • Quickly test small pieces of logic or APIs.
  2. One-Off Scripts:
    • Automate tasks like file processing, network requests, or data transformation without setting up a full Java project.
  3. Education:
    • Ideal for learning Java as you can explore logic first and object-oriented concepts later.
  4. Debugging:
    • Use a single file to test specific functionality while debugging.

Key Details

  • Compatibility: Make sure you’re using Java 25 or above, as earlier versions don’t support these features.
  • Execution: The java command interprets single .java files directly.
  • Limitations:
    • These features are for simplicity and quick scripts. For larger applications, traditional class structures and best practices should be followed.

By leveraging classless main methods and unnamed classes in Java 25, you can write cleaner, more concise code faster than before!

How to use classless main methods in Java 25

By I Wayan Saryada in Basic, Java 25 0 Comment

In Java 25, you can take advantage of the classless main method, allowing you to write short and simple programs without needing to wrap them in a class declaration. This feature is designed to make Java more approachable, especially for quick scripting or beginner-friendly coding introductions.

How to Use Classless Main Methods

  1. Create a Java file:
    Simply start with a .java file, skipping the need for a class declaration. Declare a void main() function as your entry point.

    Example:

    void main() {
   System.out.println("Hello, Java 25!");
}
  2. Run the file:
    Compile and run the program directly using the java command. Java 25 interprets this as an entry-point method.

    java Hello.java
  3. Output:
    The program will execute, and you’ll see the result printed into the terminal:

    Hello, Java 25!

Key Details of Classless Main Methods

  • No public class wrapper needed:
    There’s no need to define a class or include access modifiers like public.

  • Focus on simplicity:
    This syntax makes it easier to write short utility scripts or test snippets without boilerplate.

  • Direct script execution:
    Java 25 allows you to directly execute .java files without manually compiling (javac).

Use Cases

  • Learning Java: Ideal for beginners who want to experiment with Java quickly, without worrying about object-oriented concepts initially.
  • Script Writing: Great for quick scripts, prototyping, or throwaway Java programs.
  • Debugging and One-Liners: Use it to test small snippets or explore functionality without creating entire project structures.

Java 25 is continuing to evolve into a flexible language both for large enterprise systems and small-scale scripting needs with minimal setup.

How do I use Map.forEach() for concise iteration?

By I Wayan Saryada in Util Package 0 Comment

The Map.forEach method in Java provides a concise and elegant way to iterate over all key-value pairs in a Map. This method accepts a lambda function (or method reference), which processes each entry in the map.

Here’s how you can use Map.forEach for concise iteration:

Syntax:

map.forEach((key, value) -> {
    // Your logic here
});

Example:

Suppose you have a map, and you want to print each key-value pair:

Map<String, Integer> map = new HashMap<>();
map.put("Apple", 10);
map.put("Orange", 20);
map.put("Banana", 30);

// Use forEach for iteration
map.forEach((key, value) -> System.out.println("Key: " + key + ", Value: " + value));

Explanation:

  1. Lambda Expression:
    • (key, value) are the parameters representing the key and the value of each entry in the map.
    • The code block after -> defines what happens for each entry in the map.
  2. Conciseness:
    • No need to use nested loops or explicitly retrieve entries from the map using entrySet or keySet.

Use Cases:

  • Logging or printing map entries.
  • Applying transformations (e.g., modifying values).
  • Collecting or filtering certain entries based on some condition.

Method Reference:

If your logic can be represented as a method, you can use a method reference:

map.forEach(System.out::println); // Prints entries like "Apple=10"

This keeps the code concise, readable, and functional.