HASTABLE TRONG JAVA

1. HashTable trong Java là gì?

Lớp Java HashTable cài đặt (implement) một bảng HashTable để map khóa và giá trị.
HashTable kế thừa lớp Dictionary và cài đặt (implement) Map Interface.

Các đặc điểm quan trọng về lớp HashTable trong java là:
 HashTable là một mảng của list. Mỗi list được biết đến như một bucket (vùng
chứa) các phần tử. Vị trí của một bucket được xác định bằng việc gọi phương
thức hashcode().
 HashTable cũng lưu trữ dữ liệu dưới dạng cặp key và value.
 HashTable chứa các key duy nhất.
 HashTable KHÔNG thể có bất kỳ key hoặc giá trị nào là null.
 HashTable được đồng bộ (synchronized).
1.1. Tạo một HashTable trong Java
Để tạo HashMap, trước tiên chúng ta phải import gói java.util.HashMap. Khi chúng ta
đã import xong, sau đây là cách chúng ta có thể tạo các hashmap trong Java.
// HashMap creation with 8 capacity and 0.6 load factor
// HashMap creation with 8 capacity and 0.6 load factor
HashMap<Key, Value> numbers = new HashMap<>(8,
0.6f);

Trong đoạn code trên, chúng ta đã tạo ra một hashmap có tên là numbers. Trong đó:
  Key là code định danh duy nhất được sử dụng để liên kết từng phần tử (value)
trong map
 Value là các phần tử được liên kết bởi các key trong map
Lưu ý về đoạn code new HashMap<>(8, 0.6). Ở đây, tham số đầu tiên là capacity và
tham số thứ hai là loadFactor .
 capacity là dung lượng của HashMap này là 8. Ý nghĩa nó có thể lưu trữ 8
mục.
 loadFactor là hệ số tải của hashmap này là 0,6. Điều này có nghĩa là bất cứ khi
nào bảng băm của chúng ta được lấp đầy 60%, các mục mới sẽ được chuyển
sang bảng băm mới có kích thước gấp đôi bảng băm ban đầu.
1.2.Tạo HashMap từ các Map khác
Sau đây là cách chúng ta có thể tạo một hashmap chứa tất cả các phần tử của các map
khác
import java.util.HashMap;

class Main {
public static void main(String[] args) {
// Creating a hashmap of even numbers
HashMap<String, Integer> evenNumbers = new HashMap<>();
evenNumbers.put("Two", 2);
evenNumbers.put("Four", 4);
System.out.println("HashMap1: " + evenNumbers);

// Creating a hash map from other hashmap

HashMap<String, Integer> numbers = new HashMap<>(evenNumbers);
numbers.put("Three", 3);
System.out.println("HashMap2: " + numbers);
}
}

Kết quả
HashMap1: {Four=4, Two=2}
HashMap2: {Two=2, Three=3, Four=4}
1.3. Chèn các phần tử vào HashMap
 put() – chèn cặp key/value được chỉ định vào map
 putAll() – chèn tất cả các mục từ map được chỉ định vào map hiện tại
 putIfAbsent() – chèn cặp key/value được chỉ định vào map nếu key được chỉ
định không có trong map
import java.util.HashMap;

class Main {
public static void main(String[] args) {
// Creating HashMap of even numbers
HashMap<String, Integer> evenNumbers = new HashMap<>();

// Using put()
evenNumbers.put("Two", 2);
evenNumbers.put("Four", 4);

// Using putIfAbsent()
evenNumbers.putIfAbsent("Six", 6);
System.out.println("HashMap of even numbers: " + evenNumbers);

//Creating HashMap of numbers

HashMap<String, Integer> numbers = new HashMap<>();
numbers.put("One", 1);

// Using putAll()
numbers.putAll(evenNumbers);
System.out.println("HashMap of numbers: " + numbers);
}
}

Kết quả
HashMap of even numbers: {Six=6, Four=4, Two=2}
HashMap of numbers: {Six=6, One=1, Four=4, Two=2}
1.4. Lấy các phần tử trong HashMap
 entrySet() – trả về một tập hợp gồm tất cả cặp key / value của map
 keySet() – trả về một tập hợp gồm tất cả các key của map
  values() – trả về một tập hợp gồm tất cả các value của map

