What is the use of adding a null key or value to a HashMap in Java?

HashMap allows one null key and any number of null values. What is the use of it?

I'm not positive what you're asking, but if you're looking for an example of when one would want to use a null key, I use them often in maps to represent the default case (i.e. the value that should be used if a given key isn't present):

Map<A, B> foo;
A search;
B val = foo.containsKey(search) ? foo.get(search) : foo.get(null);

HashMap handles null keys specially (since it can't call .hashCode() on a null object), but null values aren't anything special, they're stored in the map like anything else

One example would be for modeling trees. If you are using a HashMap to represent a tree structure, where the key is the parent and the value is list of children, then the values for the null key would be the root nodes.

One example of usage for null values is when using a HashMap as a cache for results of an expensive operation (such as a call to an external web service) which may return null.

Putting a null value in the map then allows you to distinguish between the case where the operation has not been performed for a given key (cache.containsKey(someKey) returns false), and where the operation has been performed but returned a null value (cache.containsKey(someKey) returns true, cache.get(someKey) returns null).

Without null values, you would have to either put some special value in the cache to indicate a null response, or simply not cache that response at all and perform the operation every time.

The answers so far only consider the worth of have a null key, but the question also asks about any number of null values.

The benefit of storing the value null against a key in a HashMap is the same as in databases, etc - you can record a distinction between having a value that is empty (e.g. string ""), and not having a value at all (null).

Here's my only-somewhat-contrived example of a case where the null key can be useful:

public class Timer {
	private static final Logger LOG = Logger.getLogger(Timer.class);
	private static final Map<String, Long> START_TIMES = new HashMap<String, Long>();
	
	public static synchronized void start() {
		long now = System.currentTimeMillis();
		if (START_TIMES.containsKey(null)) {
			LOG.warn("Anonymous timer was started twice without being stopped; previous timer has run for " + (now - START_TIMES.get(null).longValue()) +"ms"); 
		}
		START_TIMES.put(null, now);
	}
	
	public static synchronized long stop() {
		if (! START_TIMES.containsKey(null)) {
			return 0;
		}
		
		return printTimer("Anonymous", START_TIMES.remove(null), System.currentTimeMillis());
	}
	
	public static synchronized void start(String name) {
		long now = System.currentTimeMillis();
		if (START_TIMES.containsKey(name)) {
			LOG.warn(name + " timer was started twice without being stopped; previous timer has run for " + (now - START_TIMES.get(name).longValue()) +"ms"); 
		}
		START_TIMES.put(name, now);
	}
	
	public static synchronized long stop(String name) {
		if (! START_TIMES.containsKey(name)) {
			return 0;
		}
		
		return printTimer(name, START_TIMES.remove(name), System.currentTimeMillis());
	}
	
	private static long printTimer(String name, long start, long end) {
		LOG.info(name + " timer ran for " + (end - start) + "ms");
		return end - start;
	}
}

Another example : I use it to group Data by date. But some data don't have date. I can group it with the header "NoDate"

A null key can also be helpful when the map stores data for UI selections where the map key represents a bean field.

A corresponding null field value would for example be represented as "(please select)" in the UI selection.