Bài 12: MAP VÀ HASHMAP – CẤU TRÚC DỮ LIỆU KEY-VALUE TRONG JAVA

Chào các nhà quản lý dữ liệu tương lai! Hôm nay chúng ta sẽ học về một cấu trúc dữ liệu cực kỳ quan trọng và hữu ích trong Java: Map và cụ thể là HashMap. Đây là công cụ không thể thiếu khi bạn cần lưu trữ và truy xuất dữ liệu theo cặp khóa-giá trị (key-value).

I. PHẦN LÝ THUYẾT

1. Map là gì?

Map là một interface trong Java Collection Framework, nhưng không phải là một Collection con (không kế thừa từ Collection interface). Map đại diện cho cấu trúc dữ liệu key-value (khóa-giá trị), trong đó:

  • Mỗi cặp key-value được gọi là một entry
  • Key là duy nhất (không trùng lặp)
  • Value có thể trùng lặp
  • Một key chỉ ánh xạ đến một value

2. Tại sao cần Map?

Hãy tưởng tượng bạn cần lưu trữ thông tin sinh viên với mã số sinh viên làm khóa:

  • Với List: phải duyệt toàn bộ để tìm sinh viên theo mã số
  • Với Map: truy xuất trực tiếp bằng mã số (key) → cực kỳ nhanh

3. Các implementation của Map

Java cung cấp nhiều lớp triển khai Map:

  • HashMap: Sử dụng bảng băm, không đảm bảo thứ tự
  • LinkedHashMap: Giữ thứ tự chèn vào
  • TreeMap: Sắp xếp theo thứ tự tự nhiên của key (hoặc Comparator)
  • Hashtable: Đồng bộ hóa, legacy class

4. HashMap – Implementation phổ biến nhất

HashMap là implementation của Map sử dụng bảng băm (hash table):

  • Lưu trữ dữ liệu dưới dạng key-value
  • Cho phép key là null và value là null
  • Không đảm bảo thứ tự các phần tử
  • Thời gian truy cập trung bình O(1) cho các thao tác cơ bản (get, put)

5. Cơ chế hoạt động của HashMap

HashMap hoạt động dựa trên nguyên lý băm (hashing):

  1. Khi thêm một cặp key-value, HashMap tính hash code của key
  2. Dựa vào hash code để xác định bucket (nhóm) lưu trữ
  3. Trong mỗi bucket, dữ liệu được lưu dưới dạng linked list (Java 8+: chuyển thành tree khi bucket lớn)

6. Các phương thức quan trọng của Map/HashMap

A. Thao tác cơ bản

  1. put(K key, V value): Thêm cặp key-value vào map
  2. get(Object key): Lấy value dựa trên key
  3. remove(Object key): Xóa entry dựa trên key
  4. containsKey(Object key): Kiểm tra key có tồn tại không
  5. containsValue(Object value): Kiểm tra value có tồn tại không
  6. size(): Trả về số lượng entry
  7. isEmpty(): Kiểm tra map có rỗng không
  8. clear(): Xóa tất cả entry

B. Duyệt qua Map

  1. keySet(): Trả về tập hợp tất cả keys
  2. values(): Trả về collection tất cả values
  3. entrySet(): Trả về tập hợp tất cả entries (cặp key-value)

C. Các phương thức khác

  1. putAll(Map m): Thêm tất cả entry từ map khác
  2. getOrDefault(Object key, V defaultValue): Lấy value hoặc defaultValue nếu key không tồn tại
  3. putIfAbsent(K key, V value): Chỉ thêm nếu key chưa tồn tại

7. So sánh List và Map

Tiêu chíList (ArrayList)Map (HashMap)
Cấu trúcChỉ mục (index) – giá trịKhóa (key) – giá trị
Truy cậpTheo chỉ số (index)Theo khóa (key)
Tính duy nhấtCho phép trùng lặpKey là duy nhất
Thứ tựGiữ thứ tự chèn vàoHashMap: không giữ thứ tự
Hiệu suất tìm kiếmO(n) (phải duyệt)O(1) trung bình

II. PHẦN THỰC HÀNH

Ví dụ 1: HashMap cơ bản – Minh họa các phương thức

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

