HashMap没有添加所有密钥

Question

I am adding strings to a HashMap<String, ChartSeries> but it doesn't add all the strings. It does however change the size integer of the hashmap:

As you can see it says size:6 but when you look into the table it only holds 4 objects.

This is my code:

for (CaseTypeActivationAmount CTAM : caseTypeActivationAmounts) {
    ChartSeries cs;
    if (!caseTypes.containsKey(CTAM.getOmschrijving())) {
        if (CTAM.getOmschrijving() != null) {
            cs = new ChartSeries(CTAM.getOmschrijving());
        } else {
            cs = new ChartSeries(" ");
        }

        caseTypes.put(CTAM.getOmschrijving(), cs);
    } else {
        cs = caseTypes.get(CTAM.getOmschrijving());
    }
    DateFormat dateFormat = new SimpleDateFormat("dd/MM/yy");
    cs.set(dateFormat.format(CTAM.getDate()), CTAM.getAmount());
}

Am I missing something?

Answer 1

when you look into the table it only holds 4 objects.

The table does hold six objects. However, due to hash collisions, it holds them in only four separate chains .

You can see what's going on in the debugger: open the value of each node, and examine the next value. You will find that either (1) two of the six nodes have a second item, or (2) one of the six nodes has two additional items in its chain, for the overall count of six objects.

Answer 2

Yes, you are missing something. Each position of the backing array of the HashMap can hold a reference to a single HashMap.Node . However, that Node does not necessarily contain just a single Map.Entry . It can contain a linked-list or tree of Entries which were mapped to the same bucket (bit) of the HashMap .

Therefore the 4 Node s you are seeing do not correspond with 4 Entries.

If you iterate over the entrySet of the map you'll see all 6 Entries.

Answer 3

Those are Node s, actually LinkedNodes. The hashcode of some of the keys are equal, and you get more then one entry in the same bucket.

One of the HashMap$Node that you see is actually :

 HashMap$Node -> HashMap$Node(next)...

Here is how it actually looks internally:

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    V value;
    Node<K,V> next; // NOTICE the next here

When you go after a certain limit, those Nodes are going to become TreeNodes (holding an entire Tree of Entries) in a single bucket.