Wie kann man All auf Java HashMap-Inhalte von einem zum anderen setzen, aber vorhandene Schlüssel und Werte nicht ersetzen?

Ich muss alle Schlüssel und Werte von einer A HashMap auf eine andere B kopieren, aber nicht vorhandene Schlüssel und Werte ersetzen.

Was ist der beste Weg, das zu tun?

Ich dachte, anstatt das keySet zu iterieren und zu prüfen, ob es existiert oder nicht, würde ich es tun

Map temp = new HashMap(); // generic later
temp.putAll(Amap);
A.clear();
A.putAll(Bmap);
A.putAll(temp);

Es sieht so aus, als ob Sie bereit sind, eine temporäre Datei zu erstellen Mapalso ich würde es so machen:

Map tmp = new HashMap(patch);
tmp.keySet().removeAll(target.keySet());
target.putAll(tmp);

Hier, patch ist die Karte, die Sie hinzufügen target Karte.

Dank Louis Wasserman ist hier eine Version, die die neuen Methoden in Java 8 nutzt:

patch.forEach(target::putIfAbsent);

Verwenden Guave‘s Karten -Klasse’-Utility-Methoden zum Berechnen der Differenz von 2 Karten können Sie dies in einer einzigen Zeile tun, mit einer Methodensignatur, die deutlicher macht, was Sie erreichen möchten:

public static void main(final String[] args) {
    // Create some maps
    final Map<Integer, String> map1 = new HashMap<Integer, String>();
    map1.put(1, "Hello");
    map1.put(2, "There");
    final Map<Integer, String> map2 = new HashMap<Integer, String>();
    map2.put(2, "There");
    map2.put(3, "is");
    map2.put(4, "a");
    map2.put(5, "bird");

    // Add everything in map1 not in map2 to map2
    map2.putAll(Maps.difference(map1, map2).entriesOnlyOnLeft());
}

Iteriere einfach und füge hinzu:

for(Map.Entry e : a.entrySet())
  if(!b.containsKey(e.getKey())
    b.put(e.getKey(), e.getValue());

Bearbeiten, um hinzuzufügen:

Wenn Sie Änderungen an a vornehmen können, können Sie auch Folgendes tun:

a.putAll(b)

und a wird genau das haben, was Sie brauchen. (alle Einträge in b und alle Einträge in a die sind nicht drin b)

Sie können es in nur einer Zeile schaffen, wenn Sie die Kartenreihenfolge in @ericksons Lösung ändern:

mapWithNotSoImportantValues.putAll( mapWithImportantValues );

In diesem Fall ersetzen Sie Werte in mapWithNotSoImportantValues ​​durch Werte aus mapWithImportantValues ​​mit denselben Schlüsseln.

Java 8-Lösung verwenden Map#merge

Ab Java-8 können Sie verwenden Map#merge(K key, V value, BiFunction remappingFunction) die einen Wert in die verschmilzt Map verwenden remappingFunction falls der Schlüssel bereits in der gefunden wird Map Sie möchten das Paar einsetzen.

// using lambda
newMap.forEach((key, value) -> map.merge(key, value, (oldValue, newValue) -> oldValue));

// using for-loop
for (Map.Entry<Integer, String> entry: newMap.entrySet()) {
    map.merge(entry.getKey(), entry.getValue(), (oldValue, newValue) -> oldValue);
}

Der Code iteriert die newMap Einträge (key und value) und jeder wird zusammengeführt map durch die Methode merge. Das remappingFunction wird im Falle eines duplizierten Schlüssels ausgelöst und in diesem Fall heißt es, dass der erstere (Original) oldValue Der Wert wird verwendet und nicht umgeschrieben.

Mit dieser Lösung benötigen Sie kein Provisorium Map.

Lassen Sie uns ein Beispiel für das Zusammenführen haben newMap Einträge in map und Beibehalten der ursprünglichen Werte im Falle des duplizierten Eintrags.

Map<Integer, String> newMap = new HashMap<>();
newMap.put(2, "EVIL VALUE");                         // this will NOT be merged into
newMap.put(4, "four");                               // this WILL be merged into
newMap.put(5, "five");                               // this WILL be merged into

Map<Integer, String> map = new HashMap<>();
map.put(1, "one");
map.put(2, "two");
map.put(3, "three");

newMap.forEach((k, v) -> map.merge(k, v, (oldValue, newValue) -> oldValue));

map.forEach((k, v) -> System.out.println(k + " " + v));

1 one
2 two
3 three
4 four
5 five

public class MyMap {

public static void main(String[] args) {

    Map<String, String> map1 = new HashMap<String, String>();
    map1.put("key1", "value1");
    map1.put("key2", "value2");
    map1.put("key3", "value3");
    map1.put(null, null);

    Map<String, String> map2 = new HashMap<String, String>();
    map2.put("key4", "value4");
    map2.put("key5", "value5");
    map2.put("key6", "value6");
    map2.put("key3", "replaced-value-of-key3-in-map2");
    // used only if map1 can be changes/updates with the same keys present in map2.
    map1.putAll(map2);

    // use below if you are not supposed to modify the map1.
    for (Map.Entry e : map2.entrySet())
        if (!map1.containsKey(e.getKey()))
            map1.put(e.getKey().toString(), e.getValue().toString());
    System.out.println(map1);
}}

Mit Java 8 gibt es diese API-Methode, um Ihre Anforderung zu erfüllen.

map.putIfAbsent(key, value)

Wenn der angegebene Schlüssel nicht bereits einem Wert zugeordnet ist (oder auf null abgebildet ist), wird er dem angegebenen Wert zugeordnet und null zurückgegeben, andernfalls wird der aktuelle Wert zurückgegeben.