Giao diện bản đồ trong Java

Giao diện bản đồ Java là gì

Giao diện Bản đồ Java là một phần của khung Bộ sưu tập Java, nhưng nó không phải là kiểu con của giao diện Bộ sưu tập. Vì vậy, nó hoạt động theo một cách khác so với, chẳng hạn như Danh sách hoặc các Đối tượng bộ sưu tập khác. Mỗi phần tử của Map<Key, Value> đại diện cho một cặp khóa-giá trị. Cả Khóa và giá trị đều là một số đối tượng. Tất cả các khóa trong một bản đồ cụ thể là duy nhất, trong khi các giá trị thì không, vì vậy chúng có thể được sao chép. Bạn có thể nghĩ về Map trong Java như một loại từ điển hoặc danh mục cửa hàng trực tuyến, nơi bạn có thể tìm thấy bất kỳ mục nào bằng cách sử dụng chỉ mục duy nhất của nó. Khóa là mã định danh duy nhất của giá trị trong Bản đồ. Ví dụ: trong Map<String, Item> String là ID của một số Mặt hàng từ cửa hàng trực tuyến. Theo tài liệu Bản đồ có các Giao diện con tiếp theo:

Ràng buộc ;

ConcurrentMap<K,V> ;

ConcurrentNavigableMap<K,V> ;

LogicalMessageContext ;

Bối cảnh tin nhắn ;

NavigableMap<K,V> ;

SOAPMessageContext ;

SortedMap<K,V> .

Và thực hiện các lớp:

Trừu TượngBản Đồ
Thuộc tính
Nhà cung cấp xác thực
ConcurrentHashMap
Đồng thờiSkipListMap
EnumMap
Bản đồ băm
Hashtable
Bản SắcBămBản Đồ
LinkedHashMap
Máy inNhà nướcLý do
Của cải
Các nhà cung cấp
Kết xuấtGợi ý
ràng buộc đơn giản
Hỗ trợ dữ liệu dạng bảng
CâyBản Đồ
UIDefaults
YếuBămBản Đồ

Java AbstractMap là một lớp trừu tượng thực hiện hầu hết giao diện Bản đồ.
Java HashMap là một cấu trúc dữ liệu để lưu trữ các cặp khóa-giá trị bằng cách sử dụng bảng băm.
Java TreeMap là một cấu trúc dữ liệu để sử dụng một cây, tức là hiển thị với các phím được sắp xếp.
WeakHashMap để sử dụng bảng băm với các khóa yếu, hiển thị với các giá trị có thể bị xóa bởi trình thu gom rác nếu chúng không còn được sử dụng.
LinkedHashMap là một bản đồ có thứ tự thêm phần tử, cho phép lặp theo thứ tự chèn.
EnumMap mở rộng lớp AbstractMap để sử dụng với các khóa enum.

IdentityHashMap sử dụng kiểm tra tính tương đương tham chiếu khi so sánh tài liệu, ánh xạ với các khóa được so sánh bằng thao tác == thay vì phương thức equals()

Ở đây, chúng tôi quan tâm đến việc triển khai Giao diện Bản đồ phổ biến nhất: HashMap, TreeMap và LinkedHashMap. Nhân tiện, thứ tự của các thành phần bản đồ phụ thuộc vào việc triển khai cụ thể. Giả sử, TreeMap và LinkedHashMap có thứ tự các phần tử có thể dự đoán được, trong khi HashMap thì không.

phương pháp bản đồ

Các hoạt động chính của bất kỳ Bản đồ nào là chèn, xóa và tìm kiếm các phần tử.

public Object put(Khóa đối tượng, Giá trị đối tượng) chèn một phần tử vào bản đồ.
public void putAll(Map map) chèn bản đồ đã chỉ định vào bên trong bản đồ.
public Object remove(Object key) xóa một mục nhập theo khóa đã chỉ định.
public Object get(Object key) trả về giá trị cho khóa đã chỉ định.
public boolean containsKey(Object key) tìm kiếm khóa được chỉ định từ bản đồ này
public Set keySet() trả về chế độ xem Set chứa tất cả các khóa
public Set entrySet() trả về chế độ xem Set với tất cả các khóa và giá trị.

