Làm thế nào để cập nhật một giá trị, được cung cấp một khóa trong hàm băm?

Giả sử chúng ta có một HashMap<String, Integer>Java.

Làm cách nào để cập nhật (tăng) giá trị nguyên của khóa chuỗi cho mỗi lần tồn tại của chuỗi tôi tìm thấy?

Người ta có thể loại bỏ và nhập lại cặp, nhưng chi phí sẽ là một mối quan tâm.
Một cách khác là chỉ cần đặt cặp mới và cái cũ sẽ được thay thế.

Trong trường hợp sau, điều gì xảy ra nếu có xung đột mã băm với khóa mới tôi đang cố gắng chèn? Hành vi đúng cho một hashtable sẽ là chỉ định một vị trí khác cho nó hoặc tạo một danh sách từ đó trong nhóm hiện tại.

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

nên ổn Nó sẽ cập nhật giá trị cho ánh xạ hiện có. Lưu ý rằng điều này sử dụng tự động đấm bốc. Với sự giúp đỡ của map.get(key)chúng tôi nhận được giá trị của khóa tương ứng, sau đó bạn có thể cập nhật với yêu cầu của bạn. Ở đây tôi đang cập nhật lên giá trị tăng thêm 1.

Cách Java 8:

Bạn có thể sử dụng computeIfPresentphương thức và cung cấp cho nó một hàm ánh xạ, sẽ được gọi để tính toán một giá trị mới dựa trên giá trị hiện có.

Ví dụ,

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

Thay thế, bạn có thể sử dụng mergephương thức, trong đó 1 là giá trị mặc định và hàm tăng giá trị hiện tại lên 1:

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

Bên cạnh đó, có một loạt các phương pháp hữu ích khác, chẳng hạn như putIfAbsent, getOrDefault, forEachvv

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

Phương thức putnày sẽ thay thế giá trị của khóa hiện có và sẽ tạo nó nếu không tồn tại.

Cách 8 được đơn giản hóa của Java :

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

Điều này sử dụng phương thức HashMap lấy giá trị cho một khóa, nhưng nếu không thể lấy được khóa, nó sẽ trả về giá trị mặc định đã chỉ định (trong trường hợp này là '0').

Điều này được hỗ trợ trong lõi Java: HashMap <K, V> getOrDefault (Khóa đối tượng, V defaultValue)

Thay thế Integerbằng AtomicIntegervà gọi một trong các incrementAndGet/ getAndIncrementphương thức trên nó.

Một cách khác là bọc một lớp intriêng của bạn MutableIntegercó một increment()phương thức, bạn chỉ có một mối quan tâm về an toàn luồng để giải quyết.

Giải pháp một dòng:

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

Giải pháp của @ Matthew là đơn giản nhất và sẽ thực hiện đủ tốt trong hầu hết các trường hợp.

Nếu bạn cần hiệu suất cao, AtomicInteger là giải pháp tốt hơn ala @BalusC.

Tuy nhiên, một giải pháp nhanh hơn (cung cấp an toàn luồng không phải là vấn đề) là sử dụng TObjectIntHashMap cung cấp phương thức tăng (khóa) và sử dụng các nguyên hàm và ít đối tượng hơn so với tạo AtomicIntegers. ví dụ

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

Bạn có thể tăng như bên dưới nhưng bạn cần kiểm tra sự tồn tại để không bị ném NullPulumException

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

Liệu hàm băm có tồn tại (với 0 là giá trị) hay nó được "đặt" vào bản đồ trên bước tăng đầu tiên? Nếu nó được "đặt" vào gia số đầu tiên, mã sẽ có dạng:

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

Nó có thể hơi muộn nhưng đây là hai xu của tôi.

Nếu bạn đang sử dụng Java 8 thì bạn có thể sử dụng phương thức compute IfPftime . Nếu giá trị của khóa được chỉ định hiện diện và không có giá trị thì nó sẽ cố gắng tính toán một ánh xạ mới được cung cấp cho khóa và giá trị được ánh xạ hiện tại của nó.

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]

Chúng ta cũng có thể sử dụng một phương thức khác đặt IfAbsent để đặt khóa. Nếu khóa được chỉ định chưa được liên kết với một giá trị (hoặc được ánh xạ thành null) thì phương thức này liên kết nó với giá trị đã cho và trả về null, nếu không thì trả về giá trị hiện tại.

Trong trường hợp bản đồ được chia sẻ trên các luồng thì chúng ta có thể sử dụng ConcurrentHashMapvà AtomicInteger . Từ tài liệu:

An AtomicIntegerlà một giá trị int có thể được cập nhật nguyên tử. Một AtomicInteger được sử dụng trong các ứng dụng như bộ đếm tăng nguyên tử và không thể được sử dụng để thay thế cho Integer. Tuy nhiên, lớp này mở rộng Số để cho phép truy cập thống nhất bằng các công cụ và tiện ích liên quan đến các lớp dựa trên số.

Chúng ta có thể sử dụng chúng như được hiển thị:

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]

Một điểm cần quan sát là chúng ta đang gọi getđể lấy giá trị cho khóa Bvà sau đó gọi incrementAndGet()giá trị của nó là điều tất nhiên AtomicInteger. Chúng ta có thể tối ưu hóa nó khi phương thức putIfAbsenttrả về giá trị cho khóa nếu đã có:

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

Một lưu ý nữa là nếu chúng tôi dự định sử dụng AtomicLong thì theo tài liệu dưới sự tranh chấp cao, thông lượng dự kiến ​​của LongAdder sẽ cao hơn đáng kể, với chi phí tiêu thụ không gian cao hơn. Cũng kiểm tra câu hỏi này .

Giải pháp sạch hơn mà không có NullPulumException là:

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

Vì tôi không thể nhận xét một vài câu trả lời do ít tiếng tăm hơn, tôi sẽ đăng một giải pháp mà tôi đã áp dụng.

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

Sử dụng một forvòng lặp để tăng chỉ số:

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

}

Có những câu trả lời sai cho câu hỏi này ở đây ngụ ý phương thức đặt Hashtable sẽ thay thế giá trị hiện có nếu khóa tồn tại, điều này không đúng với Hashtable mà thay vào đó là HashMap. Xem Javadoc cho 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);

hoặc là

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

Số nguyên là kiểu dữ liệu Nguyên thủy http://cs.fit.edu/~ryan/java/lingu/java-data.html , vì vậy bạn cần lấy nó ra, thực hiện một số quy trình, sau đó đặt lại. nếu bạn có một giá trị không phải là kiểu dữ liệu Nguyên thủy, bạn chỉ cần lấy nó ra, xử lý nó, không cần đưa nó trở lại vào hashmap.

Thử:

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

GHI CHÚ:

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

Bạn có thể thay đổi khóa hoặc giá trị trong hashmap của mình, nhưng bạn không thể thay đổi cả hai cùng một lúc.

Sử dụng Java8 được xây dựng trong phần kết hợp 'compute IfPftime'

Thí dụ:

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