public class HashMapCoBan {
    public static void main(String[] args) {
        System.out.println("=== HASHMAP CƠ BẢN - MINH HỌA CÁC PHƯƠNG THỨC ===\n");
        
        // 1. Khai báo HashMap với Generics
        Map<String, Integer> diemSo = new HashMap<>();
        
        // 2. Thêm cặp key-value - put()
        System.out.println("--- THÊM PHẦN TỬ ---");
        diemSo.put("Nguyễn Văn A", 85);
        diemSo.put("Trần Thị B", 92);
        diemSo.put("Lê Văn C", 78);
        diemSo.put("Phạm Thị D", 95);
        
        // Key trùng sẽ ghi đè value
        Integer diemCu = diemSo.put("Nguyễn Văn A", 90); // Trả về value cũ
        System.out.println("Điểm cũ của Nguyễn Văn A: " + diemCu);
        
        System.out.println("Map sau khi thêm: " + diemSo);
        
        // 3. Lấy kích thước - size()
        System.out.println("\n--- KÍCH THƯỚC ---");
        System.out.println("Số phần tử: " + diemSo.size());
        
        // 4. Truy cập value theo key - get()
        System.out.println("\n--- TRUY CẬP VALUE ---");
        System.out.println("Điểm của Trần Thị B: " + diemSo.get("Trần Thị B"));
        System.out.println("Điểm của Không tồn tại: " + diemSo.get("Không tồn tại")); // null
        
        // 5. Kiểm tra tồn tại - containsKey(), containsValue()
        System.out.println("\n--- KIỂM TRA TỒN TẠI ---");
        System.out.println("Có key 'Lê Văn C' không? " + diemSo.containsKey("Lê Văn C"));
        System.out.println("Có key 'Nguyễn Văn Z' không? " + diemSo.containsKey("Nguyễn Văn Z"));
        System.out.println("Có value 95 không? " + diemSo.containsValue(95));
        System.out.println("Có value 100 không? " + diemSo.containsValue(100));
        
        // 6. Xóa phần tử - remove()
        System.out.println("\n--- XÓA PHẦN TỬ ---");
        System.out.println("Trước khi xóa: " + diemSo);
        
        // Xóa theo key
        Integer diemBiXoa = diemSo.remove("Lê Văn C");
        System.out.println("Đã xóa Lê Văn C với điểm: " + diemBiXoa);
        
        // Xóa key không tồn tại
        Integer diemKhongTonTai = diemSo.remove("Không tồn tại");
        System.out.println("Xóa key không tồn tại trả về: " + diemKhongTonTai);
        
        System.out.println("Sau khi xóa: " + diemSo);
        
        // 7. Kiểm tra rỗng - isEmpty()
        System.out.println("\n--- KIỂM TRA RỖNG ---");
        System.out.println("Map có rỗng không? " + diemSo.isEmpty());
        
        // 8. Duyệt qua Map
        System.out.println("\n--- DUYỆT MAP ---");
        
        System.out.println("Cách 1: Duyệt qua keySet()");
        for (String ten : diemSo.keySet()) {
            System.out.println("Key: " + ten + ", Value: " + diemSo.get(ten));
        }
        
        System.out.println("\nCách 2: Duyệt qua values()");
        for (Integer diem : diemSo.values()) {
            System.out.println("Value: " + diem);
        }
        
        System.out.println("\nCách 3: Duyệt qua entrySet() (HIỆU QUẢ NHẤT)");
        for (Map.Entry<String, Integer> entry : diemSo.entrySet()) {
            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
        }
        
        System.out.println("\nCách 4: Duyệt với forEach và Lambda (Java 8+)");
        diemSo.forEach((key, value) -> {
            System.out.println("Key: " + key + ", Value: " + value);
        });
        
        // 9. Các phương thức tiện ích khác
        System.out.println("\n--- PHƯƠNG THỨC TIỆN ÍCH ---");
        
        // getOrDefault()
        System.out.println("Điểm của Nguyễn Văn A: " + diemSo.getOrDefault("Nguyễn Văn A", 0));
        System.out.println("Điểm của Không tồn tại: " + diemSo.getOrDefault("Không tồn tại", 0));
        
        // putIfAbsent() - chỉ thêm nếu key chưa tồn tại
        Integer giaTriCu = diemSo.putIfAbsent("Nguyễn Văn A", 100); // Không thay đổi vì key đã tồn tại
        System.out.println("putIfAbsent Nguyễn Văn A trả về: " + giaTriCu);
        
        Integer giaTriMoi = diemSo.putIfAbsent("Lê Văn E", 88); // Thêm mới
        System.out.println("putIfAbsent Lê Văn E trả về: " + giaTriMoi); // null vì key chưa tồn tại
        System.out.println("Map sau putIfAbsent: " + diemSo);
        
        // 10. Xóa toàn bộ - clear()
        System.out.println("\n--- XÓA TOÀN BỘ ---");
        Map<String, Integer> mapTam = new HashMap<>();
        mapTam.put("Tạm thời", 1);
        System.out.println("Map tạm trước khi clear: " + mapTam);
        mapTam.clear();
        System.out.println("Map tạm sau khi clear: " + mapTam);
        System.out.println("Kích thước sau clear: " + mapTam.size());
    }
}