HashMap là gì

HashMap là gì? Đây là triển khai phổ biến nhất của giao diện Map<Key,Value>. Cấu trúc dữ liệu này dựa trên nguyên tắc băm.

Nguyên tắc chính của công việc HashMap: băm

Để hiểu hashmap là gì và nó hoạt động như thế nào, trước tiên hãy nói về hàm băm và hàm băm. Hàm băm chỉ là một hàm theo nghĩa toán học. Vì vậy, có một số giá trị đầu vào (một đối tượng, một phần dữ liệu) và hàm chuyển đổi nó bằng cách sử dụng một quy tắc thích hợp thành giá trị đầu ra - một hàm băm. Băm khá thường xuyên là một số thập lục phân có độ dài phù hợp. Các quy tắc của quá trình chuyển đổi có thể khác nhau, nhưng chúng tuân theo các nguyên tắc sau:

Một đầu vào cụ thể (đối tượng) có một mã băm cụ thể.
Nếu hai đối tượng bằng nhau, mã băm của chúng cũng bằng nhau. Điều ngược lại là không đúng sự thật.
Nếu các mã băm khác nhau, các đối tượng chắc chắn không bằng nhau.
Đôi khi các đối tượng khác nhau có thể có cùng mã băm. Đó là một sự kiện rất khó xảy ra, được đặt tên là “va chạm” và một hàm băm chất lượng tốt sẽ giảm thiểu xác suất va chạm.

Trong Java, mọi đối tượng đều có mã băm. Nó được tính bằng phương thức hashCode của lớp Đối tượng, lớp cha của tất cả các Đối tượng Java. Thông thường, các nhà phát triển ghi đè phương thức này cho các lớp của riêng họ cũng như các phương thức bằng được liên kết với nó.

HashMap: cách thức hoạt động

Vì vậy, Class HashMap<K,V> vì mọi triển khai Bản đồ bao gồm các khóa và giá trị. Nó lưu trữ các khóa bằng cách sử dụng các nguyên tắc băm. Bên trong HashMap Các cặp khóa-giá trị được lưu trữ trong các "nhóm", các nhóm này cùng nhau tạo thành một "bảng", một mảng nội bộ gồm các danh sách được liên kết và kích thước ban đầu của nó là 16. HashMap trong Java sử dụng mã băm của khóa để xác định nhóm nơi cặp khóa/giá trị sẽ ánh xạ: Tính năng phức tạp của HashMap là mỗi ô (nhóm) của bảng [] không chỉ giữ một cặp mà còn nhiều cặp. Chúng không được lưu trữ dưới dạng một đối tượng rõ ràng (như LinkedList), mà dưới dạng một chuỗi ẩn. Chuỗi được tạo ra do mỗi cặp lưu trữ một liên kết đến cặp tiếp theo. Nghĩa là, tất cả các cặp HashMap nằm rải rác trên 16 chuỗi. Khi bạn đặt một cặp mới vào bảng, hàm băm của khóa sẽ được xem xét. Hàm băm này không phải là hàm mã băm được tích hợp trong đối tượng khóa. Nó được coi là nằm trong khoảng 0-15. Cặp này được thêm vào chuỗi các cặp được lưu trữ trong nhóm với chỉ số băm. Cách tiếp cận này mang lại cho chúng tôi khả năng tăng tốc tìm kiếm. Trong khi tìm kiếm một cặp theo khóa, không cần phải xem toàn bộ bảng. Giá trị băm của khóa được xem xét và chỉ chuỗi được lưu trữ trong ô có chỉ số băm mới được kiểm tra. Nếu có quá nhiều cặp trong HashMap, chuỗi sẽ trở nên quá dài. Sau đó, kích thước của mảng tăng lên, hàm băm của tất cả các đối tượng được lưu trữ được tính toán lại và chúng nằm rải rác dọc theo các chuỗi mới.

Tuyên bố HashMap

