HashMap trong Java: put, get, duyệt map và mẫu thường dùng

Map lưu các cặp khóa và giá trị

HashMap (trong java.util) lưu các liên kết: mỗi khóa (key) ánh xạ tới một giá trị (value), và bạn tra giá trị theo khóa trong thời gian gần như hằng số. Hãy nghĩ tới một cuốn từ điển: từ là khóa, định nghĩa là giá trị.

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 29);
        ages.put("Chen", 41);

        System.out.println(ages.get("Boris"));
        System.out.println(ages);
    }
}

Hai tham số kiểu là <KeyType, ValueType>. Ở đây khóa là String và giá trị là Integer. Cũng như với ArrayList, bạn thường khai báo biến theo interface Map và tạo đối tượng HashMap.

put, get và ghi đè

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> stock = new HashMap<>();
        stock.put("apples", 50);
        stock.put("apples", 75);   // same key -> overwrites the old value

        System.out.println(stock.get("apples"));  // 75
        System.out.println(stock.get("pears"));    // null - key not present
    }
}

Hai điều cần ghi nhớ:

• Khóa là duy nhất. put với một khóa đã có sẽ thay giá trị của nó và trả về giá trị cũ.
• get với khóa không tồn tại trả về null, không báo lỗi. Tự động unboxing giá trị null đó thành int sẽ ném NullPointerException, một nguồn bug rất phổ biến.

getOrDefault tránh bẫy null

Thay vì lần nào cũng kiểm tra null, hãy yêu cầu một giá trị dự phòng:

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> stock = new HashMap<>();
        stock.put("apples", 50);

        int apples = stock.getOrDefault("apples", 0);
        int pears = stock.getOrDefault("pears", 0);

        System.out.println(apples + " apples, " + pears + " pears");
    }
}

Đây là cách gọn nhất để xử lý những lần tra cứu "có thể có, có thể không", và nó dẫn thẳng tới mẫu code nổi tiếng nhất của HashMap.

Đếm số lần xuất hiện

Đếm mỗi phần tử xuất hiện bao nhiêu lần là bài toán kinh điển của HashMap:

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        String text = "the cat the dog the cat";
        Map<String, Integer> counts = new HashMap<>();

        for (String word : text.split(" ")) {
            counts.put(word, counts.getOrDefault(word, 0) + 1);
        }

        System.out.println(counts);
    }
}

Mẫu map.put(key, map.getOrDefault(key, 0) + 1) đọc là "lấy số đếm hiện tại (hoặc 0), cộng một, rồi lưu lại". Một cách viết gọn hơn tương đương là counts.merge(word, 1, Integer::sum).

Kiểm tra và xóa

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 29);

        System.out.println(ages.containsKey("Ada"));     // true
        System.out.println(ages.containsValue(29));      // true
        System.out.println(ages.size());                 // 2

        ages.remove("Ada");
        System.out.println(ages.containsKey("Ada"));     // false
    }
}

putIfAbsent(key, value) chỉ ghi khi khóa chưa tồn tại, hữu ích cho việc khởi tạo trễ (lazy initialization).

Duyệt một HashMap

Vòng lặp phổ biến nhất duyệt entrySet(), cho bạn cùng lúc khóa và giá trị:

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 29);
        ages.put("Chen", 41);

        for (Map.Entry<String, Integer> entry : ages.entrySet()) {
            System.out.println(entry.getKey() + " is " + entry.getValue());
        }
    }
}

Nếu bạn chỉ cần khóa hoặc chỉ cần giá trị:

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 29);

        for (String name : ages.keySet()) {
            System.out.println(name);
        }
        for (int age : ages.values()) {
            System.out.println(age);
        }
    }
}

Bạn cũng có thể dùng forEach với lambda: ages.forEach((name, age) -> System.out.println(name + ": " + age));.

HashMap không giữ thứ tự

HashMap không cam kết gì về thứ tự duyệt: thứ tự phụ thuộc vào kết quả băm và có thể thay đổi giữa các lần chạy. Nếu bạn cần thứ tự dự đoán được:

• LinkedHashMap giữ thứ tự thêm vào.
• TreeMap giữ khóa được sắp xếp theo thứ tự tự nhiên (hoặc theo Comparator bạn cung cấp).

Cả ba đều cài đặt interface Map, nên muốn đổi chỉ cần sửa một dòng ở constructor.

Khóa phải băm được

HashMap tìm phần tử bằng cách băm khóa, nên hashCode() và equals() của khóa phải nhất quán với nhau. Các kiểu có sẵn như String và Integer đã làm đúng điều này. Nếu dùng lớp của riêng bạn làm khóa, hãy override cả equals lẫn hashCode, nếu không hai đối tượng "bằng nhau" về ý nghĩa sẽ rơi vào hai bucket khác nhau và việc tra cứu sẽ thất bại một cách khó hiểu.

Tiếp theo: HashSet

HashMap trả lời câu hỏi "giá trị nào được lưu dưới khóa này?". Khi bạn chỉ quan tâm một thứ có tồn tại hay không, tức một tập giá trị duy nhất không kèm dữ liệu liên kết, công cụ cần dùng là HashSet, nội dung của trang tiếp theo.