How do I use Map.getOrDefault() default method in Java?

By Wayan in Java 8, Util Package 0 Comment

The Map.getOrDefault(Object key, V defaultValue) method in Java 8 is a convenience default method to return the value for a given key. If the map does not contain a mapping for the key, then it returns the default value.

This method can be particularly useful in situations where you’re working with a map and need to fetch a value for a key, but aren’t sure if the key exists in the map. It helps you handle these scenarios without a need to write extra conditional code to check if the key is present (i.e., using containsKey(Object key)) before trying to get the value.

Here’s a common use case without getOrDefault():

Map<String, Integer> map = new HashMap<>();
// fill map...

Integer value;
if (map.containsKey("key")) {
    value = map.get("key");
} else {
    value = -1;
}

Here’s a basic example of how to use getOrDefault():

package org.kodejava.util;

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

public class MapGetOrDefaultExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("A", 1);
        map.put("B", 2);
        map.put("C", 3);

        // Get a value of the key "A". It will return value 1 as
        // "A" is present in the map.
        Integer value = map.getOrDefault("A", -1);
        System.out.println("Value: " + value);

        // Try to get a value of the key "Z". As "Z" is not present
        // in the map, it will return the default value -1.
        value = map.getOrDefault("Z", -1);
        System.out.println("Value: " + value);
    }
}

In this example, “Value: 1” and then “Value: -1” will be printed in the console. In the first case, the key “A” is in the map, so the associated value 1 is returned. In the second case, the key “Z” does not exist in the map, so the default value of -1 is returned.

How do I sort entries of a map by its keys or values?

By Wayan in Java 8, Util Package 0 Comment

To sort the entries of a map by keys or values in Java, you can convert your Map to a Stream, sort it, and then collect it back into a Map.

Here’s an example of sorting by keys:

package org.kodejava.util;

import java.util.HashMap;
import java.util.Map;
import java.util.LinkedHashMap;
import java.util.stream.Collectors;

public class MapSortComparingByKey {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Apple", 10);
        map.put("Orange", 20);
        map.put("Banana", 30);

        Map<String, Integer> sortedByKey = map.entrySet().stream()
                .sorted(Map.Entry.comparingByKey())
                .collect(Collectors.toMap(
                        Map.Entry::getKey,
                        Map.Entry::getValue,
                        (oldValue, newValue) -> oldValue,
                        LinkedHashMap::new
                ));

        sortedByKey.forEach((key, value) -> System.out.println("Key: " + key + ", Value: " + value));
    }
}

Output:

Key: Apple, Value: 10
Key: Banana, Value: 30
Key: Orange, Value: 20

In the example map.entrySet().stream() creates a Stream consisting of the entries in the map. The sorted(Map.Entry.comparingByKey()) method sorts the entries based on keys. The sorted entries are collected back into a new LinkedHashMap (which maintains the order of its elements).

You can sort by values in a similar way:

package org.kodejava.util;

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.stream.Collectors;

public class MapSortComparingByValue {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Apple", 10);
        map.put("Orange", 20);
        map.put("Banana", 30);

        Map<String, Integer> sortedByValue = map.entrySet().stream()
                .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
                .collect(Collectors.toMap(
                        Map.Entry::getKey,
                        Map.Entry::getValue,
                        (oldValue, newValue) -> oldValue,
                        LinkedHashMap::new
                ));

        sortedByValue.forEach((key, value) -> System.out.println("Key: " + key + ", Value: " + value));
    }
}

Output:

Key: Banana, Value: 30
Key: Orange, Value: 20
Key: Apple, Value: 10

In this example, sorted(Map.Entry.<String, Integer>comparingByValue().reversed()) sorts the entries based on values in descending order. The reversed() method is used to reverse the natural ordering. If you want to sort in ascending order, omit the reversed() call.

How do I use the Map.forEach() default method?

By Wayan in Java 8, Util Package 0 Comment

The forEach() method in the Map interface in Java 8, allows you to iterate over each entry in the map, allowing you to use each key-value pair in some way.

Here’s a basic usage of the forEach() method:

package org.kodejava.util;

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

public class MapForEachExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Apple", 10);
        map.put("Orange", 20);
        map.put("Banana", 30);

        // Use the forEach method. Here, each key-value pair is printed.
        map.forEach((key, value) -> System.out.println("Key: " + key + ", Value: " + value));
    }
}

