HashMap trong Java - Học Java core - từ cơ bản đến nâng cao

// Khai báo HashMap
// thì import gói thư viện java.util.HashMap
import java.util.HashMap;
public class TênClass {
	// ...
}

public static void main(String[] args) {
	// khai báo 1 HashMap tên hashMap1
	// mỗi phần tử trong hashMap1 bao gồm 2 phần
	// key (Integer) và value (Float)
	HashMap<Integer, Float> hashMap1 = new HashMap<>();
		
	// khai báo 1 HashMap tên hashMap2
	// mỗi phần tử trong hashMap2 bao gồm 2 phần
	// key (String) và value (String)
	// có kích thước khởi tạo = 10
	HashMap<String, String> hashMap2 = new HashMap<>(10);
		
	// khai báo 1 HashMap có kích thước khởi tạo = 4
	// và yếu tố tải = 0.75f (mặc định)
	// chi tiết về kích thước khởi tạo và yếu tố tải
	// các bạn xem lại bài HashSet
	HashMap<Double, Double> hashMap3 = new HashMap<>(4, 0.75f);
		
	// khai báo 1 HashMap được tạo thành từ 1 Collection khác
	HashMap<Float, Integer> hashMap4 = new HashMap<>(new TreeMap<>());
}
	

public static void main(String[] args) {
	// khai báo 1 HashMap có tên là hashMap
	// kiểu dữ liệu của key và value là String 
	HashMap<String, String> hashMap = new HashMap<>();
			
	// Thêm value vào trong hashMap với key tương ứng 
	// sử dụng phương thức put()
	// đối số thứ nhất trong put là key có kiểu là String
	// và đối số thứ hai là value có kiểu là String
	hashMap.put("CSLT", "Cơ sở lập trình");
	hashMap.put("C++", "C++");
	hashMap.put("C#", "C Sharp");
	hashMap.put("PHP", "PHP");
	hashMap.put("Java", "Java");
	 
	// tạo 1 Set có tên là setHashMap
	// chứa toàn bộ các entry (vừa key vừa value)
	// của hashMap
	Set<Map.Entry<String, String>> setHashMap = hashMap.entrySet();
		
	System.out.println("Các entry có trong setHashMap:");
	System.out.println(setHashMap);
}

public static void main(String[] args) {
	HashMap<Integer, Integer> hashMap = new HashMap<>();
	hashMap.put(0, 1);
	hashMap.put(1, 2);
	hashMap.put(2, 3);
	hashMap.put(3, 4);
	hashMap.put(4, 5);
	hashMap.put(5, 6);
			
	// Cách duyệt HashMap với forEach() trong Java 8
	// đối số thứ nhất bên trong forEach là key
	// đối số thứ hai bên trong forEach là value
	System.out.println("Các entry có trong hashMap là: ");
	hashMap.forEach((keyInt, valueInt) -> System.out.println(
		"Key = " + keyInt + ", value = " + valueInt));
}

public static void main(String[] args) {
	HashMap<Integer, String> hashMap = new HashMap<>();
	hashMap.put(2, "Thứ hai");
	hashMap.put(3, "Thứ ba");
	hashMap.put(4, "Thứ tư");
	hashMap.put(5, "Thứ năm");
	hashMap.put(6, "Thứ sáu");
	hashMap.put(7, "Thứ bảy");
	hashMap.put(8, "Chủ nhật");
			
	// phương thức keySet()
	// sẽ trả về 1 Set chứa key có trong hashMap
	System.out.println("Key của các entry trong hashMap: ");
	for (int key : hashMap.keySet()) {
		System.out.println("Key = " + key);
	}
}

public static void main(String[] args) {
	HashMap<String, String> hashMap = new HashMap<>();
	hashMap.put("January", "Tháng 1");
	hashMap.put("February", "Tháng 2");
	hashMap.put("March", "Tháng 3");
	hashMap.put("April", "Tháng 4");
	hashMap.put("May", "Tháng 5");
	hashMap.put("June", "Tháng 6");
	hashMap.put("July", "Tháng 7");
			
	// phương thức values() sẽ trả về 
	// một tập hợp gồm các value có trong hashMap
	System.out.println("Các value có trong hashMap là: ");
	for (String value : hashMap.values()) {
		System.out.println("Value = " + value);
	}
}

