当 root == null 时，Java TreeMap put() 方法中的 compare(key, key) 的目的是什么？

Question

I am reading Java 1.8 TreeMap source code. The put method is written as below:

public V put(K key, V value) {
    Entry<K,V> t = root;
    if (t == null) {
        compare(key, key); // type (and possibly null) check

        root = new Entry<>(key, value, null);
        size = 1;
        modCount++;
        return null;
    }
...... //more code
}

When root == null, which means that it is the first time for us to put an Entry, why we still need to compare the key itself before we assign the entry to root?

BTW, compare method is:

final int compare(Object k1, Object k2) {
    return comparator==null ? ((Comparable<? super K>)k1).compareTo((K)k2)
        : comparator.compare((K)k1, (K)k2);
}

Answer 1

The comment explains why:

// type (and possibly null) check

This compare will ensure that key is not null , and has the expected type, before it is stored in the map.

In the compare method, as shown, the key is either cast to a Comparable , and has compareTo invoked, or it is passed as an argument to the comparator . These operations will fail with either NullPointerException s or ClassCastExceptions if key is null , or not of the required type for the comparator to handle.

Answer 2

The comment hints at what is going on.

// type (and possibly null) check

A correctly implemented Comparator or Comparable will check that its arguments have types that it understands before comparing them. It may also test if the arguments are not null ... depending on whether it implements an ordering where null is or isn't allowed.

By using compare to compare the initial key to itself, the code is checking that key has an appropriate type, and optionally that it is not null .

---

You commented:

but the compare method seems not do the type and null check

This is the code you are talking about.

final int compare(Object k1, Object k2) {
    return comparator==null ? ((Comparable<? super K>)k1).compareTo((K)k2)
        : comparator.compare((K)k1, (K)k2);
}

The checks we are talking about happen as follows.

• When comparator is null :

  • An implicit null check on k1 occurs when k1.compareTo(k2) is called.
  • A type check occurs in the (Comparable) cast to ensure that k1 is a Comparable .
  • A second type check will typically happen within the key's compareTo method.

• When comparator is not null , the type check and the (optional in this case) null check happen within the Comparator<K>.compare method that we are calling.

(The casts to (K) are unchecked type casts and won't do any actual type checking.)