HashMap与HashSet插入行为差异：为何内部基于HashMap却处理不同？

Great question! This is such a common "wait, that doesn't make sense at first" moment when you dig into Java's collection internals. Let's break this down clearly.

First, let's confirm the underlying relationship: yes, HashSet is built on top of HashMap. When you add an element to a HashSet, it stores that element as a key in a hidden HashMap, using a constant dummy Object (usually called PRESENT) as the associated value—this value never changes, it's just a placeholder.

So why the different behavior? It all comes down to what each collection is designed to do:

1. HashMap's Core Purpose: Store Key-Value Pairs #

HashMap exists to map unique keys to values. When you call put(K key, V value):

• If the key doesn't exist, it adds the new key-value pair and returns null.
• If the key already exists, it replaces the old value with the new one and returns the old value.

This makes sense for a key-value store—you often want to update the value tied to a key. For example:

HashMap<String, Integer> fruitCounts = new HashMap<>();
fruitCounts.put("apple", 5); // Adds "apple" -> 5
fruitCounts.put("apple", 10); // Replaces with "apple" -> 10 (returns 5)

2. HashSet's Core Purpose: Store Unique Elements #

HashSet only cares about keeping a collection of unique elements—it has no use for "values" at all. Its add(E e) method wraps around HashMap's put but adds a critical check:

• When it calls map.put(e, PRESENT), it looks at the return value.
  • If the return is null, the key (your element) didn't exist before—so the element is added successfully, and add returns true.
  • If the return is the PRESENT constant, the key already existed—so HashSet ignores the duplicate, and add returns false without making any changes.

Here's that logic in action:

HashSet<String> uniqueFruits = new HashSet<>();
uniqueFruits.add("apple"); // Adds "apple", returns true
boolean wasAdded = uniqueFruits.add("apple"); // Returns false, no change to the set

The Bottom Line #

HashSet doesn't "override" HashMap's behavior—it leverages HashMap's key uniqueness feature to achieve its own goal. Since HashSet has no use for the "value" part of the HashMap entry, it doesn't bother updating the dummy value (it's the same every time anyway). Instead, it just checks whether the element was already present via the put method's return value, then decides to either add the element or ignore it.

内容的提问来源于stack exchange，提问作者Ankush Dutt