public static void main(String[] args) {
	Map<String, String> hashMap = new HashMap<>();
	hashMap.put("Apple", "Táo");
	hashMap.put("Banana", "Chuối");
	hashMap.put("Orange", "Cam");
			
	// sử dụng Iterator để lấy toàn bộ entry của hashMap
	// vì 1 entry bao gồm key và value
	// nên kiểu dữ liệu của Iterator sẽ bao gồm
	// kiểu dữ liệu của cả key và value
	Iterator<Map.Entry<String, String>> iterator = hashMap.entrySet().iterator();
			
	System.out.println("Các entry có trong hashMap là: ");
	while (iterator.hasNext()) {
		System.out.println(iterator.next());
	}
}

public static void main(String[] args) {
	Map<String, String> hashMap = new HashMap<>();
	hashMap.put("Apple", "Táo");
	hashMap.put("Banana", "Chuối");
	hashMap.put("Orange", "Cam");
			
	// sử dụng Iterator để lấy toàn bộ value của HashMap
	// thông qua phương thức values()
	// vì các value có kiểu là String
	// nên iterator cũng có kiểu là String
	Iterator<String> iterator = hashMap.values().iterator();
			
	System.out.println("Value có trong hashMap là: ");
	while (iterator.hasNext()) {
		System.out.println(iterator.next());
	}
}

put(K key, V value);

public static void main(String[] args) {
	int soSanPham = 2;
	HashMap<String, String> hashMapProducts = new HashMap<>();
	Scanner scanner = new Scanner(System.in);
	String maSanPham, tenSanPham;
		
	// thêm thông tin của 2 sản phẩm
	// vào trong hashMapProducts
	// trong đó key là mã sản phẩm, còn value là tên của sản phẩm đó
	for (int i = 1; i <= soSanPham; i++) {
		System.out.println("Nhập thông tin của sản phẩm thứ " + i);
		System.out.println("Nhập mã sản phẩm: ");
		maSanPham = scanner.nextLine();
		System.out.println("Nhập tên sản phẩm: ");
		tenSanPham = scanner.nextLine();
		hashMapProducts.put(maSanPham, tenSanPham);
	}
			
	// hiển thị danh sách sản phẩm sử dụng Iterator
	System.out.println("Danh sách các sản phẩm vừa nhập: ");
	System.out.println("Mã sản phẩm	Tên sản phẩm");
	Iterator<Map.Entry<String, String>> iterator = hashMapProducts.entrySet().iterator();
	while (iterator.hasNext()) {
		// tạo 1 entry
		Map.Entry<String, String> entry = iterator.next();
		System.out.println(entry.getKey() + "		" + entry.getValue());
	}
			
	// thêm 1 sản phẩm mới vào trong hashMapProducts
	// nếu mã sản phẩm đó đã tồn tại thì thông báo mã đã tồn tại
	// ngược lại thì mới nhập tên sản phẩm
	// và thêm vào bình thường sau đó thông báo "Thêm thành công"
	// tăng số sản phẩm lên 1
	System.out.println("Nhập mã sản phẩm cần thêm: ");
	String maSanPhamMoi = scanner.nextLine();
	
	// phương thức containsKey() sẽ kiểm tra mã sản phẩm mới nhập vào
	// có tồn tại trong hashMapProducts hay chưa
	if (hashMapProducts.containsKey(maSanPhamMoi)) {
		System.out.println("Mã sản phẩm = " + maSanPhamMoi + " đã tồn tại!");
	} else {
		System.out.println("Nhập tên sản phẩm cần thêm: ");
		String tenSanPhamMoi = scanner.nextLine();
		
		hashMapProducts.put(maSanPhamMoi, tenSanPhamMoi);
		soSanPham++;
		System.out.println("Danh sách các sản phẩm sau khi thêm: ");
		System.out.println("Số sản phẩm = " + soSanPham);
		System.out.println("Mã sản phẩm	Tên sản phẩm");
		iterator = hashMapProducts.entrySet().iterator();
		while (iterator.hasNext()) {
			// tạo 1 entry
			Map.Entry<String, String> entry = iterator.next();
			System.out.println(entry.getKey() + "		" + entry.getValue());
		}
	}
}

