получить - массив ключ значение java




Как обновить значение, учитывая ключ в jash hashmap? (11)

Предположим, что мы имеем HashMap<String, Integer> в Java.

Как обновить (увеличить) целочисленное значение строкового ключа для каждого существования строки, которую я нахожу?

Можно было бы удалить и повторно ввести пару, но накладные расходы были бы проблемой.
Другой способ состоял бы в том, чтобы просто поместить новую пару, а старый - на замену.

В последнем случае, что произойдет, если есть столкновение hashcode с новым ключом, который я пытаюсь вставить? Правильное поведение хэш-таблицы было бы назначением для него другого места или составлением списка из текущего ведра.


Java 8 путь:

Вы можете использовать метод computeIfPresent и предоставить ему функцию сопоставления, которая будет вызываться для вычисления нового значения на основе существующего.

Например,

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

Альтернативно, вы можете использовать метод merge , где 1 - значение по умолчанию, а функция увеличивает существующее значение на 1:

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

Кроме того, существует множество других полезных методов, таких как putIfAbsent , getOrDefault , forEach и т. Д.


Вы можете увеличивать, как показано ниже, но вам нужно проверить существование, чтобы исключить NullPointerException

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

Здесь есть вводящие в заблуждение ответы на этот вопрос, которые предполагают, что метод Hashtable put заменит существующее значение, если ключ существует, это неверно для Hashtable, а скорее для HashMap. См. Javadoc для HashMap http://docs.oracle.com/javase/7/docs/api/java/util/HashMap.html#put%28K,%20V%29


Используйте цикл for для увеличения индекса:

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

}

Поскольку я не могу прокомментировать несколько ответов из-за меньшей репутации, я отправлю решение, которое я применил.

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

Пытаться:

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

НОТА:

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

Вы можете изменить либо ключ, либо значение в вашем хэш-карте, но вы не можете изменить оба одновременно.


Решение Мэтью является самым простым и будет достаточно хорошо работать в большинстве случаев.

Если вам нужна высокая производительность, AtomicInteger - лучшее решение ala @BalusC.

Тем не менее, более быстрое решение (при условии, что безопасность потоков не является проблемой) заключается в использовании TObjectIntHashMap который предоставляет метод приращения (ключа) и использует примитивы и меньше объектов, чем создание AtomicIntegers. например

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

Существует ли хэш (с 0 в качестве значения) или он «помещен» на карту при первом приращении? Если он «ставится» при первом приращении, код должен выглядеть так:

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

Это может быть немного поздно, но вот мои два цента.

Если вы используете Java 8, вы можете использовать метод computeIfPresent . Если значение для указанного ключа присутствует и не равно null, оно пытается вычислить новое сопоставление с учетом ключа и текущего отображаемого значения.

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]

Мы также можем использовать другой метод putIfAbsent для ввода ключа. Если указанный ключ еще не связан со значением (или сопоставлен с нулем), то этот метод связывает его с заданным значением и возвращает null, иначе возвращает текущее значение.

Если карта разделяется по потокам, мы можем использовать ConcurrentHashMap и AtomicInteger . Из документа:

AtomicInteger - это значение int, которое может быть обновлено атомарно. AtomicInteger используется в приложениях, таких как атомарно увеличивающиеся счетчики, и не может использоваться для замены Integer. Однако этот класс расширяет Number, чтобы обеспечить равномерный доступ с помощью инструментов и утилит, которые имеют дело с численными классами.

Мы можем использовать их, как показано:

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]

Один момент для наблюдения заключается в том, что мы вызываем get для получения значения для ключа B а затем вызываем incrementAndGet() по его значению, которое, конечно же, AtomicInteger . Мы можем оптимизировать его как метод putIfAbsent возвращает значение для ключа, если оно уже присутствует:

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

На стороне примечания, если мы планируем использовать AtomicLong то согласно документации по высокой конкуренции ожидаемая пропускная способность LongAdder значительно выше, за счет более высокого использования пространства. Также проверьте этот question .


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

или же

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

Целое - это примитивные типы данных http://cs.fit.edu/~ryan/java/language/java-data.html , поэтому вам нужно вытащить его, сделать некоторый процесс, а затем вернуть его обратно. если у вас есть значение, которое не является примитивным типом данных, вам нужно только его вынуть, обработать, нет необходимости возвращать его в хэш-карту.


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

все должно быть в порядке. Он обновит значение для существующего сопоставления. Обратите внимание, что в этом случае используется автоматический бокс.





hashmap