1. HashMap trong Java là gì?

HashMap trong Java là một lớp được sử dụng để triển khai Interface Map. Lớp HashMap cho phép chúng ta lưu trữ cặp phần tử là các khóa Key và giá trị Value, trong đó các khóa Key phải là duy nhất. Nếu bạn cố gắng chèn khóa trùng lặp, nó sẽ thay thế phần tử của khóa tương ứng. HashMap trong Java kế thừa lại lớp AbstractMap() và triển khai Interface Map trong Java. Nó cũng cho phép chúng ta lưu trữ các phần tử null, nhưng chỉ nên có một khóa null.

Khi sử dụng HashMap trong Java, ta cần chú ý một số tính chất quan trọng của lớp này:

• HashMap lưu trữ phần tử theo cặp (Key, Value)
• HashMap chỉ cho phép lưu trữ các khóa là duy nhất.
• HashMap có thể có một khóa null và nhiều giá trị null.
• HashMap không được đồng bộ hóa.
• HashMap không có thứ tự.
• Dung lượng mặc định ban đầu của lớp HashMap() là 16 với hệ số tải là 0,75.

Lớp HashMap được tìm thấy trong gói java.util. vì vậy để sử dụng được lớp này, ta cần nhập vào thư viện import java.util.*;

2. Khai báo HashMap trong Java

Kể từ phiên bản Java 5, lớp HashMap được ký hiệu là HashMap <K, V> , trong đó K là viết tắt của khóa và V là giá trị. Chúng ta hoàn toàn có thể khai báo một HashMap trong Java theo cú pháp như sau:

HashMap<typeKey,typeValue> name = new HashMap<typeKey,typeValue>()

Trong đó:

• typeKey là kiểu dữ liệu của khóa trong HashMap
• typeValue là kiểu dữ liệu của giá trị tương ứng với khóa trong HashMap
• name là tên của đối tượng HashMap cần khởi tạo

Lớp HashMap() sẽ gồm 4 constructor. Dưới đây là bảng liệt kê các constructor của lớp này và mô tả các cách sử dụng các constructor đó:

Hãy xem một ví dụ đơn giản về việc khai báo (khởi tạo) một lớp HashMap() để lưu trữ cặp khóa và giá trị. Sau đó chúng ta sẽ đi kiểm tra xem HashMap() vừa khởi tạo có là rổng hay không? Và hiển thị ra các phần tử có trong lớp HashMap() vừa được khởi tạo.

import java.util.*;  
public class Main {
    public static void main(String[] args) {
        //Khoi tao mot HashMap co Key kieu Integer, Value kieu String
        HashMap<Integer,String> hashMap = new HashMap<Integer,String>();
        //Kiem tra HashMap vua tao co rong hay khong?
        boolean result = hashMap.isEmpty();
        System.out.println("HashMap vua khoi tao co rong hay khong? \n" + result);
        //Kiem tra phan tu trong HashMap
        System.out.println("Phan tu co trong HashMap la: \n" + hashMap);  
    }
}

Kết quả:

HashMap vua khoi tao co rong hay khong? 
true
Phan tu co trong HashMap la: 
{}

Nhận xét: Khi một lớp HashMap() được khởi tạo thành công sẽ là một HashMap rỗng và chúng sử dụng cặp dấu ngoặc nhọn {} để lưu trữ các phần tử bên trong. Điều này khá giống với Map Interface.

3. Thao tác với HashMap trong Java

Các thao tác chính khi làm việc với lớp HashMap() đó là những thao tác: thêm phần tử, cập nhật phần tử, xóa phần tử, duyệt qua các phần tử trong HashMap(). Chúng ta sẽ cùng nhau tìm hiểu rõ hơn ở những phần bên dưới đây (có kèm theo ví dụ).

3.1 Thêm phần tử vào HashMap trong Java

Mỗi phần tử bên trong HashMap sẽ là một cặp phần tử bao gồm Key và Value. Vậy nên, để thêm phẩn tử vào trong HashMap chúng ta cần thêm đầy đủ hai thành phần này vào HashMap.

Tương tự như Interface Map trong Java, việc thêm một phần tử vào trong lớp HashMap() cũng được thực hiện thông qua phương thức put() – phương thức này nhận vào hai tham số: tham số đầu tiên là Key của phần tử cần thêm, tham số thứ hai là Value của phần tử cần thêm.