public static void main(String[] args) {
	HashMap<String, String> hashMapCity = new HashMap<>();
	hashMapCity.put("QNg", "Quảng Ngãi");
	hashMapCity.put("QN", "Quảng Nam");
	// trong trường hợp này ta thấy
	// key của Quảng Nam và Quảng Ninh
	// đều là QN nên chương trình sẽ thêm 
	// vào trong hashMapCity value đứng sau (tức là Quảng Ninh)
	hashMapCity.put("QN", "Quảng Ninh");
	hashMapCity.put("HCM", "Thành phố Hồ Chí Minh");
			
	System.out.println("Danh sách các thành phố trong hashMapCity: ");
	Set<Map.Entry<String, String>> setCity = hashMapCity.entrySet();
	System.out.println(setCity);
			
	// lấy thành phố có mã là QNg
	// và hiển thị tên thành phố 
	System.out.println("QNg: " + hashMapCity.get("QNg"));
			
	// lấy thành phố có mã là NT
	// vì trong hashMapCity không có thành phố nào có mã là NT
	// nên sẽ hiển thị giá trị null
	System.out.println("NT: " + hashMapCity.get("NT"));
			
	// Để kiểm tra xem 1 value có trong HashMap hay không
	// chúng ta sẽ dùng phương thức containsValue()
	if (hashMapCity.containsValue("Thành phố Hồ Chí Minh")) {
		System.out.println("Có Thành phố Hồ Chí Minh trong hashMapCity");
	}
}

remove(K key);

public static void main(String[] args) {
	HashMap<Integer, Integer> hashMap = new HashMap<>();
	hashMap.put(1, 9);
	hashMap.put(4, 10);
	hashMap.put(2, 7);
	hashMap.put(8, 20);
		
	System.out.println("Các phần tử có trong hashMap: ");
	Set<Map.Entry<Integer, Integer>> setMap = hashMap.entrySet();
	System.out.println(setMap);
			
	// xóa entry có khóa bằng 2 ra khỏi hashMap
	// sử dụng phương thức remove()
	hashMap.remove(2);
		
	System.out.println("Các phần tử có trong hashMap sau khi xóa: ");
	System.out.println(hashMap);
}

replace(K key, V value);

replace(K key, V oldValue, V newValue);

public static void main(String[] args) {
	HashMap<Integer, Double> hashMap = new HashMap<>();
	hashMap.put(1, 9d);
	hashMap.put(4, 10.1d);
	hashMap.put(2, 7.2d);
	hashMap.put(8, 20.28d);
		
	System.out.println("Các phần tử có trong hashMap: ");
	Set<Map.Entry<Integer, Double>> setMap = hashMap.entrySet();
	System.out.println(setMap);
			
	// thay thế value của entry có khóa là 4
	// thành 10.11d
	hashMap.replace(4, 10.11d);
		
	// ngoài ra chúng ta có thế thay thế như sau
	// câu lệnh bên dưới sẽ thay thế entry 
	// có key là 2, value là 7.2d thành 2.7d
	hashMap.replace(2, 7.2d, 2.7d);
			
	System.out.println("Các phần tử có trong hashMap sau khi thay thế: ");
	setMap = hashMap.entrySet();
	System.out.println(setMap);
}

putAll(HashMap m);

public static void main(String[] args) {
	HashMap<String, String> hashMap = new HashMap<>();
	hashMap.put("VN", "Việt Nam");
	hashMap.put("Laos", "Lào");
	hashMap.put("Korea", "Hàn Quốc");
	hashMap.put("US", "Mỹ");
			
	System.out.println("Các phần tử có trong hashMap: ");
	Set<Map.Entry<String, String>> setHashMap = hashMap.entrySet();
	System.out.println(setHashMap);
			
	// tạo 1 HashMap rỗng
	HashMap<String, String> hashMapCopy = new HashMap<>();
		
	// phương thức size() sẽ trả về số lượng entry có trong hashMapCopy
	System.out.println("Số lượng các entry có trong hashMapCopy "
		+ "trước khi sao chép = " + (hashMapCopy.size()));
			
	// sao chép các entry của hashMap
	// vào trong hashMapCopy
	hashMapCopy.putAll(hashMap);
			
	System.out.println("Số lượng các entry có trong hashMapCopy "
		+ "sau khi sao chép = " + (hashMapCopy.size()));
	System.out.println("Các phần tử có trong hashMapCopy: ");
	Set<Map.Entry<String, String>> setHashMapCopy = hashMapCopy.entrySet();
	System.out.println(setHashMapCopy);
}