How do I use ConcurrentHashMap.computeIfAbsent safely?

By I Wayan Saryada in Util Package 0 Comment

To safely use ConcurrentHashMap.computeIfAbsent, it’s important to understand both its purpose and how to use it in a thread-safe manner.

Purpose of computeIfAbsent

computeIfAbsent is a method of ConcurrentHashMap that:

  1. Checks if the key exists in the map.
  2. If the key exists, it returns the associated value.
  3. If the key does not exist, it computes a value for the key using the provided function, inserts the computed value into the map, and returns the value.

This method is thread-safe, meaning:

  • It guarantees atomicity when checking for the key, computing the value, and inserting it into the map.
  • Multiple threads can safely call this method without introducing non-deterministic behavior or data race conditions.

Safe Usage Guidelines

  1. Avoid Side Effects in the Mapping Function:
    The computation function should not introduce side effects or interfere with the ConcurrentHashMap itself. Modifying the map inside the mapping function or depending on the external mutable shared state can lead to unexpected behavior.

    Example of unsafe behavior:

    map.computeIfAbsent(key, k -> {
   map.put(someOtherKey, someOtherValue);  // Modifies the map during compute
   return calculateValue(k);
});

    Instead, the function should remain isolated and focus solely on deriving a value for the given key.

  2. Concurrency Is Handled For You:
    There’s no need for explicit synchronization or locking when using computeIfAbsent. The method ensures that the check and computation happen atomically for each key.

    Example:

    ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();
String value = map.computeIfAbsent("key", k -> "computedValue");
  3. Be Careful with Long/Expensive Computations:
    If the computation logic in computeIfAbsent is long-running or expensive, this can lead to contention or delays when multiple threads are trying to compute values for the same key. If you expect expensive computations:

    • Offload the computation to a dedicated service or background thread pool.
    • Return placeholders immediately if possible and fill them later.
  4. Guard Against Null Values:
    While ConcurrentHashMap does not allow null keys or values, the mapping function might inadvertently return a null value. This will result in a NullPointerException. Always ensure that the computation logic does not return null.

    Example check:

    map.computeIfAbsent("key", k -> {
   String result = computeValue(k);
   return (result != null) ? result : "defaultValue";
});
  5. Avoid Recursive Dependencies:
    Do not create circular dependencies where computeIfAbsent recursively triggers a computation for the same key or related keys. This can cause a StackOverflowError.

Practical Example

Here’s a robust example:

package org.kodejava.util.concurrent;

import java.util.concurrent.ConcurrentHashMap;

public class ComputeIfAbsentExample {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

        // Safe and efficient usage of computeIfAbsent
        Integer value = map.computeIfAbsent("item", key -> {
            // Expensive or non-trivial computation can go here
            return key.length();  // Mapping key to length as the value
        });

        System.out.println("Value: " + value);  // Output: Value: 4
    }
}

Summary

Using ConcurrentHashMap.computeIfAbsent safely involves:

  • Avoiding side effects in the mapping function.
  • Being cautious with long or expensive computations.
  • Ensuring the mapping function does not return null.
  • Relinquishing explicit synchronization, as it’s already atomic.
  • Avoiding recursive or circular dependencies in value computation.

By adhering to these guidelines, you can leverage the method effectively, even in highly concurrent environments.

How do I use LinkedHashMap for predictable iteration order?

By I Wayan Saryada in Util Package 0 Comment

In Java, a LinkedHashMap is a subtype of HashMap that maintains a predictable iteration order. It uses a doubly linked list to store the entries in insertion order (or, optionally, access order). Here’s how you can use LinkedHashMap for predictable iteration order:

1. Maintaining Insertion Order

By default, a LinkedHashMap iterates its entries in the order they were inserted. This is useful when you want to retrieve elements in the same order you added them.

Here’s an example:

package org.kodejava.util;

import java.util.LinkedHashMap;
import java.util.Map;

public class LinkedHashMapExample {
    public static void main(String[] args) {
        // Creating LinkedHashMap
        Map<String, Integer> map = new LinkedHashMap<>();

        // Adding elements (insertion order)
        map.put("One", 1);
        map.put("Two", 2);
        map.put("Three", 3);
        map.put("Four", 4);

        // Iterating through the map
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println(entry.getKey() + " => " + entry.getValue());
        }
    }
}

Output:

One => 1
Two => 2
Three => 3
Four => 4