import java.util.*;  
public class Main {
    public static void main(String[] args) {
        //Khoi tao mot HashMap co Key kieu Integer, Value kieu String
        HashMap<Integer,String> hashMap = new HashMap<Integer,String>();
        //Kiem tra HashMap vua tao co rong hay khong?
        boolean result = hashMap.isEmpty();
        System.out.println("HashMap vua khoi tao co rong hay khong? \n" + result);
        //Kiem tra phan tu trong HashMap
        System.out.println("Phan tu co trong HashMap la: \n" + hashMap);  
        
        //Them cac phan tu vao HashMap
        hashMap.put(1,"Nam");  
        hashMap.put(2,"Thanh");  
        hashMap.put(3,"Ha");  
        hashMap.put(4,"Son"); 
        hashMap.put(1,"Anh"); 
        
        //Kiem tra HashMap sau khi them phan tu co rong khong?
        boolean result2 = hashMap.isEmpty();
        System.out.println("HashMap sau khi them phan tu co rong hay khong? \n" + result2); 
        //Kiem tra phan tu trong HashMap
        System.out.println("Phan tu co trong HashMap sau khi them la: \n" + hashMap);
    }
}

Kết quả:

HashMap vua khoi tao co rong hay khong? 
true
Phan tu co trong HashMap la: 
{}
HashMap sau khi them phan tu co rong hay khong? 
false
Phan tu co trong HashMap sau khi them la: 
{1=Nam, 2=Thanh, 3=Ha, 4=Son}

Lưu ý: Chúng ta sẽ không thể lưu trữ các khóa trùng lặp trong HashMap. Tuy nhiên, nếu bạn cố gắng lưu trữ khóa trùng lặp với một khóa khác, nó sẽ thay thế giá trị của khóa đó.

3.2 Duyệt các phần tử trong HashMap

Để thực hiện được thao tác duyệt các phần tử trong HashMap ta cần sử dụng đến Map.Entry – chúng sẽ trả về một Set mới với các phần tử trong nó sẽ thuộc trong HashMap và việc duyệt các phần tử trong HashMap lúc này sẽ chuyển thành duyệt các phần tử trong Set.

import java.util.*;  
public class Main {
    public static void main(String[] args) {
        //Khoi tao mot HashMap co Key kieu Integer, Value kieu String
        HashMap<Integer,String> hashMap = new HashMap<Integer,String>();
        
        //Them cac phan tu vao HashMap
        hashMap.put(1,"Nam");  
        hashMap.put(2,"Thanh");  
        hashMap.put(3,"Ha");  
        hashMap.put(4,"Son");  
        //Hien thi phan tu trong HashMap
        System.out.println("Phan tu co trong HashMap sau khi them la: \n" + hashMap);
        
        //Duyet cac phan tu trong HashMap
        System.out.println ("Duyet cac phan tu trong HashMap");  
        for (Map.Entry m: hashMap.entrySet()) {  
            //Hien thi Key:Value
            System.out.println (m.getKey () + ":" + m.getValue ());    
        }  
    }
}

Kết quả:

Phan tu co trong HashMap sau khi them la: 
{1=Nam, 2=Thanh, 3=Ha, 4=Son}
Duyet cac phan tu trong HashMap
1:Nam
2:Thanh
3:Ha
4:Son

3.3 Thay đổi giá trị phần tử trong HashMap

Thao tác thay đổi giá trị phần tử trong HashMap được thực hiện khi ta biết Key của phần tử cần được cập nhật. Việc cập nhật giá trị này sẽ thay đổi hoàn toàn giá trị Value ban đầu có trong phần tử thành một giá trị Value mới được thay thế.

Để thực hiện được việc thay đổi một giá trị của phần tử có trong HashMap ta chỉ cần gọi đến phương thức replace() – phương thức này yêu cầu nhập vào khóa Key của phần từ cần cập nhật và giá trị Value cần thay đổi dựa theo khóa Key của phần tử đó.

import java.util.*;  
public class Main {
    public static void main(String[] args) {
        //Khoi tao mot HashMap co Key kieu Integer, Value kieu String
        HashMap<Integer,String> hashMap = new HashMap<Integer,String>();
        
        //Them cac phan tu vao HashMap
        hashMap.put(1,"Nam");  
        hashMap.put(2,"Thanh");  
        hashMap.put(3,"Ha");  
        hashMap.put(4,"Son"); 
        //Kiem tra phan tu trong HashMap
        System.out.println("Phan tu co trong HashMap sau khi them la: \n" + hashMap);
        
        //Cap nhat phan tu co Key=3 va Key=1
        hashMap.replace(3,"Hong");  
        hashMap.replace(1,"Nga");  
        //Kiem tra phan tu trong HashMap sau khi cap nhat phan tu
        System.out.println("Phan tu co trong HashMap sau cap nhat la: \n" + hashMap);
    }
}