Nếu bạn truy cập mã HashMap của lớp, bạn sẽ tìm thấy phần khai báo tiếp theo:

public class HashMap extends AbstractMap implements Map, Cloneable, Serializable

Trong đó K là loại khóa được duy trì bởi bản đồ này và V - loại giá trị được ánh xạ. Đây là một ví dụ về khai báo HashMap với khóa Số nguyên và giá trị Chuỗi trong mã của bạn:

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

phương pháp HashMap

Đây là danh sách các phương pháp HashMap.

Lấy đối tượng(Khóa đối tượng) trả về giá trị cho khóa đã chỉ định;
Đặt đối tượng(Khóa k, Giá trị v) chèn ánh xạ giá trị khóa vào bản đồ;
Xóa đối tượng(Khóa đối tượng) xóa ánh xạ cho khóa đã chỉ định khỏi bản đồ này nếu có;
void clear() xóa tất cả các cặp khóa-giá trị khỏi HashMap;
Bản sao đối tượng() trả về một bản sao nông của phiên bản HashMap này mà không sao chép các khóa và giá trị;
boolean containsKey(Khóa đối tượng) trả về true nếu tìm thấy khóa đã chỉ định trong bản đồ, sai nếu không tìm thấy;
boolean containsValue(Object Value) trả về true nếu tìm thấy khóa đã chỉ định trong bản đồ, sai nếu không tìm thấy;
boolean isEmpty() trả về true nếu bản đồ trống, sai nếu không;
Đặt keySet() trả về Tập hợp các khóa được tìm nạp từ bản đồ;
int size() trả về số lượng ánh xạ khóa-giá trị;
Collection values() trả về một tập hợp các giá trị của bản đồ;
Xóa đối tượng(Khóa đối tượng) xóa cặp khóa-giá trị cho khóa đã chỉ định;
void putAll(Map m) sao chép tất cả các thành phần của bản đồ sang bản đồ khác.

Ví dụ Java HashMap

Hãy tạo một chương trình với Java HashMap Ví dụ để minh họa cách thức hoạt động của nó:

import java.util.HashMap;
import java.util.Map;
import java.util.Iterator;
import java.util.Set;

public class HashMap {

   public static void main(String[] args) {

       {

           // HashMap declaration
           HashMap<Integer, String> myHashMap = new HashMap<Integer, String>();

           //Adding elements into HashMap
           myHashMap.put(7, "Johnny");
           myHashMap.put(8, "Ivy");
           myHashMap.put(1, "Rick");
           myHashMap.put(4, "Stan");
           myHashMap.put(3, "Kyle");

           //print out the map content using Iterator
           Set set = myHashMap.entrySet();
           Iterator iterator = set.iterator();
           while (iterator.hasNext()) {
               Map.Entry mapEntry = (Map.Entry) iterator.next();
               System.out.print("key: " + mapEntry.getKey() + " value: ");
               System.out.println(mapEntry.getValue());
           }
           System.out.println("get an element from myHashMap via key and print the value out:");
           System.out.println(myHashMap.get(8));
           //print out hashMap on standard way:
           System.out.println(myHashMap);

           // Get values based on key
           String var = myHashMap.get(2);
           //here we'll get null, we don't have such a key
           System.out.println("Value with key 2: " + var);
           var = myHashMap.get(7);
           System.out.println("Value with key 7: " + var);

           // Remove values based on key
           myHashMap.remove(4);
           System.out.println("myHashMap after removing element:");
           System.out.println(myHashMap);
           myHashMap.clear();
           System.out.println("myHashMap after total clearing:");
           System.out.println(myHashMap);
       }

   }
}

Kết quả chạy chương trình:

key: 1 value: Rick
key: 3 value: Kyle
key: 4 value: Stan
key: 7 value: Johnny
key: 8 value: Ivy
get an element from myHashMap via key and print the value out:
Ivy
{1=Rick, 3=Kyle, 4=Stan, 7=Johnny, 8=Ivy}
Value with key 2: null
Value with key 7: Johnny
myHashMap after removing element:
{1=Rick, 3=Kyle, 7=Johnny, 8=Ivy}
myHashMap after total clearing:
{}

