Java – why do we have immutable empty maps?

/**

/**
 * Returns the empty map (immutable).  This map is serializable.
 *
 * <p>This example illustrates the type-safe way to obtain an empty set:
 * <pre>
 *     Map&lt;String,Date&gt; s = Collections.emptyMap();
 * </pre>
 * Implementation note:  Implementations of this method need not
 * create a separate <tt>Map</tt> object for each call.   Using this
 * method is likely to have comparable cost to using the like-named
 * field.  (Unlike this method,the field does not provide type safety.)
 *
 * @see #EMPTY_MAP
 * @since 1.5
 */
@SuppressWarnings("unchecked")
public static final <K,V> Map<K,V> emptyMap() {
    return (Map<K,V>) EMPTY_MAP;
}

The above function returns an immutable empty graph

public static final Map EMPTY_MAP = new EmptyMap<>();

The emptymap class is as follows

/**
 * @serial include
 */
private static class EmptyMap<K,V>
    extends AbstractMap<K,V>
    implements Serializable
{
    private static final long serialVersionUID = 6428348081105594320L;

    public int size()                          {return 0;}
    public boolean isEmpty()                   {return true;}
    public boolean containsKey(Object key)     {return false;}
    public boolean containsValue(Object value) {return false;}
    public V get(Object key)                   {return null;}
    public Set<K> keySet()                     {return emptySet();}
    public Collection<V> values()              {return emptySet();}
    public Set<Map.Entry<K,V>> entrySet()      {return emptySet();}

    public boolean equals(Object o) {
        return (o instanceof Map) && ((Map<?,?>)o).isEmpty();
    }

    public int hashCode()                      {return 0;}

    // Preserves singleton property
    private Object readResolve() {
        return EMPTY_MAP;
    }
}

What is the purpose of this class and utility method? I tried

Map myMap = Collections.emptyMap();
myMap.put("Name","John");

I'm on the thread "main" Java Get an exception in lang.unsupported operationexception because the collection is immutable and modification is not supported So what does such a data structure use?

Solution

If you return a map result, it is usually immutable. For example, you can create an immutable map to wrap your own "real" data without having to create a complete copy or trust the caller not to mutate

In addition, if you return an empty map result, it is convenient not to create a new object every time - each empty map is equal to each empty map, so it is good to use an instance