import java.util.HashMap;

class Main {
public static void main(String[] args) {
HashMap<String, Integer> numbers = new HashMap<>();

numbers.put("One", 1);
numbers.put("Two", 2);
numbers.put("Three", 3);
System.out.println("HashMap: " + numbers);

// Using entrySet()
System.out.println("Key/Value mappings: " + numbers.entrySet());

// Using keySet()
System.out.println("Keys: " + numbers.keySet());

// Using values()
System.out.println("Values: " + numbers.values());
}
}

Kết quả

HashMap: {One=1, Two=2, Three=3}

Key/Value mappings: [One=1, Two=2, Three=3]
Keys: [One, Two, Three]
Values: [1, 2, 3]
  get()- Trả về value liên kết với key được chỉ định. Trả về null nếu không tìm
thấy key.
 getOrDefault()- Trả về value liên kết với key được chỉ định. Trả về value mặc
định đã chỉ định nếu không tìm thấy key.

import java.util.HashMap;

class Main {
public static void main(String[] args) {

HashMap<String, Integer> numbers = new HashMap<>();

numbers.put("One", 1);
numbers.put("Two", 2);
numbers.put("Three", 3);
System.out.println("HashMap: " + numbers);

// Using get()
int value1 = numbers.get("Three");
System.out.println("Returned Number: " + value1);

// Using getOrDefault()
int value2 = numbers.getOrDefault("Five", 5);
System.out.println("Returned Number: " + value2);
}
}

Kết quả
HashMap: {One=1, Two=2, Three=3}
Returned Number: 3
Returned Number: 5
1.5. Xóa phần tử hỏi HashTable
 remove(key) – trả về và xóa mục liên kết với key được chỉ định khỏi map
 remove(key, value) – chỉ xóa mục khỏi map nếu key được chỉ định liên kết với
value đã chỉ định và trả về giá trị boolean
import java.util.HashMap;

class Main {
public static void main(String[] args) {

HashMap<String, Integer> numbers = new HashMap<>();

numbers.put("One", 1);
numbers.put("Two", 2);
numbers.put("Three", 3);
System.out.println("HashMap: " + numbers);

// remove method with single parameter

int value = numbers.remove("Two");
System.out.println("Removed value: " + value);

// remove method with two parameters

boolean result = numbers.remove("Three", 3);
System.out.println("Is the entry Three removed? " + result);

System.out.println("Updated HashMap: " + numbers);

}
}

Kết quả

HashMap: {One=1, Two=2, Three=3}

Removed value: 2
Is the entry Three removed? True
Updated HashMap: {One=1}
1.6. Thay thế các phần tử trong HashTable
 replace(key, value) – thay thế value liên kết với Key được chỉ định bằng một
value mới
 replace(key, old, new) – thay thế value old bằng value new nếu value old đã
liên kết với Key được chỉ định
  replaceAll(function) – thay thế từng value của map bằng kết quả của hàm
được chỉ định
import java.util.HashMap;

class Main {
public static void main(String[] args) {

HashMap<String, Integer> numbers = new HashMap<>();

numbers.put("First", 1);
numbers.put("Second", 2);
numbers.put("Third", 3);
System.out.println("Original HashMap: " + numbers);

// Using replace()
numbers.replace("Second", 22);
numbers.replace("Third", 3, 33);
System.out.println("HashMap using replace(): " + numbers);

// Using replaceAll()
numbers.replaceAll((key, oldValue) -> oldValue + 2);
System.out.println("HashMap using replaceAll(): " + numbers);
}
}

Kết quả
Original HashMap: {Second=2, Third=3, First=1}HashMap using replace:
{Second=22, Third=33, First=1}
HashMap using replaceAll: {Second=24, Third=35, First=3}
Trong chương trình trên chú ý câu lệnh:
numbers.replaceAll((key, oldValue) ->
oldValue + 2);