CâyBản Đồ

TreeMap trong Java cũng triển khai giao diện Map<Key,Value>, nhưng nó dựa trên cấu trúc dữ liệu cây Đỏ-Đen. Một Cây bao gồm các "nút" và các đường nối các nút - nhánh". Nút "gốc" nằm ở trên cùng của cây. Từ gốc có thể có các nhánh và các nút. Đó là một cấu trúc phân cấp, bạn có thể nghĩ các nút này là "con" của gốc. Nút con có thể có các nút con của chính nó - các nút thấp hơn. Các nút không có nút con được gọi là "nút cuối" hoặc "các lá". Cây nhị phân là một cây mà mọi nút đều có 0, 1 hoặc hai con. Cây tìm kiếm nhị phân là một cấu trúc, trong đó mỗi nút bên trong lưu trữ một khóa và đôi khi là một giá trị được liên kết và có hai cây con phân biệt ("trái" và "phải"). Cây tìm kiếm nhị phân tự cân bằng là cây tìm kiếm nhị phân dựa trên nút tự động giữ chiều cao của nó (số lượng cấp tối đa bên dưới gốc) nhỏ khi đối mặt với việc chèn và xóa mục tùy ý. Cây đỏ đen là cây nhị phân cân bằng có các tính chất:

Mỗi nút có màu đỏ hoặc đen
Gốc luôn đen
Mỗi lá là một nút NIL (loại rỗng, rỗng) và nó có màu đen
Nếu một nút có màu đỏ, thì các nút con của nó chắc chắn có màu đen.
Mọi đường đi đơn giản từ một nút đến một lá con đều chứa cùng một số nút đen.

Các tính năng của TreeMap

TreeMap sử dụng cấu trúc dữ liệu cây để lưu trữ các khóa dưới dạng các nút và sắp xếp các khóa bằng thuật toán Cây Đỏ-Đen. Vì vậy, TreeMap giữ cho các mục của nó được sắp xếp theo thứ tự tự nhiên của các khóa. Đối với số tự nhiên là thứ tự tăng dần, đối với chuỗi - thứ tự bảng chữ cái. Bạn có thể sử dụng một bộ so sánh nếu bạn cần thay đổi logic đặt hàng. Sắp xếp các đối tượng theo cách tự nhiên là một lợi thế lớn của TreeMap, cũng như tìm một số đối tượng bằng các bộ lọc và điều kiện khác nhau.

phương pháp TreeMap

Object get(Khóa đối tượng) trả về giá trị của khóa tương ứng;
Đặt đối tượng (Khóa đối tượng, Giá trị đối tượng) chèn ánh xạ vào bản đồ;
Xóa đối tượng(Khóa đối tượng) xóa ánh xạ cho khóa này nếu TreeMap chứa nó;
boolean containsKey(Khóa đối tượng) trả về true nếu bản đồ này chứa ánh xạ cho khóa đã chỉ định;
boolean containsValue(Object value) trả về true nếu TreeMap ánh xạ một hoặc nhiều khóa tới giá trị đã chỉ định;
Object firstKey() trả về khóa đầu tiên hiện có trong bản đồ đã sắp xếp;
Đối tượng lastKey() trả về khóa cuối cùng hiện có trong bản đồ đã sắp xếp;
void putAll(Bản đồ bản đồ) sao chép tất cả các ánh xạ từ bản đồ đã chỉ định sang bản đồ;
Đặt entrySet() trả về chế độ xem đã đặt của ánh xạ
int size() trả về số lượng ánh xạ khóa-giá trị
Giá trị bộ sưu tập() trả về chế độ xem bộ sưu tập các giá trị
Object clone() trả về một bản sao nông của TreeMap
void clear() xóa tất cả ánh xạ khỏi TreeMap
SortedMap headMap(Object key_value) trả về chế độ xem của phần bản đồ nhỏ hơn tham số key_value
Đặt keySet() trả về chế độ xem Đặt của các khóa có trong sơ đồ cây
SortedMap subMap(K fromKey, K toKey) trả về chế độ xem của phần bản đồ này có các khóa nằm trong khoảng fromKey, bao gồm, đến toKey, độc quyền
Object firstKey() trả về khóa đầu tiên từ TreeMap.

