Map.ofEntries gives Null Pointer Exception on checking NULL key using containsKey()

Question

I was fetching key from a constant map earlier using HashMap.

On passing a NULL key at containsKey(), I used to get FALSE.

To make the code look fancy, I tried java-8 over it. So, instead of HashMap, I started using Map.ofEntries to build my map

Surprisingly, I got Null Pointer Exception when a Null key was passed to containsKey() method

String str = null;

Map<String,String> hashMap = new HashMap<>();
hashMap.put("k1", "v1");
System.out.print(hashMap.containsKey(str)); // This gives false

Map<String,String> ofEntriesMap = Map.ofEntries( Map.entry("k1", "v1")); 
System.out.print(ofEntriesMap.containsKey(str)); // Why this gives Null Pointer Exception ?

I am unable to figure out, why it is behaving differently at Map.ofEntries.

What is the best way to handle this situation ?

Answer 1

The javadoc of Map says:

Unmodifiable Maps

The Map.of, Map.ofEntries, and Map.copyOf static factory methods provide a convenient way to create unmodifiable maps. The Map instances created by these methods have the following characteristics:

• They are unmodifiable. Keys and values cannot be added, removed, or updated. Calling any mutator method on the Map will always cause UnsupportedOperationException to be thrown. However, if the contained keys or values are themselves mutable, this may cause the Map to behave inconsistently or its contents to appear to change.
• They disallow null keys and values. Attempts to create them with null keys or values result in NullPointerException.
• ...

In contrast, the javadoc of HashMap says:

Hash table based implementation of the Map interface. This implementation provides all of the optional map operations, and permits null values and the null key. (The HashMap class is roughly equivalent to Hashtable, except that it is unsynchronized and permits nulls.) This class makes no guarantees as to the order of the map; in particular, it does not guarantee that the order will remain constant over time.

...

Answer 2

instead of HashMap, I started using Map.ofEntries to build my map

Surprisingly, I got Null Pointer Exception when a Null key was passed to containsKey() method

The documentation for java.util.Map says, in part:

Some map implementations have restrictions on the keys and values they may contain. For example, some implementations prohibit null keys and values, and some have restrictions on the types of their keys. Attempting to insert an ineligible key or value throws an unchecked exception, typically NullPointerException or ClassCastException. Attempting to query the presence of an ineligible key or value may throw an exception, or it may simply return false; some implementations will exhibit the former behavior and some will exhibit the latter.

(Emphasis added.)

As @Andreas's answer already observes, the maps created via Map.ofEntries() are of such an implementation. Specifically, they disallow null keys and values. Although it is not documented whether their containsKey() methods exercise the option to throw when presented with a null argument, you need to use them with that possibility in mind.

On the other hand, as Andreas also shows, HashMap is documented to permit null keys and values, so its containsKey() method is expected to complete normally when passed a null argument.

What is the best way to handle this situation ?

You have two main choices:

• If you want to continue to (directly) use a map created via Map.ofEntries() then you must avoid testing whether it contains null keys. Since you know that it cannot contain null keys, such tests are unnecessary.

• If you want to rely on being able to test null keys' presence in your map, and especially if you want the option of having null keys or null values in it, then you must not use Map.ofEntries() to create it. You might, however, use Map.ofEntries() to initialize it. For example:

  Map<String, String> myMap = Collections.unmodifiableMap(
      new HashMap<String, String>(
          Map.ofEntries(
              Map.Entry("k1", "v1")
          )
      )
  );
  

  Note also that if you are putting fewer than 11 entries in your map, then Map.of() is a bit tidier than Map.ofEntries(). And, of course, if you don't care whether the map is modifiable then you don't have to put it into that unmodifiable wrapper.

Answer 3

This is implementation detail of the unmodifiable map, created by Map.ofEntries.

When you're adding null key to HashMap, it calculates hash of null equal to 0.

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

But Map.ofEntries creates ImmutableCollections.Map1 in case when only one pair was provided and ImmutableCollections.MapN otherwise.

Here is implementation of ImmutableCollections.Map1::containsKey

public boolean containsKey(Object o) {
    return o.equals(k0); // implicit nullcheck of o
}

You can see that comment says that NullPointerException is expected behaviour. As for ImmutableCollections.MapN::containsKey it uses explicit null-check.

public boolean containsKey(Object o) {
        Objects.requireNonNull(o);
        return size > 0 && probe(o) >= 0;
}

If you refer Map::containsKey Javadoc, you can see that it's explicitly said that this method may or may not produce NPE.

Returns true if this map contains a mapping for the specified key. More formally, returns true if and only if this map contains a mapping for a key k such that Objects.equals(key, k). (There can be at most one such mapping.)

Params: key – key whose presence in this map is to be tested

Returns: true if this map contains a mapping for the specified key

Throws: ClassCastException – if the key is of an inappropriate type for this map (optional)

NullPointerException – if the specified key is null and this map does not permit null keys (optional)