Ở đây, hàm này truy cập tất cả các mục của map. Sau đó, nó thay thế tất cả các value
bằng các value mới được cung cấp bởi biểu thức lambda .
1.7. Duyệt qua từng phần tử trong HashMap
Trong một HashMap, chúng ta có thể:
 Lặp qua các key của nó
 Lặp qua các value của nó
 Lặp qua các key/value của nó

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

class Main {
public static void main(String[] args) {

// Creating a HashMap
HashMap<String, Integer> numbers = new HashMap<>();
numbers.put("One", 1);
numbers.put("Two", 2);
numbers.put("Three", 3);
System.out.println("HashMap: " + numbers);

// Accessing the key/value pair

System.out.print("Entries: ");
for(Entry<String, Integer> entry: numbers.entrySet()) {
System.out.print(entry);
System.out.print(", ");
}

// Accessing the key

System.out.print("\nKeys: ");
for(String key: numbers.keySet()) {
System.out.print(key);
System.out.print(", ");
}

// Accessing the value

System.out.print("\nValues: ");
for(Integer value: numbers.values()) {
System.out.print(value);
System.out.print(", ");
}
}
}

Kết quả
HashMap: {One=1, Two=2, Three=3}
Entries: One=1, Two=2, Three=3
Keys: One, Two, Three,
Values: 1, 2, ,3,

Trong chương trình trên, lưu ý rằng chúng ta đã import gói java.util.Map.Entry. Ở
đây, Map.Entry là class trong của Map interface. Class trong này trả về một view
(các phần tử) của map.
Ngoài ra chúng ta cũng có thể lặp lại HashMap bằng cách sử dụng hàm iterator(). Để
sử dụng hàm này, chúng ta phải import java.util.Iterator gói.
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;

class Main {
public static void main(String[] args) {
// Creating a HashMap
HashMap<String, Integer> numbers = new HashMap<>();
numbers.put("One", 1);
numbers.put("Two", 2);
numbers.put("Three", 3);
System.out.println("HashMap: " + numbers);

// Creating an object of Iterator

Iterator<Entry<String, Integer>> iterate1 = numbers.entrySet().iterator();

// Accessing the Key/Value pair

System.out.print("Entries: ");
while(iterate1.hasNext()) {
System.out.print(iterate1.next());
System.out.print(", ");
}

// Accessing the key

Iterator<String> iterate2 = numbers.keySet().iterator();
System.out.print("\nKeys: ");
while(iterate2.hasNext()) {
System.out.print(iterate2.next());
System.out.print(", ");
}

// Accessing the value

Iterator<Integer> iterate3 = numbers.values().iterator();
 System.out.print("\nValues: ");
while(iterate3.hasNext()) {
System.out.print(iterate3.next());
System.out.print(", ");
}
}
}

Kết quả
HashMap: {One=1, Two=2, Three=3}
Entries: One=1, Two=2, Three=3
Keys: One, Two, Three,Values: 1, 2, 3.
2.Một số hàm của HashMap
Hàm Mô tả
clear() Xóa tất cả các mục khỏi map
containsKey() Kiểm tra xem map có chứa key được chỉ định hay không và trả về
giá trị boolean
containsValue() Kiểm tra xem map có chứa value được chỉ định hay không và trả
về giá trị boolean
size() Trả về kích cỡ của map
isEmpty() Kiểm tra xem map có trống không và trả về giá trị boolean

2.1. Xóa tất cả các mục khỏi map

import java.util.Hashtable;

public class ClearHashtableExample {

public static void main(String[] args) {
// Tạo một Hashtable với kiểu String làm khóa và giá trị
Hashtable<String, Integer> hashtable = new Hashtable<>();

// Thêm các mục vào Hashtable

hashtable.put("A", 1);
hashtable.put("B", 2);
hashtable.put("C", 3);

System.out.println("Hashtable ban đầu: " + hashtable);

// Xóa tất cả các mục trong Hashtable bằng cách gọi clear()
hashtable.clear();

System.out.println("Sau khi xóa tất cả các mục: " + hashtable);

 }
}

Kết quả:
Hashtable ban đầu: {A=1, B=2, C=3}
Sau khi xóa tất cả các mục: {}
2.2. Kiểm tra xem map có chứa key được chỉ định hay không và trả về giá trị
boolean
import java.util.HashMap;
import java.util.Map;

