Wie aktualisiere ich einen Wert anhand eines Schlüssels in einer Hashmap?

Angenommen, wir haben eine HashMap<String, Integer>in Java.

Wie aktualisiere (inkrementiere) ich den Integer-Wert des String-Schlüssels für jede Existenz des gefundenen Strings?

Man könnte das Paar entfernen und erneut eingeben, aber der Aufwand wäre ein Problem.
Ein anderer Weg wäre, einfach das neue Paar zu setzen und das alte zu ersetzen.

Was passiert im letzteren Fall, wenn eine Hashcode-Kollision mit einem neuen Schlüssel auftritt, den ich einzufügen versuche? Das richtige Verhalten für eine Hashtabelle wäre, ihr einen anderen Ort zuzuweisen oder eine Liste daraus im aktuellen Bucket zu erstellen.

map.put(key, map.get(key) + 1);

sollte gut sein. Der Wert für das vorhandene Mapping wird aktualisiert. Beachten Sie, dass dies Auto-Boxing verwendet. Mit Hilfe von erhalten map.get(key)wir den Wert des entsprechenden Schlüssels, dann können Sie mit Ihrer Anforderung aktualisieren. Hier aktualisiere ich auf den Inkrementwert um 1.

Java 8 Weg:

Sie können die computeIfPresentMethode verwenden und ihr eine Zuordnungsfunktion zuweisen, die aufgerufen wird, um einen neuen Wert basierend auf dem vorhandenen zu berechnen.

Zum Beispiel,

Map<String, Integer> words = new HashMap<>();
words.put("hello", 3);
words.put("world", 4);
words.computeIfPresent("hello", (k, v) -> v + 1);
System.out.println(words.get("hello"));

Alternativ können Sie eine mergeMethode verwenden, bei der 1 der Standardwert ist und die Funktion den vorhandenen Wert um 1 erhöht:

words.merge("hello", 1, Integer::sum);

Darüber hinaus gibt es eine Reihe von anderen nützlichen Methoden, wie putIfAbsent, getOrDefault, forEachusw.

hashmap.put(key, hashmap.get(key) + 1);

Das Verfahren putwird ersetzen Sie den Wert eines vorhandenen Schlüssels und wird es schaffen , wenn nicht vorhanden ist .

Der vereinfachte Java 8- Weg:

map.put(key, map.getOrDefault(key, 0) + 1);

Dies verwendet die Methode von HashMap, die den Wert für einen Schlüssel abruft. Wenn der Schlüssel jedoch nicht abgerufen werden kann, wird der angegebene Standardwert zurückgegeben (in diesem Fall eine '0').

Dies wird in Java unterstützt: HashMap <K, V> getOrDefault (Objektschlüssel, V defaultValue)

Ersetzen Sie Integerdurch AtomicIntegerund rufen Sie eine der incrementAndGet/ getAndIncrementMethoden auf.

Eine Alternative besteht darin, eine intin Ihre eigene MutableIntegerKlasse increment()einzubinden, die eine Methode hat. Sie müssen nur noch ein Sicherheitsbedenken lösen.

Einzeilige Lösung:

map.put(key, map.containsKey(key) ? map.get(key) + 1 : 1);

@ Matthews Lösung ist die einfachste und funktioniert in den meisten Fällen gut genug.

Wenn Sie eine hohe Leistung benötigen, ist AtomicInteger eine bessere Lösung als @BalusC.

Eine schnellere Lösung (vorausgesetzt, die Thread-Sicherheit ist kein Problem) ist die Verwendung von TObjectIntHashMap, die eine Inkrementierungsmethode (Schlüsselmethode) bereitstellt und Grundelemente und weniger Objekte verwendet als das Erstellen von AtomicIntegern. z.B

TObjectIntHashMap<String> map = new TObjectIntHashMap<String>()
map.increment("aaa");

Sie können wie unten inkrementieren, müssen jedoch die Existenz überprüfen, damit keine NullPointerException ausgelöst wird

if(!map.containsKey(key)) {
 p.put(key,1);
}
else {
 p.put(key, map.getKey()+1);
}

Existiert der Hash (mit 0 als Wert) oder wird er beim ersten Inkrement auf die Karte "gesetzt"? Wenn es beim ersten Inkrement "gesetzt" wird, sollte der Code folgendermaßen aussehen:

if (hashmap.containsKey(key)) {
    hashmap.put(key, hashmap.get(key)+1);
} else { 
    hashmap.put(key,1);
}

Es mag etwas spät sein, aber hier sind meine zwei Cent.

Wenn Sie Java 8 verwenden, können Sie die computeIfPresent- Methode verwenden. Wenn der Wert für den angegebenen Schlüssel vorhanden und nicht null ist, wird versucht, eine neue Zuordnung unter Berücksichtigung des Schlüssels und seines aktuellen zugeordneten Werts zu berechnen.

final Map<String,Integer> map1 = new HashMap<>();
map1.put("A",0);
map1.put("B",0);
map1.computeIfPresent("B",(k,v)->v+1);  //[A=0, B=1]