In this example, the elements are iterated in the same order they were inserted.

2. Maintaining Access Order

You can configure a LinkedHashMap to maintain access order, which means it reorders entries based on the most recent access. To enable access order, you must use the constructor that takes a boolean parameter for accessOrder.

Here’s an example:

package org.kodejava.util;

import java.util.LinkedHashMap;
import java.util.Map;

public class AccessOrderExample {
    public static void main(String[] args) {
        // Creating LinkedHashMap with access-order
        Map<String, Integer> map = new LinkedHashMap<>(16, 0.75f, true);

        // Adding elements
        map.put("One", 1);
        map.put("Two", 2);
        map.put("Three", 3);

        // Accessing some elements
        map.get("One");  // Access "One"
        map.get("Three"); // Access "Three"

        // Iterating through the map
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println(entry.getKey() + " => " + entry.getValue());
        }
    }
}

Output:

Two => 2
One => 1
Three => 3

In this case:

  • Initially, the insertion order was One, Two, Three.
  • After accessing One and Three, they were moved to the end, making Two the first in the iteration order.

3. Removing the Oldest Entry with Access Order

If needed, you can use a LinkedHashMap in combination with its removeEldestEntry method to automatically remove the oldest entry (e.g., implementing a cache).

Here’s how:

package org.kodejava.util;

import java.util.LinkedHashMap;
import java.util.Map;

public class RemoveEldestExample {
    public static void main(String[] args) {
        // Create LinkedHashMap with override for removeEldestEntry
        LinkedHashMap<String, Integer> map = new LinkedHashMap<>(3, 0.75f, true) {
            @Override
            protected boolean removeEldestEntry(Map.Entry<String, Integer> eldest) {
                return size() > 3; // Remove oldest if size > 3
            }
        };

        // Adding elements
        map.put("One", 1);
        map.put("Two", 2);
        map.put("Three", 3);
        map.put("Four", 4); // "One" will be removed here

        // Accessing some elements
        map.get("Two");
        map.put("Five", 5); // "Three" will be removed here

        // Iterating through the map
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println(entry.getKey() + " => " + entry.getValue());
        }
    }
}

Output:

Four => 4
Two => 2
Five => 5

Explanation:

  1. The map was set to remove the eldest (first) entry when its size exceeds 3.
  2. When "Four" was added, "One" was removed because the size limit was exceeded.
  3. When "Five" was added, "Three" was removed, as it was now the eldest entry after accessing "Two".

Summary of Key Points:

  1. Insertion Order: By default, the iteration order matches the insertion order.
  2. Access Order: Can be enabled using the LinkedHashMap constructor with accessOrder = true.
  3. Custom Behavior: Override the removeEldestEntry method to create a fixed-size cache or similar functionality.

LinkedHashMap is handy when you need consistent iteration order (e.g., for caches, ordering-sensitive collections).

How do I use Collectors.groupingBy() with downstream collectors?

By I Wayan Saryada in Stream API, Util Package 0 Comment

The Collectors.groupingBy is a powerful method in Java’s Stream API that allows grouping of elements in a stream based on a classification function, and it works well with downstream collectors. Here’s how you can use Collectors.groupingBy with downstream collectors effectively.

Syntax of Collectors.groupingBy with a Downstream Collector

The key method signature is:

Collectors.groupingBy(Classifier, Downstream)
  • Classifier: A function that determines how the elements are grouped (e.g., based on a key derived from the element).
  • Downstream Collector: The collector used to process the grouped elements further (e.g., counting, mapping, reducing, collecting to a list, etc.).

Example 1: Grouping Elements and Counting Them

To group elements based on a key and count the number of elements in each group:

Map<String, Long> result = items.stream()
    .collect(Collectors.groupingBy(
        item -> item.getCategory(), // Classifier
        Collectors.counting()       // Downstream collector
    ));
  • This produces a map where the key is the category, and the value is the count of items in that category.

Example 2: Group and Collect as a List

If you want to group the elements and collect them in lists:

Map<String, List<Item>> result = items.stream()
    .collect(Collectors.groupingBy(
        item -> item.getCategory(), // Classifier
        Collectors.toList()         // Downstream collector
    ));
  • Groups all elements into lists under their respective categories.

Example 3: Group and Use Summarizing Collector

To produce a statistical summary (e.g., count, sum, min, max, average) for each group:

