The Map.merge method in Java is a convenient way to simplify various kinds of logic that require updating or modifying values in a map, such as counting occurrences. It works by letting you specify how to combine the old value (if it exists) and the new value (to be added). This is particularly useful for implementing counting logic more concisely.

Here’s how you can use Map.merge to count occurrences:

Key Idea

• If the key doesn’t exist in the map, merge inserts it with the given value.
• If the key already exists, merge uses the provided function (a BiFunction) to combine the existing value and the new value.

Example: Counting Word Occurrences in a String

package org.kodejava.util;

import java.util.HashMap;
import java.util.Map;

public class WordCounter {
    public static void main(String[] args) {
        String text = "apple banana apple orange banana apple";

        // Split the string into words
        String[] words = text.split(" ");

        // Map to store word counts
        Map<String, Integer> wordCounts = new HashMap<>();

        // Use Map.merge to simplify counting logic
        for (String word : words) {
            // Increment count for each word
            wordCounts.merge(word, 1, Integer::sum);
        }

        // Print the word counts
        System.out.println(wordCounts);
    }
}

Explanation of merge Usage

In the above example:

1. wordCounts.merge(word, 1, Integer::sum);
   • word is the key.
   • 1 is the value to add (for each occurrence of the word).
   • Integer::sum is the combining function that adds the existing value (if present) and the new value.
     • If the word is already in the map, the count is increased by 1.
     • If the word is not in the map, it is added with an initial count of 1.

Advantages of Using Map.merge for Counting

• Conciseness: Avoids the need for verbose if-else or containsKey checks.
• Thread Safety: Works well in a thread-safe map (e.g., ConcurrentHashMap) without requiring additional synchronization.
• Readability: The code is clear and easy to understand, as the counting logic is encapsulated in a single line.

Without Map.merge

To see why Map.merge simplifies the code, here’s how the same logic would look without it:

for (String word : words) {
    if (wordCounts.containsKey(word)) {
        wordCounts.put(word, wordCounts.get(word) + 1);
    } else {
        wordCounts.put(word, 1);
    }
}

As you can see, it’s more verbose and repetitive compared to using merge.

Other Use Cases for Map.merge

1. Updating a map with custom logic:
   You can combine values in a way that suits your requirements, such as concatenating strings or appending to a list.

2. Tracking multiple values:
   For example, storing a list of values associated with a key while avoiding null checks:

   map.merge(key, new ArrayList<>(List.of(value)), (oldList, newList) -> {
      oldList.addAll(newList);
      return oldList;
   });
   

3. Combining maps:
   Merge entries from one map into another map using custom logic.

In summary, Map.merge helps to simplify and streamline your counting or updating logic by focusing on what to do with existing and new values, while handling key-insertion logic for you.

Java 17 introduced sealed classes as part of the enhancements to the type system. Sealed classes allow developers to explicitly control which classes can extend or implement a class or interface, thereby achieving better type safety and making it easier to design domain-specific hierarchies. Here’s a guide on how to use sealed classes effectively:

What are Sealed Classes?

Sealed classes restrict which other classes or interfaces can extend or implement them. By using sealed classes, you can:

1. Define a closed hierarchy of types where only a fixed set of subtypes is allowed.
2. Ensure better maintainability and readability of your type hierarchy.
3. Provide exhaustive handling for these types with features like switch statements.

The syntax revolves around the sealed, non-sealed, and final keywords.

Declaring and Using Sealed Classes

1. Declaration

To declare a sealed class:

• Use the sealed modifier.
• Specify the permitted subclasses with the permits clause.

package org.kodejava.basic;

public sealed class Shape permits Circle, Rectangle, Square {
   // Common properties and methods for all shapes
}

In this example:

• Shape is the sealed class.
• Only Circle, Rectangle, and Square are allowed to extend Shape.

2. Permitted Subclasses

Every subclass permitted by the sealed class must opt for one of the following:

• final: The subclass cannot be further extended.
• non-sealed: The subclass can be extended by any other class.
• sealed: The subclass restricts its hierarchy further with permits.

Examples:

package org.kodejava.basic;

// Final subclass (cannot have further subclasses)
public final class Circle extends Shape {
   double radius;

   public Circle(double radius) {
      this.radius = radius;
   }
}

package org.kodejava.basic;

// Sealed subclass with its own permitted subclasses
public sealed class Rectangle extends Shape permits RoundedRectangle {
   double width, height;

   public Rectangle(double width, double height) {
      this.width = width;
      this.height = height;
   }
}

package org.kodejava.basic;

// Non-sealed subclass (can have arbitrary subclasses)
public non-sealed class Square extends Shape {
   double side;

   public Square(double side) {
      this.side = side;
   }
}

package org.kodejava.basic;

// Permitted subclass of Rectangle
public final class RoundedRectangle extends Rectangle {
    double cornerRadius;

    public RoundedRectangle(double width, double height, double cornerRadius) {
        super(width, height);
        this.cornerRadius = cornerRadius;
    }
}

Benefits of Sealed Classes

1. Closed Type Hierarchies
   Sealed classes provide an explicit way to define and restrict type hierarchies, avoiding unintended subclasses.

2. Exhaustiveness in switch Statements
   When all subclasses of a sealed class are known, the compiler ensures exhaustiveness in switch expressions. This helps eliminate the possibility of missing a case.

   Example:

   public double calculateArea(Shape shape) {
       return switch (shape) {
           case Circle c -> Math.PI * c.radius * c.radius;
           case RoundedRectangle rr ->
                   rr.width * rr.height - (4 - Math.PI) * rr.cornerRadius * rr.cornerRadius / 4;
           case Rectangle r -> r.width * r.height;
           case Square s -> s.side * s.side;
           default -> throw new IllegalStateException("Unexpected value: " + shape);
       };
   }
   

   If you later add a new subclass to Shape, the compiler will generate an error until you update the switch statement accordingly.

3. Immutability and Security
   By marking direct subclasses as final or controlling further inheritance (e.g., via sealed vs. non-sealed), you ensure immutability in specific contexts and prevent unintended behavior caused by subclassing.

Practical Use Cases for Sealed Classes

1. Domain Modelling
   Example: A sealed class Payment can have subclasses for CreditCardPayment, BankTransfer, and CryptoPayment.

   public sealed class Payment permits CreditCardPayment, BankTransfer, CryptoPayment {
      // Common payment attributes
   }
   
   public final class CreditCardPayment extends Payment {
      // Credit card specific fields
   }
   
   public final class BankTransfer extends Payment {
      // Bank transfer specific fields
   }
   
   public final class CryptoPayment extends Payment {
      // Crypto payment specific fields
   }
   

2. Compiler Assistance for Type-Safe Code
   The sealed hierarchy ensures that when you process these types (e.g., with switch or polymorphic methods), the compiler helps enforce exhaustive handling.

Key Points to Remember

• You must list all permitted subclasses explicitly using the permits clause.
• All subclasses of a sealed class must be declared in the same module or package as the sealed class (enhanced encapsulation).
• sealed, non-sealed, and final define the inheritance relation for permitted subclasses.

Summary

Sealed classes are a powerful tool in Java 17 for creating controlled and predictable type hierarchies. They help enforce constraints at compile-time, reduce runtime errors, and assist developers in creating clean, maintainable, and type-safe code. Use them effectively to create robust domain models and application logic.