Jak zaktualizować wartość, biorąc pod uwagę klucz w haszapie?

Załóżmy, że mamy HashMap<String, Integer>Javę.

Jak zaktualizować (zwiększyć) wartość całkowitą klucza ciągu dla każdego istnienia znalezionego ciągu?

Można usunąć i ponownie wprowadzić parę, ale narzut byłby problemem.
Innym sposobem byłoby po prostu umieszczenie nowej pary, a stara zostanie zastąpiona.

W tym drugim przypadku, co się stanie, jeśli dojdzie do zderzenia kodu skrótu z nowym kluczem, który próbuję wstawić? Prawidłowe zachowanie tablicy mieszającej oznaczałoby przypisanie jej innego miejsca lub utworzenie z niej listy w bieżącym segmencie.

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

powinno być dobrze. Zaktualizuje wartość istniejącego mapowania. Pamiętaj, że używa to automatycznego boksu. Za pomocą map.get(key)możemy uzyskać wartość odpowiedniego klucza, a następnie możesz zaktualizować zgodnie z wymaganiami. Tutaj aktualizuję wartość przyrostu o 1.

Java 8 sposób:

Możesz użyć computeIfPresentmetody i podać jej funkcję mapowania, która zostanie wywołana w celu obliczenia nowej wartości na podstawie istniejącej.

Na przykład,

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

Alternatywnie można użyć mergemetody, gdzie 1 jest wartością domyślną, a funkcja zwiększa istniejącą wartość o 1:

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

Dodatkowo, istnieje kilka innych przydatnych metod, takich jak putIfAbsent, getOrDefault, forEach, etc.

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

Metoda putbędzie zastąpić wartość istniejącego klucza i stworzy go, jeśli nie istnieje.

Uproszczony sposób Java 8 :

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

Korzysta z metody HashMap, która pobiera wartość klucza, ale jeśli klucza nie można odzyskać, zwraca określoną wartość domyślną (w tym przypadku „0”).

Jest to obsługiwane w rdzeniu Java: HashMap <K, V> getOrDefault (Klucz obiektu, V defaultValue)

Zamień Integerna AtomicIntegeri wywołaj jedną z metod incrementAndGet/ getAndIncrement.

Alternatywą jest zawinięcie intwe własną MutableIntegerklasę, która ma increment()metodę, do rozwiązania jest jeszcze tylko kwestia bezpieczeństwa wątków.

Rozwiązanie jednoliniowe:

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

@ Rozwiązanie Matthew jest najprostsze i w większości przypadków będzie działać wystarczająco dobrze.

Jeśli potrzebujesz wysokiej wydajności, AtomicInteger jest lepszym rozwiązaniem ala @BalusC.

Jednak szybszym rozwiązaniem (pod warunkiem, że bezpieczeństwo wątków nie stanowi problemu) jest użycie TObjectIntHashMap, która zapewnia metodę przyrostu (klucza) i wykorzystuje operacje podstawowe i mniej obiektów niż tworzenie AtomicIntegers. na przykład

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

Możesz zwiększyć jak poniżej, ale musisz sprawdzić istnienie, aby wyjątek NullPointerException nie został zgłoszony

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

Czy istnieje skrót (z wartością 0), czy też jest on „wstawiany” do mapy przy pierwszym kroku? Jeśli zostanie „wstawiony” do pierwszego przyrostu, kod powinien wyglądać następująco:

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

Może być trochę późno, ale oto moje dwa centy.

Jeśli używasz Java 8, możesz skorzystać z metody computeIfPresent . Jeśli wartość określonego klucza jest obecna i ma wartość inną niż null, wówczas próbuje obliczyć nowe odwzorowanie, biorąc pod uwagę klucz i jego bieżącą wartość odwzorowaną.

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]

Możemy również użyć innej metody putIfAbsent do wprowadzenia klucza. Jeśli określony klucz nie jest już powiązany z wartością (lub jest odwzorowany na wartość NULL), wówczas ta metoda wiąże go z podaną wartością i zwraca wartość NULL, w przeciwnym razie zwraca bieżącą wartość.

W przypadku, gdy mapa jest wspólna dla wątków następnie możemy wykorzystać ConcurrentHashMapi AtomicInteger . Z dokumentu:

An AtomicIntegerjest wartością całkowitą, która może być aktualizowana atomowo. AtomicInteger jest używany w aplikacjach takich jak liczniki z przyrostem atomowym i nie może być stosowany jako zamiennik liczby całkowitej. Jednak ta klasa rozszerza liczbę, aby umożliwić jednolity dostęp do narzędzi i programów narzędziowych, które zajmują się klasami opartymi na liczbach.

Możemy ich używać, jak pokazano:

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]

Należy zauważyć, że wzywamy, getaby uzyskać wartość klucza, Ba następnie wywołujemy incrementAndGet()jej wartość, co oczywiście jest AtomicInteger. Możemy go zoptymalizować, ponieważ metoda putIfAbsentzwraca wartość klucza, jeśli już istnieje:

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

Na marginesie, jeśli planujemy użyć AtomicLong, to zgodnie z dokumentacją w wysokiej rywalizacji spodziewana przepustowość LongAdder jest znacznie wyższa, kosztem wyższego zużycia miejsca. Sprawdź także to pytanie .

Czystsze rozwiązanie bez NullPointerException to:

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

Ponieważ nie mogę skomentować kilku odpowiedzi z powodu mniejszej reputacji, opublikuję rozwiązanie, które zastosowałem.

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

Użyj forpętli, aby zwiększyć indeks:

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

}

Istnieją mylące odpowiedzi na to pytanie, które sugerują, że metoda wprowadzania Hashtable zastąpi istniejącą wartość, jeśli klucz istnieje, nie dotyczy to Hashtable, ale raczej HashMap. Zobacz Javadoc dla 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);

lub

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

Liczba całkowita jest pierwotnymi typami danych http://cs.fit.edu/~ryan/java/language/java-data.html , więc musisz ją wyjąć, zrobić trochę procesu, a następnie odłożyć. jeśli masz wartość, która nie jest pierwotnym typem danych, wystarczy ją wyjąć, przetworzyć, nie trzeba ponownie umieszczać jej w haszapie.

Próbować:

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

UWAGA:

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

Możesz zmienić klucz lub wartość w haszapie, ale nie możesz zmienić obu jednocześnie.

Użyj wbudowanej funkcji Java8 „computeIfPresent”

Przykład:

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