Map<String, DoubleSummaryStatistics> result = items.stream()
    .collect(Collectors.groupingBy(
        item -> item.getCategory(), // Classifier
        Collectors.summarizingDouble(Item::getPrice) // Summarizing collector
    ));
  • This gives a map where each group has a DoubleSummaryStatistics object that includes the sum, count, min, max, and average for the prices in that group.

Example 4: Group and Reduce Values

To group elements and simultaneously reduce the values for each group:

Map<String, Optional<Item>> result = items.stream()
    .collect(Collectors.groupingBy(
        item -> item.getCategory(),                      // Classifier
        Collectors.reducing((item1, item2) -> 
            item1.getPrice() > item2.getPrice() ? item1 : item2) // Downstream: Find max price
    ));
  • This produces a map where each category has an Optional<Item> representing the item with the highest price.

Example 5: Multi-Level Grouping

You can nest multiple groupingBy collectors to perform hierarchical grouping:

Map<String, Map<String, List<Item>>> result = items.stream()
    .collect(Collectors.groupingBy(
        Item::getCategory,        // First-level group by category
        Collectors.groupingBy(Item::getType) // Second-level group by type
    ));
  • This creates a nested map where the first key is the category, and the value contains another map grouped by type.

Practical Example Walkthrough:

If you have a list of strings and want to:

  • Group them by their length.
  • Collect their counts using Collectors.counting().

Here’s how:

List<String> names = List.of("apple", "banana", "orange", "kiwi", "pear");

Map<Integer, Long> groupedCounts = names.stream()
    .collect(Collectors.groupingBy(
        String::length,       // Classifier: Group by string length
        Collectors.counting() // Downstream collector: Count elements
    ));

System.out.println(groupedCounts);
// Output: {4=2, 5=2, 6=1}

Key Points of Using Downstream Collectors:

  1. Flexibility: You can use different collectors (e.g., toList, toSet, counting, joining, etc.) to define how grouped elements are processed.
  2. Composition: Downstream collectors can be combined, nested, or customized using collectingAndThen or reducing.
  3. Extensibility: Custom Collector implementations can be used as downstream collectors for complex use cases.

This approach simplifies processing grouped data and eliminates the need for verbose loops or manual grouping logic.

How do I use Stream.ofNullable() for Optional Streams?

By I Wayan Saryada in Java 9, Util Package 0 Comment

The Stream.ofNullable method in Java is a utility introduced in Java 9. It is used to create a stream from an object that may or may not be null. This is especially useful when dealing with optional values where you want to avoid manually checking if a value is null before creating a stream.

Here’s how Stream.ofNullable works:

  1. If the passed object is not null, it creates a stream containing that single element.
  2. If the passed object is null, it creates an empty stream.

This is particularly effective when you need to safely process nullable values in a stream pipeline without additional null checks.

Syntax:

Stream.ofNullable(T t)

Parameters:

  • t: The object that you want to create a stream from (nullable).

Returns:

  • A stream consisting of the specified element if it is non-null.
  • An empty stream if the element is null.

Example Usage:

Basic Example

package org.kodejava.util.stream;

import java.util.stream.Stream;

public class StreamOfNullableExample {
    public static void main(String[] args) {
        String value = "Hello, World!";
        Stream<String> stream1 = Stream.ofNullable(value);
        stream1.forEach(System.out::println); // Outputs: Hello, World!

        String nullValue = null;
        Stream<String> stream2 = Stream.ofNullable(nullValue);
        stream2.forEach(System.out::println); // Outputs nothing (empty stream)
    }
}

Combining with Other Stream Operations

package org.kodejava.util.stream;

import java.util.stream.Collectors;
import java.util.List;
import java.util.stream.Stream;

public class OptionalStreamExample {
    public static void main(String[] args) {
        String[] values = { "one", null, "three", null };

        // Collect all non-null values into a list
        List<String> nonNullValues = Stream.of(values)
            .flatMap(Stream::ofNullable) // Process each value safely, handling nulls
            .collect(Collectors.toList());

        System.out.println(nonNullValues); // Outputs: [one, three]
    }
}

Practical Example with Optional

When dealing with Optional values, you can use Stream.ofNullable to easily integrate with other streams.

package org.kodejava.util.stream;

import java.util.Optional;
import java.util.stream.Stream;

