Como atualizar um valor, dada uma chave em um hashmap?

Suponha que tenhamos um HashMap<String, Integer>em Java.

Como atualizo (incremento) o valor inteiro da chave de cadeia para cada existência da cadeia que encontro?

Pode-se remover e reinserir o par, mas a sobrecarga seria uma preocupação.
Outra maneira seria colocar o novo par e o antigo seria substituído.

Neste último caso, o que acontece se houver uma colisão de código de hash com uma nova chave que estou tentando inserir? O comportamento correto para uma hashtable seria atribuir um local diferente para ele ou fazer uma lista dele no intervalo atual.

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

deve ficar bem. Ele atualizará o valor para o mapeamento existente. Observe que isso usa boxe automático. Com a ajuda de map.get(key)obtermos o valor da chave correspondente, você poderá atualizar com sua exigência. Aqui estou atualizando para aumentar o valor em 1.

Maneira Java 8:

Você pode usar o computeIfPresentmétodo e fornecer a ele uma função de mapeamento, que será chamada para calcular um novo valor com base no valor existente.

Por exemplo,

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

Como alternativa, você pode usar o mergemétodo, em que 1 é o valor padrão e a função incrementa o valor existente em 1:

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

Além disso, há um conjunto de outros métodos úteis, tais como putIfAbsent, getOrDefault, forEach, etc.

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

O método putirá substituir o valor de uma chave existente e criará-lo se não existe.

A maneira simplificada do Java 8 :

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

Isso usa o método do HashMap que recupera o valor de uma chave, mas se a chave não puder ser recuperada, ela retornará o valor padrão especificado (neste caso, um '0').

Isso é suportado no Java principal: HashMap <K, V> getOrDefault (Chave do objeto, V defaultValue)

Substitua Integerpor AtomicIntegere chame um dos métodos incrementAndGet/ getAndIncrementnele.

Uma alternativa é agrupar uma classe intem sua própria MutableIntegerclasse que possua um increment()método, você só tem uma preocupação de segurança de thread a resolver ainda.

Solução de uma linha:

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

@ A solução de Matthew é a mais simples e terá bom desempenho na maioria dos casos.

Se você precisar de alto desempenho, o AtomicInteger é uma solução melhor, ala @BalusC.

No entanto, uma solução mais rápida (desde que a segurança do encadeamento não seja um problema) é usar TObjectIntHashMap, que fornece um método de incremento (chave) e usa primitivos e menos objetos do que a criação de AtomicIntegers. por exemplo

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

Você pode incrementar como abaixo, mas precisa verificar a existência para que uma NullPointerException não seja lançada

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

O hash existe (com 0 como valor) ou é "colocado" no mapa no primeiro incremento? Se for "colocado" no primeiro incremento, o código deve se parecer com:

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

Pode ser um pouco tarde, mas aqui estão meus dois centavos.

Se você estiver usando o Java 8, poderá usar o método computeIfPresent . Se o valor da chave especificada estiver presente e não for nulo, ele tentará calcular um novo mapeamento, dada a chave e seu valor mapeado atual.

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]

Também podemos fazer uso de outro método putIfAbsent para colocar uma chave. Se a chave especificada ainda não estiver associada a um valor (ou estiver mapeada para nula), esse método a associará ao valor fornecido e retornará nulo; caso contrário, retornará o valor atual.

No caso do mapa é compartilhado entre threads, então podemos fazer uso de ConcurrentHashMape AtomicInteger . Do documento:

An AtomicIntegeré um valor int que pode ser atualizado atomicamente. Um AtomicInteger é usado em aplicativos como contadores incrementados atomicamente e não pode ser usado como um substituto para um número inteiro. No entanto, esta classe estende Number para permitir acesso uniforme por ferramentas e utilitários que lidam com classes numericamente baseadas.

Podemos usá-los como mostrado:

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]

Um ponto a observar é que estamos invocando getpara obter o valor da chave Be, em seguida, invocando incrementAndGet()seu valor, que é claro AtomicInteger. Podemos otimizá-lo, pois o método putIfAbsentretorna o valor da chave, se já estiver presente:

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

Além disso, se planejarmos usar o AtomicLong , conforme a documentação sob alta contenção, a taxa de transferência esperada do LongAdder será significativamente maior, à custa de um maior consumo de espaço. Verifique também esta pergunta .

A solução mais limpa sem NullPointerException é:

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

Como não posso comentar algumas respostas devido à menor reputação, publicarei uma solução que apliquei.

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 um forloop para incrementar o í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 ....

}

Há respostas enganosas para esta pergunta aqui que implicam que o método put Hashtable substituirá o valor existente se a chave existir; isso não é verdade para o Hashtable, mas para o 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);

ou

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

Inteiro é tipos de dados primitivos http://cs.fit.edu/~ryan/java/language/java-data.html , então você precisa removê-lo, fazer algum processo e colocá-lo novamente. se você tiver um valor que não seja do tipo Primitivo, precisará retirá-lo, processá-lo e não precisará colocá-lo novamente no mapa de hash.

Tentar:

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

Você pode alterar a chave ou o valor no seu hashmap, mas não pode alterar as duas ao mesmo tempo.

Use Java8 construído em função 'computeIfPresent'

Exemplo:

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