public class MapContainsKeyExample {

public static void main(String[] args) {
// Tạo một HashMap với kiểu String làm khóa và Integer làm giá trị
Map<String, Integer> map = new HashMap<>();

// Thêm các mục vào HashMap

map.put("apple", 10);
map.put("banana", 20);
map.put("orange", 15);

// Kiểm tra xem HashMap có chứa khóa "banana" hay không

String keyToCheck = "banana";
if (map.containsKey(keyToCheck)) {
System.out.println("HashMap chứa khóa '" + keyToCheck + "'");
} else {
System.out.println("HashMap không chứa khóa '" + keyToCheck + "'");
}

// Kiểm tra xem HashMap có chứa khóa "pear" hay không

String anotherKey = "pear";
if (map.containsKey(anotherKey)) {
System.out.println("HashMap chứa khóa '" + anotherKey + "'");
} else {
System.out.println("HashMap không chứa khóa '" + anotherKey + "'");
}
}
}

Kết quả:
HashMap chứa khóa 'banana'
HashMap không chứa khóa 'pear'

2.3. Kiểm tra xem map có chứa value được chỉ định hay không và trả về giá trị
boolean

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

public class MapContainsValueExample {

public static void main(String[] args) {
// Tạo một HashMap với kiểu String làm khóa và Integer làm giá trị
Map<String, Integer> map = new HashMap<>();

// Thêm các mục vào HashMap

map.put("apple", 10);
map.put("banana", 20);
map.put("orange", 15);

// Kiểm tra xem HashMap có chứa giá trị 20 hay không

int valueToCheck = 20;
if (map.containsValue(valueToCheck)) {
System.out.println("HashMap chứa giá trị '" + valueToCheck + "'");
} else {
System.out.println("HashMap không chứa giá trị '" + valueToCheck + "'");
}

// Kiểm tra xem HashMap có chứa giá trị 30 hay không

int anotherValue = 30;
if (map.containsValue(anotherValue)) {
System.out.println("HashMap chứa giá trị '" + anotherValue + "'");
} else {
System.out.println("HashMap không chứa giá trị '" + anotherValue + "'");
}
}
}

Kết quả:
HashMap chứa giá trị '20'
HashMap không chứa giá trị '30'
2.4. Trả về kích cỡ của map
 import java.util.HashMap;
import java.util.Map;

public class MapSizeExample {

public static void main(String[] args) {
// Tạo một HashMap với kiểu String làm khóa và Integer làm
giá trị
Map<String, Integer> map = new HashMap<>();

// Thêm các mục vào HashMap

map.put("apple", 10);
map.put("banana", 20);
map.put("orange", 15);

// Lấy kích thước của HashMap bằng phương thức size()

int size = map.size();
System.out.println("Kích thước của HashMap là: " + size);

// Bạn cũng có thể tạo một Hashtable và lấy kích thước của nó
// Hashtable<String, Integer> hashtable = new Hashtable<>();
// int sizeOfHashtable = hashtable.size();
// System.out.println("Kích thước của Hashtable là: " +
sizeOfHashtable);
}
}

Kết quả:
Kích thước của HashMap là: 3
2.5. Kiểm tra xem map có trống không và trả về giá trị boolean
import java.util.HashMap;
import java.util.Map;

public class MapIsEmptyExample {

public static void main(String[] args) {
// Tạo một HashMap với kiểu String làm khóa và Integer
làm giá trị
Map<String, Integer> map = new HashMap<>();

// Kiểm tra xem HashMap có rỗng không

if (map.isEmpty()) {
System.out.println("HashMap đang rỗng");
} else {
System.out.println("HashMap không rỗng");
}
 // Thêm một vài mục vào HashMap
map.put("apple", 10);
map.put("banana", 20);
map.put("orange", 15);

// Kiểm tra lại xem HashMap có rỗng không

if (map.isEmpty()) {
System.out.println("HashMap đang rỗng");
} else {
System.out.println("HashMap không rỗng");
}
}
}