Ví dụ 2: HashMap với đối tượng tùy chỉnh làm key

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

// Lớp SinhVien sẽ được dùng làm key trong HashMap
class SinhVien {
    private String maSV;
    private String hoTen;
    
    public SinhVien(String maSV, String hoTen) {
        this.maSV = maSV;
        this.hoTen = hoTen;
    }
    
    // Getter
    public String getMaSV() { return maSV; }
    public String getHoTen() { return hoTen; }
    
    // QUAN TRỌNG: Override equals() và hashCode() khi dùng làm key trong HashMap
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        SinhVien sinhVien = (SinhVien) o;
        return Objects.equals(maSV, sinhVien.maSV);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(maSV);
    }
    
    @Override
    public String toString() {
        return maSV + " - " + hoTen;
    }
}
// Lớp DiemMonHoc
class DiemMonHoc {
    private String tenMonHoc;
    private double diem;
    
    public DiemMonHoc(String tenMonHoc, double diem) {
        this.tenMonHoc = tenMonHoc;
        this.diem = diem;
    }
    
    public String getTenMonHoc() { return tenMonHoc; }
    public double getDiem() { return diem; }
    
    @Override
    public String toString() {
        return tenMonHoc + ": " + diem;
    }
}
// Chương trình chính
public class HashMapCustomKey {
    public static void main(String[] args) {
        System.out.println("=== HASHMAP VỚI ĐỐI TƯỢNG TÙY CHỈNH LÀM KEY ===\n");
        
        // Tạo HashMap với key là SinhVien, value là Danh sách điểm
        Map<SinhVien, Map<String, Double>> bangDiem = new HashMap<>();
        
        // Tạo các sinh viên
        SinhVien sv1 = new SinhVien("SV001", "Nguyễn Văn A");
        SinhVien sv2 = new SinhVien("SV002", "Trần Thị B");
        SinhVien sv3 = new SinhVien("SV003", "Lê Văn C");
        
        // Thêm dữ liệu điểm cho sinh viên
        Map<String, Double> diemSv1 = new HashMap<>();
        diemSv1.put("Toán", 8.5);
        diemSv1.put("Lý", 7.5);
        diemSv1.put("Hóa", 9.0);
        
        Map<String, Double> diemSv2 = new HashMap<>();
        diemSv2.put("Toán", 7.0);
        diemSv2.put("Lý", 8.0);
        diemSv2.put("Hóa", 7.5);
        
        Map<String, Double> diemSv3 = new HashMap<>();
        diemSv3.put("Toán", 9.5);
        diemSv3.put("Lý", 9.0);
        diemSv3.put("Hóa", 8.5);
        
        // Đưa vào map chính
        bangDiem.put(sv1, diemSv1);
        bangDiem.put(sv2, diemSv2);
        bangDiem.put(sv3, diemSv3);
        
        // Hiển thị toàn bộ bảng điểm
        System.out.println("=== TOÀN BỘ BẢNG ĐIỂM ===");
        for (Map.Entry<SinhVien, Map<String, Double>> entry : bangDiem.entrySet()) {
            System.out.println("\nSinh viên: " + entry.getKey());
            System.out.println("Điểm các môn:");
            for (Map.Entry<String, Double> diem : entry.getValue().entrySet()) {
                System.out.println("  " + diem.getKey() + ": " + diem.getValue());
            }
        }
        
        // Tìm kiếm điểm của một sinh viên
        System.out.println("\n=== TÌM ĐIỂM SINH VIÊN ===");
        SinhVien svCanTim = new SinhVien("SV002", "Trần Thị B"); // Tạo đối tượng mới với cùng mã SV
        
        if (bangDiem.containsKey(svCanTim)) {
            System.out.println("Tìm thấy sinh viên: " + svCanTim);
            System.out.println("Điểm: " + bangDiem.get(svCanTim));
        } else {
            System.out.println("Không tìm thấy sinh viên");
        }
        
        // Tính điểm trung bình của từng sinh viên
        System.out.println("\n=== ĐIỂM TRUNG BÌNH TỪNG SINH VIÊN ===");
        for (Map.Entry<SinhVien, Map<String, Double>> entry : bangDiem.entrySet()) {
            double tongDiem = 0;
            int soMon = 0;
            
            for (Double diem : entry.getValue().values()) {
                tongDiem += diem;
                soMon++;
            }
            
            double diemTB = soMon > 0 ? tongDiem / soMon : 0;
            System.out.printf("%s - Điểm TB: %.2f\n", entry.getKey(), diemTB);
        }
        
        // Thêm điểm mới cho sinh viên
        System.out.println("\n=== THÊM ĐIỂM MÔN MỚI ===");
        bangDiem.get(sv1).put("Văn", 8.0);
        System.out.println("Sau khi thêm điểm Văn cho SV001:");
        System.out.println(sv1 + ": " + bangDiem.get(sv1));
        
        // Xóa một môn học khỏi sinh viên
        System.out.println("\n=== XÓA MÔN HỌC ===");
        Double diemBiXoa = bangDiem.get(sv2).remove("Hóa");
        System.out.println("Đã xóa môn Hóa của SV002, điểm: " + diemBiXoa);
        System.out.println("Sau khi xóa: " + bangDiem.get(sv2));
        
        // Kiểm tra nếu không override equals() và hashCode()
        System.out.println("\n=== LƯU Ý QUAN TRỌNG ===");
        System.out.println("Khi dùng đối tượng tùy chỉnh làm key trong HashMap,");
        System.out.println("PHẢI override equals() và hashCode()");
        System.out.println("Nếu không, sẽ không tìm thấy key dù có cùng giá trị!");
    }
}