ví dụ TreeMap

import java.util.TreeMap;
import java.util.Set;
import java.util.Iterator;
import java.util.Map;

public class TreeMapExample {

   public static void main(String args[]) {

       //TreeMap declaration
       TreeMap<Integer, String> myTreeMap = new TreeMap<Integer, String>();

       //put elements to TreeMap
       myTreeMap.put(1, "Stuart");
       myTreeMap.put(23, "Michael");
       myTreeMap.put(7, "Johnny");
       myTreeMap.put(5, "Ivy");
       myTreeMap.put(2, "Alex");

       //Display and print out myTreeMap using Iterator
       Set set = myTreeMap.entrySet();
       Iterator iterator = set.iterator();
       while (iterator.hasNext()) {
           Map.Entry myEntry = (Map.Entry) iterator.next();
           System.out.print("key: " + myEntry.getKey() + " value: ");
           System.out.println(myEntry.getValue());
       }
       //TreeMap printed in classical way
       System.out.println(myTreeMap);
       //removing an element with the key =2
       myTreeMap.remove(2);
       //myTreeMap after removing:
       System.out.println(myTreeMap);
   }
}

Kết quả chạy chương trình:

key: 1 value: Stuart
key: 2 value: Alex
key: 5 value: Ivy
key: 7 value: Johnny
key: 23 value: Michael
{1=Stuart, 2=Alex, 5=Ivy, 7=Johnny, 23=Michael}
{1=Stuart, 5=Ivy, 7=Johnny, 23=Michael}

LinkedHashMap

LinkedHashMap là một cấu trúc dữ liệu kết hợp danh sách liên kết và bản đồ băm. Thật vậy, LinkedHashMap mở rộng lớp HashMap và triển khai giao diện Bản đồ, nhưng danh sách được liên kết là gì? Tuyên bố của LinkedHashMap:

Map <Integer, String> linkedHashMap = new LinkedHashMap <Integer, String>();

LinkedHashMap mới này kế thừa các thuộc tính từ HashMap (chẳng hạn như bảng, loadFactor, ngưỡng, kích thước, entrySet), cũng có hai thuộc tính đặc biệt:

header là phần đầu của danh sách liên kết kép. Trong quá trình khởi tạo, nó chỉ ra chính nó
accessOrder chỉ ra cách truy cập vào các phần tử bằng iterator. Nếu đúng, theo thứ tự của lần truy cập cuối cùng. Nếu sai, quyền truy cập sẽ theo thứ tự các phần tử được chèn vào.

Danh sách được liên kết này xác định thứ tự lặp lại. Thông thường, đó là thứ tự chèn phím vào bản đồ.

Phương thức LinkedHashMap

Nhận đối tượng(Khóa đối tượng) trả về giá trị mà khóa đã chỉ định được ánh xạ tới hoặc null nếu ánh xạ này không chứa ánh xạ cho khóa
void clear() xóa tất cả ánh xạ khỏi bản đồ.
boolean containsKey(Khóa đối tượng) trả về true nếu phần tử đã chỉ định được ánh xạ bởi một hoặc nhiều khóa
boolean removeEldestEntry(Map.Entry già nhất) trả về true nếu bản đồ xóa mục nhập lớn nhất của nó khỏi bản đồ
Set<Map.Entry<K,V>> entrySet() trả về chế độ xem Tập hợp của các ánh xạ có trong bản đồ này
void forEach(BiConsumer<? super K,? super V> action) thực hiện hành động nhất định cho mỗi mục nhập trong bản đồ này cho đến khi tất cả các mục nhập đã được xử lý hoặc hành động đưa ra một ngoại lệ.
Object getOrDefault(Khóa đối tượng, V defaultValue) trả về giá trị mà khóa đã chỉ định được ánh xạ tới. Nếu bản đồ không chứa ánh xạ cho khóa sẽ trả về giá trị mặc định.
Set<K> keySet() trả về chế độ xem Đặt của các khóa có trong bản đồ
boolean removeEldestEntry(Map.Entry<K,V> già nhất) trả về true nếu bản đồ này sẽ xóa mục nhập lớn nhất của nó
void replaceAll(BiFunction<? super K, ?super V, ?extend V> function) thay thế từng giá trị mục nhập bằng kết quả của việc gọi hàm đã cho trên mục nhập đó cho đến khi tất cả các mục nhập đã được xử lý hoặc hàm đưa ra một ngoại lệ.
Collection<v>values() trả về chế độ xem Bộ sưu tập của các giá trị có trong bản đồ

