Based on Java HashMap, how to solve the problem of inserting duplicate Key values

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.

// 在此映射中关联指定值与指定键。如果该映射以前包含了一个该键的映射关系，则旧值被替换
public V put(K key, V value) {
    // 当key为null，调用putForNullKey方法，保存null与table第一个位置中，这是HashMap允许为null的原因 
    if (key == null)
        return putForNullKey(value);
    // 使用hash函数预处理hashCode，计算key的hash值  
    int hash = hash(key.hashCode());//-------（1）
    // 计算key hash 值在 table 数组中的位置 
    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存进去
            e.value = value;
            e.recordAccess(this);
            // 返回旧的value
            return oldValue;
        }
    }
    // 修改次数增加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!