Wir können auch eine andere Methode putIfAbsent verwenden , um einen Schlüssel zu setzen. Wenn der angegebene Schlüssel noch keinem Wert zugeordnet ist (oder null zugeordnet ist), ordnet diese Methode ihn dem angegebenen Wert zu und gibt null zurück, andernfalls wird der aktuelle Wert zurückgegeben.

Falls die Karte über Threads gemeinsam genutzt , dann können wir nutzen ConcurrentHashMapund Atomicinteger . Aus dem Dokument:

An AtomicIntegerist ein int-Wert, der atomar aktualisiert werden kann. Eine AtomicInteger wird in Anwendungen wie z. B. atomar inkrementierten Zählern verwendet und kann nicht als Ersatz für eine Ganzzahl verwendet werden. Diese Klasse erweitert jedoch Number, um einen einheitlichen Zugriff für Tools und Dienstprogramme zu ermöglichen, die sich mit numerisch basierten Klassen befassen.

Wir können sie wie gezeigt verwenden:

final Map<String,AtomicInteger> map2 = new ConcurrentHashMap<>();
map2.putIfAbsent("A",new AtomicInteger(0));
map2.putIfAbsent("B",new AtomicInteger(0)); //[A=0, B=0]
map2.get("B").incrementAndGet();    //[A=0, B=1]

Ein zu beachtender Punkt ist, dass wir aufrufen get, um den Wert für den Schlüssel zu erhalten, Bund dann incrementAndGet()dessen Wert aufrufen , was natürlich der Fall ist AtomicInteger. Wir können es optimieren, da die Methode putIfAbsentden Wert für den Schlüssel zurückgibt, falls dieser bereits vorhanden ist:

map2.putIfAbsent("B",new AtomicInteger(0)).incrementAndGet();//[A=0, B=2]

Nebenbei bemerkt, wenn wir vorhaben, AtomicLong zu verwenden, ist der erwartete Durchsatz von LongAdder gemäß der Dokumentation unter hohen Konflikten auf Kosten eines höheren Platzverbrauchs erheblich höher. Überprüfen Sie auch diese Frage .

Die sauberere Lösung ohne NullPointerException lautet:

map.replace(key, map.get(key) + 1);

Da ich aufgrund des geringeren Ansehens einige Antworten nicht kommentieren kann, werde ich eine Lösung veröffentlichen, die ich angewendet habe.

for(String key : someArray)
{
   if(hashMap.containsKey(key)//will check if a particular key exist or not 
   {
      hashMap.put(hashMap.get(key),value+1);// increment the value by 1 to an already existing key
   }
   else
   {
      hashMap.put(key,value);// make a new entry into the hashmap
   }
}

Verwenden Sie eine forSchleife, um den Index zu erhöhen:

for (int i =0; i<5; i++){
    HashMap<String, Integer> map = new HashMap<String, Integer>();
    map.put("beer", 100);

    int beer = map.get("beer")+i;
    System.out.println("beer " + beer);
    System.out ....

}

Es gibt hier irreführende Antworten auf diese Frage, die implizieren, dass die Hashtable-Put-Methode den vorhandenen Wert ersetzt, wenn der Schlüssel vorhanden ist. Dies gilt nicht für Hashtable, sondern für HashMap. Siehe Javadoc für HashMap http://docs.oracle.com/javase/7/docs/api/java/util/HashMap.html#put%28K,%20V%29

Integer i = map.get(key);
if(i == null)
   i = (aValue)
map.put(key, i + 1);

oder

Integer i = map.get(key);
map.put(key, i == null ? newValue : i + 1);

Ganzzahl ist der primitive Datentyp http://cs.fit.edu/~ryan/java/language/java-data.html . Sie müssen ihn also herausnehmen, einen Prozess ausführen und dann zurücksetzen. Wenn Sie einen Wert haben, der kein primitiver Datentyp ist, müssen Sie ihn nur herausnehmen, verarbeiten und nicht wieder in die Hashmap einfügen.

Versuchen:

HashMap hm=new HashMap<String ,Double >();

HINWEIS:

String->give the new value; //THIS IS THE KEY
else
Double->pass new value; //THIS IS THE VALUE

Sie können entweder den Schlüssel oder den Wert in Ihrer Hashmap ändern, aber Sie können nicht beide gleichzeitig ändern.

Verwenden Sie die in Java8 integrierte Funktion 'computeIfPresent'.

Beispiel:

public class ExampleToUpdateMapValue {

    public static void main(String[] args) {
        Map<String,String> bookAuthors = new TreeMap<>();
        bookAuthors.put("Genesis","Moses");
        bookAuthors.put("Joshua","Joshua");
        bookAuthors.put("Judges","Samuel");

        System.out.println("---------------------Before----------------------");
        bookAuthors.entrySet().stream().forEach(System.out::println);
        // To update the existing value using Java 8
        bookAuthors.computeIfPresent("Judges", (k,v) -> v = "Samuel/Nathan/Gad");

        System.out.println("---------------------After----------------------");
        bookAuthors.entrySet().stream().forEach(System.out::println);
    }
}