¿Cómo actualizar un valor, dada una clave en un hashmap?

Supongamos que tenemos un HashMap<String, Integer>en Java.

¿Cómo actualizo (incremento) el valor entero de la cadena-clave para cada existencia de la cadena que encuentro?

Uno podría quitar y volver a entrar en el par, pero los gastos generales serían una preocupación.
Otra forma sería simplemente poner el nuevo par y el viejo sería reemplazado.

En el último caso, ¿qué sucede si hay una colisión de código hash con una nueva clave que estoy tratando de insertar? El comportamiento correcto para una tabla hash sería asignarle un lugar diferente o hacer una lista en el depósito actual.

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

debería estar bien. Actualizará el valor de la asignación existente. Tenga en cuenta que esto utiliza el auto-boxeo. Con la ayuda de map.get(key)obtenemos el valor de la clave correspondiente, luego puede actualizar con su requerimiento. Aquí estoy actualizando para incrementar el valor en 1.

Manera Java 8:

Puede usar el computeIfPresentmétodo y proporcionarle una función de mapeo, que se llamará para calcular un nuevo valor basado en uno existente.

Por ejemplo,

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

Alternativamente, puede usar el mergemétodo, donde 1 es el valor predeterminado y la función incrementa el valor existente en 1:

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

Además, hay un montón de otros métodos útiles, tales como putIfAbsent, getOrDefault, forEach, etc.

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

El método putse reemplace el valor de una clave existente y se creará si no existe.

La forma simplificada de Java 8 :

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

Esto utiliza el método de HashMap que recupera el valor de una clave, pero si la clave no se puede recuperar, devuelve el valor predeterminado especificado (en este caso, un '0').

Esto es compatible con Java central: HashMap <K, V> getOrDefault (clave de objeto, V defaultValue)

Reemplace Integerpor AtomicIntegery llame a uno de los métodos incrementAndGet/ getAndIncrementen él.

Una alternativa es envolver un inten su propia MutableIntegerclase que tiene un increment()método, solo tiene una preocupación de seguridad de hilos para resolver todavía.

Solución de una línea:

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

La solución de @ Matthew es la más simple y funcionará lo suficientemente bien en la mayoría de los casos.

Si necesita un alto rendimiento, AtomicInteger es una mejor solución ala @BalusC.

Sin embargo, una solución más rápida (siempre que la seguridad de los hilos no sea un problema) es usar TObjectIntHashMap, que proporciona un método de incremento (clave) y usa primitivas y menos objetos que crear AtomicIntegers. p.ej

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

Puede aumentar como a continuación, pero debe verificar la existencia para que no se produzca una NullPointerException

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

¿Existe el hash (con 0 como valor) o se "pone" en el mapa en el primer incremento? Si se "pone" en el primer incremento, el código debería verse así:

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

Puede que sea un poco tarde, pero aquí están mis dos centavos.

Si está utilizando Java 8, puede utilizar el método computeIfPresent . Si el valor para la clave especificada está presente y no es nulo, entonces intenta calcular una nueva asignación dada la clave y su valor asignado actual.

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]

También podemos hacer uso de otro método putIfAbsent para poner una clave. Si la clave especificada no está ya asociada a un valor (o está asignada a nulo), este método la asocia al valor dado y devuelve nulo; de lo contrario, devuelve el valor actual.

En caso de que el mapa se comparte a través de las discusiones a continuación, podemos hacer uso de ConcurrentHashMapy AtomicInteger . Del documento:

Un AtomicIntegeres un valor int que puede actualizarse atómicamente. Un AtomicInteger se usa en aplicaciones tales como contadores incrementados atómicamente, y no se puede usar como reemplazo de un Integer. Sin embargo, esta clase sí extiende el Número para permitir el acceso uniforme de herramientas y utilidades que se ocupan de clases basadas en números.

Podemos usarlos como se muestra:

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]

Un punto a tener en cuenta es que estamos invocando getpara obtener el valor de la clave By luego invocando incrementAndGet()su valor, que es, por supuesto AtomicInteger. Podemos optimizarlo ya que el método putIfAbsentdevuelve el valor de la clave si ya está presente:

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

En una nota al margen si planeamos usar AtomicLong, entonces, según la documentación bajo alta contención, el rendimiento esperado de LongAdder es significativamente mayor, a expensas de un mayor consumo de espacio. También revise esta pregunta .

La solución más limpia sin NullPointerException es:

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

Como no puedo comentar algunas respuestas debido a la menor reputación, publicaré una solución que apliqué.

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

Use un forbucle para incrementar el índice:

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 ....

}

Aquí hay respuestas engañosas a esta pregunta que implican que el método de colocación Hashtable reemplazará el valor existente si la clave existe, esto no es cierto para Hashtable sino para HashMap. Consulte Javadoc para 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);

o

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

Entero son tipos de datos primitivos http://cs.fit.edu/~ryan/java/language/java-data.html , por lo que debe extraerlo, realizar algún proceso y luego volver a colocarlo. Si tiene un valor que no son tipos de datos primitivos, solo necesita extraerlo, procesarlo, no es necesario volver a colocarlo en el hashmap.

Tratar:

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

NOTA:

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

Puede cambiar la clave o el valor en su hashmap, pero no puede cambiar ambos al mismo tiempo.

Utilice Java8 integrado en la función 'computeIfPresent'

Ejemplo:

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