Ví dụ 3: Ứng dụng thực tế – Từ điển Anh-Việt

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

public class TuDienAnhViet {
    private Map<String, String> tuDien;
    
    public TuDienAnhViet() {
        tuDien = new HashMap<>();
        khoiTaoDuLieu();
    }
    
    private void khoiTaoDuLieu() {
        // Thêm một số từ mẫu
        tuDien.put("hello", "xin chào");
        tuDien.put("goodbye", "tạm biệt");
        tuDien.put("computer", "máy tính");
        tuDien.put("keyboard", "bàn phím");
        tuDien.put("mouse", "chuột máy tính");
        tuDien.put("programming", "lập trình");
        tuDien.put("java", "ngôn ngữ lập trình Java");
        tuDien.put("algorithm", "thuật toán");
    }
    
    // Thêm từ mới
    public void themTu(String tuAnh, String tuViet) {
        if (tuDien.containsKey(tuAnh)) {
            System.out.println("Từ '" + tuAnh + "' đã tồn tại. Bạn có muốn cập nhật? (y/n)");
            Scanner sc = new Scanner(System.in);
            String luaChon = sc.nextLine().toLowerCase();
            if (luaChon.equals("y")) {
                tuDien.put(tuAnh, tuViet);
                System.out.println("Đã cập nhật từ '" + tuAnh + "'");
            }
        } else {
            tuDien.put(tuAnh, tuViet);
            System.out.println("Đã thêm từ '" + tuAnh + "'");
        }
    }
    
    // Tra từ
    public void traTu(String tuAnh) {
        if (tuDien.containsKey(tuAnh)) {
            System.out.println(tuAnh + ": " + tuDien.get(tuAnh));
        } else {
            System.out.println("Không tìm thấy từ '" + tuAnh + "' trong từ điển");
        }
    }
    
    // Xóa từ
    public void xoaTu(String tuAnh) {
        if (tuDien.containsKey(tuAnh)) {
            String tuViet = tuDien.remove(tuAnh);
            System.out.println("Đã xóa từ '" + tuAnh + "' (" + tuViet + ")");
        } else {
            System.out.println("Không tìm thấy từ '" + tuAnh + "' để xóa");
        }
    }
    
    // Hiển thị tất cả từ
    public void hienThiTatCa() {
        if (tuDien.isEmpty()) {
            System.out.println("Từ điển trống!");
            return;
        }
        
        System.out.println("\n=== TỪ ĐIỂN ANH-VIỆT ===");
        System.out.println(String.format("%-20s %-30s", "Từ tiếng Anh", "Nghĩa tiếng Việt"));
        System.out.println("=".repeat(50));
        
        for (Map.Entry<String, String> entry : tuDien.entrySet()) {
            System.out.println(String.format("%-20s %-30s", entry.getKey(), entry.getValue()));
        }
        System.out.println("Tổng số từ: " + tuDien.size());
    }
    