LinkedHashMap ví dụ

import java.util.LinkedHashMap;
import java.util.Set;
import java.util.Iterator;
import java.util.Map;
   public class HashLinkedListExample {
       public static void main(String args[]) {
           // LinkedHashMap Declaration
           LinkedHashMap<Integer, String> myLinkedHashMap =
                   new LinkedHashMap<Integer, String>();

           //Adding elements into LinkedHashMap
           myLinkedHashMap.put(7, "Johnny");
           myLinkedHashMap.put(12, "Rick");
           myLinkedHashMap.put(1, "Kyle");
           myLinkedHashMap.put(5, "Percy");
           myLinkedHashMap.put(85, "Sebastian");

           // Generate a Set of entries
           Set set = myLinkedHashMap.entrySet();

           // Display and print out the nodes  of LinkedHashMap
           Iterator iterator = set.iterator();
           while(iterator.hasNext()) {
               Map.Entry me = (Map.Entry)iterator.next();
               System.out.print("key: "+ me.getKey() +
                       " value: "+me.getValue()+"\n");
           }
           //print out HashLinkedMap on standard way:
           System.out.println(myLinkedHashMap);
           myLinkedHashMap.put(21, "Ivy");
           System.out.println(myLinkedHashMap);
           myLinkedHashMap.remove(12);
           System.out.println(myLinkedHashMap);
           myLinkedHashMap.put(12, "Ronny");
           System.out.println(myLinkedHashMap);
           myLinkedHashMap.put(1, "Stan");
           System.out.println(myLinkedHashMap);
       }
   }

Ở đây, chúng tôi tạo một LinkedHashMap mới, thêm năm phần tử, sau đó in nó ra bằng cách sử dụng trình vòng lặp và theo cách cổ điển. Như bạn có thể thấy, LinkedHashMap duy trì thứ tự chèn. Sau đó, chúng tôi xóa một phần tử khỏi Bản đồ của mình, sau đó thêm phần tử mới và sau đó - một phần tử khác có khóa, phần tử đó đã có trên bản đồ. Nó thay thế giá trị cũ được ánh xạ tới khóa này. Kết quả chạy chương trình:

key: 7 value: Johnny
key: 12 value: Rick
key: 1 value: Kyle
key: 5 value: Percy
key: 85 value: Sebastian
{7=Johnny, 12=Rick, 1=Kyle, 5=Percy, 85=Sebastian}
{7=Johnny, 12=Rick, 1=Kyle, 5=Percy, 85=Sebastian, 21=Ivy}
{7=Johnny, 1=Kyle, 5=Percy, 85=Sebastian, 21=Ivy}
{7=Johnny, 1=Kyle, 5=Percy, 85=Sebastian, 21=Ivy, 12=Ronny}
{7=Johnny, 1=Stan, 5=Percy, 85=Sebastian, 21=Ivy, 12=Ronny}

So sánh HashMap, TreeMap, LinkedHashMap

HashMap, TreeMap và LinkedHashMap là các triển khai của giao diện Bản đồ. HashMap và LinkedHashMap là cấu trúc dữ liệu băm khóa. TreeMap sử dụng thứ tự tự nhiên của các khóa để tổ chức cây tìm kiếm. Đặt hàng:

