Basierend auf Java HashMap, wie das Problem des Einfügens doppelter Schlüsselwerte gelöst werden kann

Fügen Sie doppelte Schlüsselwerte in Java HashMap ein

Um doppelte Werte in HashMap einzufügen, müssen Sie zunächst herausfinden, wie Elemente in HashMap gespeichert werden.

Put-Methode

Jedes in der Karte gespeicherte Element ist ein Schlüssel-Wert-Paar, und sie werden alle über die Put-Methode hinzugefügt, und derselbe Schlüssel hat nur einen zugeordneten Wert in der Karte. Die Put-Methode ist in Map wie folgt definiert.

V put(K key, V value);

put()-Methodenimplementierung:

Zuerst ruft hash(key) den Hashcode() des Schlüssels ab. Die Hashmap findet die Kette, in der die Position eingefügt werden soll, basierend auf dem erhaltenen Hashcode In dieser Kette gibt es das gleiche Schlüssel-Wert-Paar. Nachdem diese Kette gefunden wurde, wird die Methode equal() verwendet, um zu bestimmen, ob bereits ein Schlüssel-Wert-Paar eingefügt werden muss, und dieser Wert vergleicht tatsächlich den Schlüssel.

Es wird zum Speichern eines Schlüssel-Wert-Paares wie Schlüsselwert verwendet. Der Rückgabewert ist der alte Wert des in der Karte gespeicherten Schlüssels. Wenn er zuvor nicht vorhanden war, wird null zurückgegeben. Die Put-Methode von HashMap wird folgendermaßen implementiert.

// 在此映射中关联指定值与指定键。如果该映射以前包含了一个该键的映射关系，则旧值被替换
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;
}

Aus dem Obigen können wir ersehen, dass beim Hinzufügen der entsprechenden Schlüssel-Wert-Kombination, wenn der entsprechende Schlüssel bereits vorhanden ist, der entsprechende Wert direkt geändert und der alte Wert zurückgegeben wird. Bei der Beurteilung, ob der Schlüssel vorhanden ist HashCode des Schlüssels zuerst und vergleicht ihn dann auf Gleichheit oder Gleichheit.

Direkt aus dem obigen Code entspricht der Vergleich dem HashCode von Map.Entry und dem HashCode des Schlüssels. Tatsächlich ist der HashCode von Map.Entry tatsächlich der HashCode des Schlüssels.

Wenn der entsprechende Schlüssel ursprünglich nicht vorhanden ist, wird addEntry aufgerufen, um den entsprechenden Schlüsselwert zur Map hinzuzufügen.

Der von addEntry übergebene Parameter-Hash ist der HashCode des entsprechenden Schlüssels.

Erkennen Sie die Einzigartigkeit von Referenzobjekten als Schlüssel.

Durch das Studium der put () -Methode können wir feststellen, dass wir bei der Beurteilung, ob ein Schlüssel vorhanden ist, zuerst den Hash-Code des Schlüssels vergleichen und dann die Gleichheit oder Gleichheit vergleichen. Daher können die Methoden „rewrite hashCode()“ und „equals()“ die Referenzen von Schlüsseln überschreiben (die auf Objekte mit denselben Instanzvariablen verweisen).

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 ;                
        }       
    }
}

Nachdem Sie diese beiden Methoden neu geschrieben haben, können Sie die doppelten Referenzobjekte überschreiben. Wenn Sie den Wert überlagern müssen, verwenden Sie die Methode „containsKey()“, um festzustellen, ob doppelte Schlüsselwerte vorhanden sind, bevor Sie die Methode „put()“ aufrufen Verwenden Sie also die Methode get (), um den ursprünglichen Wert abzurufen und den neu hinzugefügten Wert hinzuzufügen.

HashMap löst das Problem des gleichen Schlüsselwerts.

Einige Szenarien erfordern, dass ein Schlüsselwert mehreren Werten entspricht, aber ein Schlüsselwert in der Karte entspricht nur einem Wertwert, da die Hashmap denselben Schlüsselwert hat put überschreibt den ersten Wert. Um dieses Problem zu lösen, verwenden Sie list zum Speichern

wie folgt:

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);
}

Jedes Mal, wenn Sie eine neue Karte erstellen, fügen Sie sie der Kartenliste hinzu. Die Idee ist ungefähr diese.

Das obige ist der detaillierte Inhalt vonBasierend auf Java HashMap, wie das Problem des Einfügens doppelter Schlüsselwerte gelöst werden kann. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!