    // Tìm kiếm gần đúng
    public void timKiemGanDung(String tuKhoa) {
        System.out.println("\nKết quả tìm kiếm cho '" + tuKhoa + "':");
        boolean timThay = false;
        
        for (Map.Entry<String, String> entry : tuDien.entrySet()) {
            if (entry.getKey().toLowerCase().contains(tuKhoa.toLowerCase()) ||
                entry.getValue().toLowerCase().contains(tuKhoa.toLowerCase())) {
                System.out.println(String.format("%-20s %-30s", entry.getKey(), entry.getValue()));
                timThay = true;
            }
        }
        
        if (!timThay) {
            System.out.println("Không tìm thấy kết quả nào");
        }
    }
    
    // Thống kê
    public void thongKe() {
        System.out.println("\n=== THỐNG KÊ TỪ ĐIỂN ===");
        System.out.println("Tổng số từ: " + tuDien.size());
        
        // Đếm số từ bắt đầu bằng các chữ cái
        Map<Character, Integer> thongKeChuCai = new HashMap<>();
        for (String tuAnh : tuDien.keySet()) {
            if (!tuAnh.isEmpty()) {
                char chuCaiDau = tuAnh.toLowerCase().charAt(0);
                thongKeChuCai.put(chuCaiDau, thongKeChuCai.getOrDefault(chuCaiDau, 0) + 1);
            }
        }
        
        System.out.println("\nThống kê theo chữ cái đầu:");
        for (Map.Entry<Character, Integer> entry : thongKeChuCai.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue() + " từ");
        }
    }
 // Chương trình chính với menu
    public static void main(String[] args) {
        TuDienAnhViet tuDien = new TuDienAnhViet();
        Scanner scanner = new Scanner(System.in);
        
        while (true) {
            System.out.println("\n=== TỪ ĐIỂN ANH-VIỆT ===");
            System.out.println("1. Tra từ");
            System.out.println("2. Thêm từ");
            System.out.println("3. Xóa từ");
            System.out.println("4. Hiển thị tất cả");
            System.out.println("5. Tìm kiếm gần đúng");
            System.out.println("6. Thống kê");
            System.out.println("7. Thoát");
            System.out.print("Chọn chức năng: ");
            
            int luaChon = 0;
            try {
                luaChon = Integer.parseInt(scanner.nextLine());
            } catch (NumberFormatException e) {
                System.out.println("Vui lòng nhập số!");
                continue;
            }
            
            switch (luaChon) {
                case 1:
                    System.out.print("Nhập từ tiếng Anh cần tra: ");
                    String tuCanTra = scanner.nextLine().toLowerCase();
                    tuDien.traTu(tuCanTra);
                    break;
                    
                case 2:
                    System.out.print("Nhập từ tiếng Anh: ");
                    String tuAnh = scanner.nextLine().toLowerCase();
                    System.out.print("Nhập nghĩa tiếng Việt: ");
                    String tuViet = scanner.nextLine();
                    tuDien.themTu(tuAnh, tuViet);
                    break;
                    
                case 3:
                    System.out.print("Nhập từ tiếng Anh cần xóa: ");
                    String tuCanXoa = scanner.nextLine().toLowerCase();
                    tuDien.xoaTu(tuCanXoa);
                    break;
                    
                case 4:
                    tuDien.hienThiTatCa();
                    break;
                    
                case 5:
                    System.out.print("Nhập từ khóa tìm kiếm: ");
                    String tuKhoa = scanner.nextLine();
                    tuDien.timKiemGanDung(tuKhoa);
                    break;
                    
                case 6:
                    tuDien.thongKe();
                    break;
                    
                case 7:
                    System.out.println("Cảm ơn đã sử dụng từ điển!");
                    scanner.close();
                    return;
                    
                default:
                    System.out.println("Lựa chọn không hợp lệ!");
            }
        }
    }
}

III. CÂU HỎI VÀ BÀI TẬP