HashMap không duy trì bất kỳ trật tự nào.
TreeMap sắp xếp các mục theo thứ tự tăng dần của các khóa.
LinkedHashMap duy trì thứ tự chèn.

Phím rỗng:

HashMap và LinkedHashMap cho phép có một khóa null.
LinkedHashMap không cho phép các khóa rỗng trong trường hợp các khóa sử dụng thứ tự tự nhiên hoặc Bộ so sánh không hỗ trợ so sánh trên các lớp rỗng.

Hãy lấy một ví dụ về bản đồ Java bao gồm cả ba cách triển khai được xem xét trong bài viết này:

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.TreeMap;

public class CompMapImpl {


    public static void main(String[] args) {
        HashMap<Integer, String> hashMap = new HashMap<>();
        TreeMap<Integer, String> treeMap = new TreeMap<>();
        LinkedHashMap<Integer, String> linkedHashMap = new LinkedHashMap<>();
        hashMap.put(5, "Ivy");
        hashMap.put(null, "Joker");
        hashMap.put(1, "First");
        hashMap.put(2, "Kyle");
        hashMap.put(-2, "Paul");
        hashMap.put(3, "Sandy");


        treeMap.put(5, "Ivy");
        //treeMap.put(null,"Joker");
        treeMap.put(1, "First");
        treeMap.put(2, "Kyle");
        treeMap.put(-2, "Paul");
        treeMap.put(3, "Sandy");

        linkedHashMap.put(5, "Ivy");
        linkedHashMap.put(null, "Joker");
        linkedHashMap.put(1, "First");
        linkedHashMap.put(2, "Kyle");
        linkedHashMap.put(-2, "Paul");
        linkedHashMap.put(3, "Sandy");
        System.out.println("HashMap");
        System.out.println(hashMap);
        System.out.println("TreeMap");
        System.out.println(treeMap);
        System.out.println("LinkedHashMap");
        System.out.println(linkedHashMap);


        LinkedHashMap<String, String> linkedHashMap1= new LinkedHashMap<> ();
        linkedHashMap1.put(null, "Andy");
        System.out.println(linkedHashMap1);
    }
}

Đây là kết quả của việc chạy chương trình này:

HashMap
{null=Joker, 1=First, -2=Paul, 2=Kyle, 3=Sandy, 5=Ivy}
TreeMap
{-2=Paul, 1=First, 2=Kyle, 3=Sandy, 5=Ivy}
LinkedHashMap
{5=Ivy, null=Joker, 1=First, 2=Kyle, -2=Paul, 3=Sandy}
{null=Andy}

Như chúng ta có thể thấy, thứ tự của các phần tử trong HashMap là không rõ ràng, trong treeMap nó phụ thuộc vào các khóa, trong LinkedHashMap nó phụ thuộc vào thứ tự chèn. Nếu chúng tôi cố gắng đặt khóa null vào LinkedHashMap, chúng tôi sẽ nhận được NullPulumException, nhưng trong LinkedHashMap1, nơi các khóa là Chuỗi, chúng tôi có thể làm điều đó. Bản đồ băm là cách triển khai bản đồ có mục đích chung tốt nhất. Nó cung cấp tốc độ tìm kiếm tối đa, lưu trữ nhanh và thao tác truy xuất, nhưng bạn nên nhớ về thứ tự hỗn loạn của nó. Bản đồ băm được liên kết kế thừa các ưu điểm của HashMap và nhận được thứ tự cho các khóa. Tuy nhiên, nó chứa LinkedList tương đối tốn bộ nhớ. nó chậm hơn HashMap khi tìm kiếm và chậm hơn một chút khi thêm/xóa do duy trì danh sách được liên kết. Bản đồ cây lưu trữ các khóa được sắp xếp theo thứ tự tăng dần. Tuy nhiên, Để củng cố những gì bạn đã học, chúng tôi khuyên bạn nên xem một video bài học từ Khóa học Java của chúng tôi

Đọc thêm:
Cách cập nhật giá trị của khóa hiện có trong HashMap Phương thức HashMap getOrDefault trong Java Phương thức KeySet trong java.util.Map