Q: Why using field `threshold` to hold initial capacity instead of an additional field like `initialCapacity` that is clearer? HashMap's constructor
/**
 * Constructs an empty <tt>HashMap</tt> with the specified initial
 * capacity and load factor.
 *
 * @param  initialCapacity the initial capacity
 * @param  loadFactor      the load factor
 * @throws IllegalArgumentException if the initial capacity is negative
 *         or the load factor is nonpositive
 */
public HashMap(int initialCapacity, float loadFactor) {
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal initial capacity: " +
                initialCapacity);
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal load factor: " +
                loadFactor);
    this.loadFactor = loadFactor;
    this.threshold = tableSizeFor(initialCapacity); // here, threadshold is actually initial capacity
}

I'm a little bit confused when reading the code. My question is that why using field threshold to hold initial capacity instead of an additional field like initialCapacity that is clearer?

Edit: I didn't notice that the constructor accept param initialCapacity, I think that the constructor param initialCapacity should be specifiedInitialCapacity.

A: Because HashMaps grow more than once, and the threshold is a dynamic value. It changes during the lifecycle of the Map and is adapted, whenever the map is resized.
Javadoc for threshold (1.8 openjdk):
/**
 * The next size value at which to resize (capacity * load factor).
 *
 * @serial
 */
// (The javadoc description is true upon serialization.
// Additionally, if the table array has not been allocated, this
// field holds the initial array capacity, or zero signifying
// DEFAULT_INITIAL_CAPACITY.)
int threshold;

Since the map can be resized, the initial capacity is just that, and the threshold is only the same initially.