Phần A: Câu hỏi lý thuyết (5 phút)

  1. Câu 1: Map và List khác nhau như thế nào? Cho ví dụ minh họa.
  2. Câu 2: Tại sao khi dùng đối tượng tùy chỉnh làm key trong HashMap phải override equals() và hashCode()?
  3. Câu 3: HashMap và Hashtable khác nhau như thế nào?
  4. Câu 4: Giải thích cơ chế hoạt động của HashMap (hashing, bucket, collision).
  5. Câu 5: Khi nào nên dùng HashMap thay vì ArrayList?

Phần B: Bài tập thực hành (25 phút)

Bài 1: Thống kê từ trong văn bản

Viết chương trình thống kê tần suất xuất hiện của các từ trong một văn bản:

  1. Nhập một đoạn văn bản từ người dùng
  2. Tách các từ (bỏ dấu câu, chuyển thành chữ thường)
  3. Sử dụng HashMap để đếm số lần xuất hiện của mỗi từ
  4. Hiển thị kết quả theo thứ tự từ xuất hiện nhiều nhất đến ít nhất
  5. Tìm từ xuất hiện nhiều nhất và ít nhất

Bài 2: Quản lý kho hàng với HashMap

Xây dựng hệ thống quản lý kho hàng:

  1. Tạo lớp SanPham với: maSP, tenSP, gia, soLuong
  2. Tạo lớp KhoHang sử dụng HashMap<String, SanPham> (key là maSP)
  3. Các chức năng:
    • Thêm sản phẩm mới
    • Tìm sản phẩm theo mã
    • Cập nhật số lượng sản phẩm
    • Xóa sản phẩm hết hàng (soLuong = 0)
    • Tính tổng giá trị kho hàng
    • Hiển thị sản phẩm có giá cao nhất

Bài 3: Danh bạ điện thoại

Tạo ứng dụng danh bạ:

  1. Sử dụng HashMap<String, List<String>> (key: tên người, value: danh sách số điện thoại)
  2. Các chức năng:
    • Thêm người với số điện thoại
    • Thêm số điện thoại mới cho người có sẵn
    • Tìm số điện thoại theo tên
    • Xóa một số điện thoại
    • Xóa toàn bộ thông tin một người
    • Hiển thị tất cả người có nhiều hơn 1 số điện thoại

Phần C: Thử thách nâng cao (20 phút)

Bài 4: Hệ thống đăng nhập

Tạo hệ thống quản lý tài khoản:

  1. Sử dụng HashMap<String, User> (key: username)
  2. Lớp User có: username, password (hash), email, role
  3. Các chức năng:
    • Đăng ký tài khoản mới (kiểm tra username không trùng)
    • Đăng nhập (kiểm tra username và password)
    • Đổi mật khẩu
    • Phân quyền (admin/user)
    • Khóa/mở khóa tài khoản
    • Thống kê số lượng user theo role

Bài 5: Cache đơn giản

Xây dựng hệ thống cache:

  1. Tạo lớp Cache<K, V> với HashMap<K, V>
  2. Giới hạn số phần tử trong cache (vd: tối đa 100 phần tử)
  3. Khi cache đầy, loại bỏ phần tử ít được truy cập nhất (LRU – Least Recently Used)
  4. Các phương thức:
    • put(K key, V value): Thêm vào cache
    • get(K key): Lấy giá trị, cập nhật thời gian truy cập
    • remove(K key): Xóa khỏi cache
    • size(): Số phần tử trong cache
    • clear(): Xóa toàn bộ cache

IV. TÓM TẮT BÀI HỌC

  • Map: Cấu trúc key–value, key là duy nhất
  • HashMap: Implementation phổ biến nhất, sử dụng bảng băm
  • Hiệu suất: Truy cập O(1) trung bình cho get() và put()
  • Các phương thức quan trọng: put(), get(), remove(), containsKey(), keySet(), entrySet()
  • Duyệt Map: Sử dụng keySet(), values(), hoặc entrySet() (hiệu quả nhất)
  • Lưu ý: Khi dùng đối tượng tùy chỉnh làm key, phải override equals() và hashCode()

“HashMap giống như một cuốn từ điển – bạn tìm nghĩa (value) bằng từ khóa (key) một cách nhanh chóng, mà không cần đọc từ đầu đến cuối.”

P.S.: Thử thách đặc biệt: Hãy tạo một lớp MyHashMap<K, V> của riêng bạn, implement các phương thức cơ bản của Map (put, get, remove, size) mà không dùng HashMap có sẵn của Java! Hãy thử giải quyết vấn đề collision khi hai key khác nhau có cùng hash code.

Comments are closed.