Kết quả:

Phan tu co trong HashMap sau khi them la: 
{1=Nam, 2=Thanh, 3=Ha, 4=Son}
Phan tu co trong HashMap sau cap nhat la: 
{1=Nga, 2=Thanh, 3=Hong, 4=Son}

3.4 Xóa phần tử trong HashMap

Trong phần này, việc xóa phần tử trong một HashMap sẽ chính là công việc loại bỏ đi một phần tử khỏi HashMap. Và để loại được phần tử cần xóa trong HashMap chúng ta cũng phải biết được Key của phần tử cần loại bỏ khỏi HashMap.

Phương thức remove() sẽ giúp chúng ta loại bỏ được một phần tử có trong HashMap. Tham số của phương thức này chính là Key của phần tử cần xóa bỏ khỏi HashMap. Sau khi gọi phương thức này, cặp giá trị Key và Value của phần tử cần xóa sẽ bị loại bỏ khỏi HashMap một cách nhanh chóng.

import java.util.*;  
public class Main {
    public static void main(String[] args) {
        //Khoi tao mot HashMap co Key kieu Integer, Value kieu String
        HashMap<Integer,String> hashMap = new HashMap<Integer,String>();
        
        //Them cac phan tu vao HashMap
        hashMap.put(1,"Nam");  
        hashMap.put(2,"Thanh");  
        hashMap.put(3,"Ha");  
        hashMap.put(4,"Son"); 
        //Kiem tra phan tu trong HashMap
        System.out.println("Phan tu co trong HashMap sau khi them la: \n" + hashMap);
        
        //Xoa phan tu co Key=3 va Key=1
        hashMap.remove(3);  
        hashMap.remove(1);  
        //Kiem tra phan tu trong HashMap sau khi cap nhat phan tu
        System.out.println("Phan tu co trong HashMap sau khi xoa la: \n" + hashMap);
    }
}

Kết quả:

Phan tu co trong HashMap sau khi them la: 
{1=Nam, 2=Thanh, 3=Ha, 4=Son}
Phan tu co trong HashMap sau khi xoa la: 
{2=Thanh, 4=Son}

Ngoài việc xóa từng phần tử bên trong HashMap dựa vào Key, nếu như bạn cần xóa đi toàn bộ phần tử có trong HashMap ban đầu bạn chỉ cần gọi đến phương thức clear() để thực hiện việc này!

import java.util.*;  
public class Main {
    public static void main(String[] args) {
        //Khoi tao mot HashMap co Key kieu Integer, Value kieu String
        HashMap<Integer,String> hashMap = new HashMap<Integer,String>();
        
        //Them cac phan tu vao HashMap
        hashMap.put(1,"Nam");  
        hashMap.put(2,"Thanh");  
        hashMap.put(3,"Ha");  
        hashMap.put(4,"Son"); 
        //Kiem tra phan tu trong HashMap
        System.out.println("Phan tu co trong HashMap sau khi them la: \n" + hashMap);
        
        //Xoa toan bo phan tu trong HashMap ban dau
        hashMap.clear();  
        //Kiem tra HashMap sau khi xoa toan bo phan tu co rong hay khong?
        boolean result = hashMap.isEmpty();
        System.out.println("HashMap sau khi xoa toan bo phan tu co rong khong? \n" + result);
        //Kiem tra phan tu trong HashMap sau khi cap nhat phan tu
        System.out.println("Phan tu co trong HashMap sau khi xoa la: \n" + hashMap);
    }
}

Kết quả:

Phan tu co trong HashMap sau khi them la: 
{1=Nam, 2=Thanh, 3=Ha, 4=Son}
HashMap sau khi xoa toan bo phan tu co rong khong? 
true
Phan tu co trong HashMap sau khi xoa la: 
{}

4. Các phương thức của HashMap trong Java

Bởi vì lớp HashMap() trong Java được kế thừa và triển khai Interface Map trong Java, vậy nên các phương thức của Map đều có thể được sử dụng cho lớp HashMap(). Dưới đây là bảng liệt kê các phương thức của HashMap trong Java: