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à
nullvà 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):
- Khi thêm một cặp key-value, HashMap tính hash code của key
- Dựa vào hash code để xác định bucket (nhóm) lưu trữ
- 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
put(K key, V value): Thêm cặp key-value vào mapget(Object key): Lấy value dựa trên keyremove(Object key): Xóa entry dựa trên keycontainsKey(Object key): Kiểm tra key có tồn tại khôngcontainsValue(Object value): Kiểm tra value có tồn tại khôngsize(): Trả về số lượng entryisEmpty(): Kiểm tra map có rỗng khôngclear(): Xóa tất cả entry
B. Duyệt qua Map
keySet(): Trả về tập hợp tất cả keysvalues(): Trả về collection tất cả valuesentrySet(): Trả về tập hợp tất cả entries (cặp key-value)
C. Các phương thức khác
putAll(Map m): Thêm tất cả entry từ map khácgetOrDefault(Object key, V defaultValue): Lấy value hoặc defaultValue nếu key không tồn tạiputIfAbsent(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úc | Chỉ mục (index) – giá trị | Khóa (key) – giá trị |
| Truy cập | Theo chỉ số (index) | Theo khóa (key) |
| Tính duy nhất | Cho phép trùng lặp | Key là duy nhất |
| Thứ tự | Giữ thứ tự chèn vào | HashMap: không giữ thứ tự |
| Hiệu suất tìm kiếm | O(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)
- Câu 1: Map và List khác nhau như thế nào? Cho ví dụ minh họa.
- 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()?
- Câu 3: HashMap và Hashtable khác nhau như thế nào?
- Câu 4: Giải thích cơ chế hoạt động của HashMap (hashing, bucket, collision).
- 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:
- Nhập một đoạn văn bản từ người dùng
- Tách các từ (bỏ dấu câu, chuyển thành chữ thường)
- Sử dụng HashMap để đếm số lần xuất hiện của mỗi từ
- Hiển thị kết quả theo thứ tự từ xuất hiện nhiều nhất đến ít nhất
- 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:
- Tạo lớp
SanPhamvới:maSP,tenSP,gia,soLuong - Tạo lớp
KhoHangsử dụng HashMap<String, SanPham> (key là maSP) - 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ạ:
- Sử dụng HashMap<String, List<String>> (key: tên người, value: danh sách số điện thoại)
- 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:
- Sử dụng HashMap<String, User> (key: username)
- Lớp
Usercó:username,password(hash),email,role - 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:
- Tạo lớp
Cache<K, V>với HashMap<K, V> - Giới hạn số phần tử trong cache (vd: tối đa 100 phần tử)
- Khi cache đầy, loại bỏ phần tử ít được truy cập nhất (LRU – Least Recently Used)
- Các phương thức:
put(K key, V value): Thêm vào cacheget(K key): Lấy giá trị, cập nhật thời gian truy cậpremove(K key): Xóa khỏi cachesize(): Số phần tử trong cacheclear(): 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ặcentrySet()(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.