public class OptionalToStreamExample {
    public static void main(String[] args) {
        Optional<String> optionalValue = Optional.of("Hello, Optional!");

        // Convert Optional to Stream and process
        Stream<String> stream = Stream.ofNullable(optionalValue.orElse(null));
        stream.forEach(System.out::println); // Outputs: Hello, Optional!
    }
}

Key Highlights of Stream.ofNullable:

  • Avoids the need for null checks when creating streams for nullable values.
  • Simplifies stream pipelines where null handling is required.
  • Works well with flatMap to filter null values while processing arrays, collections, or optionals.

By using Stream.ofNullable, you can write cleaner, safer, and more concise code when dealing with nullable values in streams.

How do I use Map.copyOf() for Immutable Maps?

By I Wayan Saryada in Java 10, Util Package 0 Comment

In Java, the Map.copyOf() method, introduced in Java 10, is a factory method used to create an unmodifiable (immutable) copy of a given Map. This method ensures that the resulting Map cannot be modified, and attempting to do so throws an UnsupportedOperationException.

Here’s how to use it effectively:

Syntax:

public static <K,V> Map<K,V> copyOf(Map<? extends K,? extends V> map)
  • Parameters: A single map (Map<? extends K, ? extends V> to copy).
  • Returns: An unmodifiable copy of the given map.
  • Throws:
    • NullPointerException if the provided map or any of its keys/values is null (this method does not allow null as keys or values).
    • IllegalArgumentException if there are duplicate keys in the map.

Examples

1. Creating an Immutable Map from an Existing Map

package org.kodejava.util;

import java.util.Map;

public class MapCopyOfExample {
    public static void main(String[] args) {
        // Original mutable map
        Map<Integer, String> originalMap = Map.of(1, "One", 2, "Two", 3, "Three");

        // Creating an immutable copy
        Map<Integer, String> immutableMap = Map.copyOf(originalMap);

        // Attempting to modify will throw UnsupportedOperationException
        System.out.println(immutableMap); // Output: {1=One, 2=Two, 3=Three}

        // Uncommenting the following line will throw an error
        // immutableMap.put(4, "Four");
    }
}

2. Avoiding Redundant Copies

Map.copyOf() avoids redundant copying. If the input Map is already unmodifiable (e.g., created using Map.copyOf() or Map.of()), it simply returns the same instance.

Map<String, String> immutableMap1 = Map.of("Key1", "Value1", "Key2", "Value2");

// Reusing the immutable instance
Map<String, String> immutableMap2 = Map.copyOf(immutableMap1);

System.out.println(immutableMap1 == immutableMap2); // Output: true

3. Copying a Mutable Map

A mutable map can be made immutable using Map.copyOf().

package org.kodejava.util;

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

public class MutableToImmutable {
    public static void main(String[] args) {
        // Create a mutable map
        Map<String, String> mutableMap = new HashMap<>();
        mutableMap.put("A", "Apple");
        mutableMap.put("B", "Banana");

        // Make an immutable copy
        Map<String, String> immutableMap = Map.copyOf(mutableMap);

        // Attempting to modify the copy throws an exception
        System.out.println(immutableMap); // Output: {A=Apple, B=Banana}

        // mutableMap.put("C", "Cherry"); // Allowed for mutableMap
        // immutableMap.put("C", "Cherry"); // Throws UnsupportedOperationException
    }
}

Notes about Map.copyOf()

  1. Null Values/Keys:
    • Both keys and values must be non-null; otherwise, a NullPointerException will be thrown.
  2. Immutable Nature:
    • The map returned is truly immutable. Not only are modifications disallowed, but if the input map is mutable, changes to the input do not affect the immutable map.
  3. Alternative Methods:
    • Map.of() can also be used to create immutable maps directly, but it requires you to specify the entries upfront.

Key Differences: Map.copyOf() vs Map.of()

Feature Map.copyOf() Map.of()
Input Accepts an existing map Accepts individual key-value pairs
Suitability for Copy Used to copy an existing map Used to create new map
Duplicates Rejects duplicates in the source map Doesn’t allow duplicates
Empty Map Works with an empty map Use Map.of() for emptiness

Summary

The Map.copyOf() method is a lightweight way to create immutable maps, especially from existing maps. It’s perfect for ensuring immutability and avoiding unintentional modifications to data structures. Use it where immutability is key, such as shared configurations, constants, or thread-safe data sharing!