java HashMap inserts duplicate Key values

To insert duplicate values ??in HashMap, you first need to figure out how elements are stored in HashMap.

put method

Every element stored in the Map is a key-value pair, and they are all added through the put method, and the same key is only There will be a value associated with it. The put method is defined as follows in Map.

V put(K key, V value);

put() method implementation:

First hash(key) gets the hashcode() of the key, and the hashmap finds the chain where the location to be inserted is based on the hashcode obtained. , all Entry key-value pairs with the same hashcode are placed in this chain. After finding this chain, it will use the equals() method to determine whether there is already a key-value pair to be inserted, and this equals actually compares the key.

It is used to store a key-value pair such as key-value. The return value is the old value of the key stored in the Map. If it does not exist before, null is returned. The put method of HashMap is implemented like this.

// 在此映射中關(guān)聯(lián)指定值與指定鍵。如果該映射以前包含了一個該鍵的映射關(guān)系，則舊值被替換
public V put(K key, V value) {
    // 當(dāng)key為null，調(diào)用putForNullKey方法，保存null與table第一個位置中，這是HashMap允許為null的原因 
    if (key == null)
        return putForNullKey(value);
    // 使用hash函數(shù)預(yù)處理hashCode，計(jì)算key的hash值  
    int hash = hash(key.hashCode());//-------（1）
    // 計(jì)算key hash 值在 table 數(shù)組中的位置 
    int i = indexFor(hash, table.length);//------(2)
    // 從i出開始迭代 e,找到 key 保存的位置
    for (Entry<K, V> e = table[i]; e != null; e = e.next) {
        Object k;
        // 判斷該條鏈上是否有hash值相同的(key相同) 
        // 若存在相同，則直接覆蓋value，返回舊value 
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            // 舊值 = 新值  
            V oldValue = e.value;
            // 將要存儲的value存進(jìn)去
            e.value = value;
            e.recordAccess(this);
            // 返回舊的value
            return oldValue;
        }
    }
    // 修改次數(shù)增加1 
    modCount++;
    // 將key、value添加至i位置處 
    addEntry(hash, key, value, i);
    return null;
}

From the above we can see that when adding the corresponding key-value combination, if the corresponding key already exists, the corresponding value will be directly changed and the old value will be returned, while judging the key When it exists, compare the hashCode of the key first, and then compare it for equality or equals.

Directly from the above code, the comparison corresponds to the hashCode of Map.Entry and the hashCode of the key. In fact, the hashCode of Map.Entry is actually the hashCode where the key is stored.

If the corresponding key does not originally exist, addEntry will be called to add the corresponding key-value to the Map.

The parameter hash passed by addEntry is the hashCode of the corresponding key.

Realize the uniqueness of reference objects as keys

Through the study of the put() method, we can find that when judging whether a key exists, we first compare the hashCode of the key, and then compare the equality or equals, so overriding the hashCode() and equals() methods can overwrite the references of keys (pointing to objects with the same instance variables).

class MyType {
    private String arga;
    private String argb;

    public MyType(String arga, String argb) {
        this.arga = arga;
        this.argb = argb;
    }

    @Override
    public int hashCode(){                 
         return this.arga.hashCode() * this.argb.hashCode() ; 
    } 
    
    @Override
    public boolean equals(Object obj) {   
        if (this == obj) {               
            return true;                  
        }         
        if (!(obj instanceof MyType)) {  
            return false;               
        }    
        MyType p = (MyType) obj;  
        if (this.arga.equals(p.arga) && this.argb.equals(p.argb)) {              
            return true ;                  
        } else {           
            return false ;                
        }       
    }
}

After rewriting these two methods, you can overwrite the duplicate reference objects. If you need to superimpose the value, use the containsKey() method to determine whether there are duplicate key values ??before calling the put() method. If so, , then use the get() method to obtain the original value, and then add the newly added value.

HashMap solves the problem of the same key value

Some scenarios require one key value to correspond to multiple values, but one key value of the map only corresponds to one value value. Since the hashmap has the same key value, The second put will overwrite the value of the first one, so in order to solve this problem: So use list to save

as follows:

List<Map<String, List<RecommendationListBO>>> hashList = new ArrayList<>();
Iterator<Map.Entry<String, List<RecommendationListBO>>> iterator = recommendationHashMap.entrySet().iterator();
Map.Entry<String, List<RecommendationListBO>> entry;
while (iterator.hasNext()) {
    entry = iterator.next();
    // 往newMap中放入新的Entry
    HashMap<String, List<RecommendationListBO>> newMap = new LinkedHashMap<>();
    newMap.put(entry.getKey().split(",")[0], entry.getValue());
    hashList.add(newMap);
}

Every time a new map is created, add to the map inside the list. The idea is roughly this.

The above is the detailed content of Based on Java HashMap, how to solve the problem of inserting duplicate Key values. For more information, please follow other related articles on the PHP Chinese website!