Output:

Key: Apple, Value: 10
Key: Orange, Value: 20
Key: Banana, Value: 30

In this example, a HashMap is created and populated with some data. The forEach method is then called on this map, with a lambda expression that accepts a key and a value, then prints them. The key and value parameters represent the current key-value pair the forEach method is handling. In this lambda expression, they are printed to the console.

This operation is applied to each entry in the map, hence the name forEach.

Using the forEach method with lambda expressions has several benefits:

  1. Improved Readability: Traditional iteration requires creating an iterator, a while or for loop, and handling each element. With forEach and lambdas, you can express what you want to do with each element clearly and concisely, making the code easier to read and understand
  2. Concurrency Safety: The forEach method is inherently safer to use in concurrent environments. You don’t need to worry about ConcurrentModificationException errors which you might get while using an Iterator and modifying the collection concurrently.
  3. Less Boilerplate Code: The forEach function in combination with a lambda function provides a way to iterate over a collection with fewer lines of code compared to using iterators
  4. Functional Programming: Lambda expressions and functional interfaces pave the way towards functional programming in Java, which allows for more expressive ways to manipulate collections.

Remember, although forEach can make your code more concise, it does not necessarily make it faster.

How do I use Map.of() factory method to create a map object?

By Wayan in Java 9, Util Package 0 Comment

In Java, the Map.of() factory method can be used to create an unmodifiable map of specified key-value pairs. This method is available in Java 9 and later versions.

Creating a map is a bit more complicated than creating lists or sets. Because we need to provide keys and values when creating a map. When using the Map.of() factory method we set the content of the map by alternating between the keys and values of the map.

Consider the following example:

package org.kodejava.util;

import java.util.Map;

public class MapOfExample {
    public static void main(String[] args) {
        Map<String, Integer> map = Map.of("John", 25, "Mary", 30, "Alice", 27, "Rosa", 22);

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

Output:

Rosa : 22
Mary : 30
John : 25
Alice : 27

In the example above, the Map.of("John", 25, "Mary", 30, "Alice", 27, "Rosa", 22) statement creates an unmodifiable map with three key-value pairs. After the map is created, any attempt to modify the map (add, update or remove elements) will throw an UnsupportedOperationException.

Note that Map.of() doesn’t accept null keys or values. If a null key or value is provided, then a NullPointerException is thrown. Besides, if duplicate keys are provided, an IllegalArgumentException is thrown.

The Map.of() method is overloaded to accept up to 10 key-value pairs. If there are more than 10 pairs, you can use Map.ofEntries() factory method to create a map. This is how we use it:

Map<String, Integer> map = Map.ofEntries(
    Map.entry("John", 25),
    Map.entry("Mary", 30),
    Map.entry("Alice", 27),
    Map.entry("Bob", 32),
    // ...
);

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

The Map.entry() is another factory method provided to create Map.Entry object.

How do I use map() method of Optional object?

By Wayan in Java 8, Util Package 0 Comment

The map method of the Optional class in Java is used to transform the value contained in the Optional. map allows you to apply a function on the value inside the Optional and returns an Optional that contains the result of the function.

Here is an example of how to use it:

package org.kodejava.util;

import java.util.Optional;

public class OptionalMapExample {
    public static void main(String[] args) {

        // Create an Optional<String>
        Optional<String> optional = Optional.of("Hello");

        // Use map method to transform the contained value
        Optional<Integer> transformedOptional = optional.map(String::length);

        // Use ifPresent to print the result if the Optional is not empty
        transformedOptional.ifPresent(System.out::println);
    }
}

In this example, we start with an Optional<String> that contains the string “Hello”. We then use map to apply the String::length method on the contained string. This transforms the Optional<String> into an Optional<Integer>, where the integer is the length of the string.

Lastly, we use ifPresent to print the result. In this case, the integer 5 will be printed.

Here is another example, where map helps us to handle null values:

Optional<String> optional = Optional.ofNullable(null);

// If optional is not present, it will print "0"
System.out.println(optional.map(String::length).orElse(0));

In this case, trying to apply String::length on a null value would result in a NullPointerException. However, using map in combination with Optional, allows us to safely transform the value and even provide a default result (“0” in this case) if the Optional is empty. This makes handling null values more reliable and your code less error-prone.