Sự khác biệt giữa HashMap, LinkedHashMap và TreeMap

Sự khác nhau giữa là gì HashMap, LinkedHashMapvà TreeMaptrong Java? Tôi không thấy bất kỳ sự khác biệt nào trong đầu ra vì cả ba đều có keySetvà values. Là Hashtablegì

Map m1 = new HashMap();
m1.put("map", "HashMap");
m1.put("schildt", "java2");
m1.put("mathew", "Hyden");
m1.put("schildt", "java2s");
print(m1.keySet()); 
print(m1.values()); 

SortedMap sm = new TreeMap();
sm.put("map", "TreeMap");
sm.put("schildt", "java2");
sm.put("mathew", "Hyden");
sm.put("schildt", "java2s");
print(sm.keySet()); 
print(sm.values());

LinkedHashMap lm = new LinkedHashMap();
lm.put("map", "LinkedHashMap");
lm.put("schildt", "java2");
lm.put("mathew", "Hyden");
lm.put("schildt", "java2s");
print(lm.keySet()); 
print(lm.values());

Tất cả ba lớp thực hiện Mapgiao diện và cung cấp hầu hết các chức năng giống nhau. Sự khác biệt quan trọng nhất là thứ tự lặp đi lặp lại qua các mục sẽ xảy ra:

• HashMaplàm cho hoàn toàn không đảm bảo về thứ tự lặp. Nó thậm chí có thể (và sẽ) thay đổi hoàn toàn khi các yếu tố mới được thêm vào.
• TreeMapsẽ lặp lại theo "thứ tự tự nhiên" của các khóa theo compareTo()phương thức của chúng (hoặc được cung cấp bên ngoài Comparator). Ngoài ra, nó thực hiện SortedMapgiao diện, chứa các phương thức phụ thuộc vào thứ tự sắp xếp này.
• LinkedHashMap sẽ lặp theo thứ tự các mục được đưa vào bản đồ

"Hashtable" là tên chung cho các bản đồ dựa trên hàm băm. Trong ngữ cảnh của API Java, Hashtablelà một lớp lỗi thời từ thời Java 1.1 trước khi khung bộ sưu tập tồn tại. Không nên sử dụng nó nữa, vì API của nó bị lộn xộn với các phương thức lỗi thời có chức năng trùng lặp và các phương thức của nó được đồng bộ hóa (có thể làm giảm hiệu suất và nói chung là vô dụng). Sử dụng ConcảnHashMap thay vì Hashtable.

Tôi thích trình bày trực quan:

╔══════════════╦═════════════════════╦═══════════════════╦═════════════════════╗
║   Property   ║       HashMap       ║      TreeMap      ║     LinkedHashMap   ║
╠══════════════╬═════════════════════╬═══════════════════╬═════════════════════╣
║ Iteration    ║  no guarantee order ║ sorted according  ║                     ║
║   Order      ║ will remain constant║ to the natural    ║    insertion-order  ║
║              ║      over time      ║    ordering       ║                     ║
╠══════════════╬═════════════════════╬═══════════════════╬═════════════════════╣
║  Get/put     ║                     ║                   ║                     ║
║   remove     ║         O(1)        ║      O(log(n))    ║         O(1)        ║
║ containsKey  ║                     ║                   ║                     ║
╠══════════════╬═════════════════════╬═══════════════════╬═════════════════════╣
║              ║                     ║   NavigableMap    ║                     ║
║  Interfaces  ║         Map         ║       Map         ║         Map         ║
║              ║                     ║    SortedMap      ║                     ║
╠══════════════╬═════════════════════╬═══════════════════╬═════════════════════╣
║              ║                     ║                   ║                     ║
║     Null     ║       allowed       ║    only values    ║       allowed       ║
║ values/keys  ║                     ║                   ║                     ║
╠══════════════╬═════════════════════╩═══════════════════╩═════════════════════╣
║              ║   Fail-fast behavior of an iterator cannot be guaranteed      ║
║   Fail-fast  ║ impossible to make any hard guarantees in the presence of     ║
║   behavior   ║           unsynchronized concurrent modification              ║
╠══════════════╬═════════════════════╦═══════════════════╦═════════════════════╣
║              ║                     ║                   ║                     ║
║Implementation║      buckets        ║   Red-Black Tree  ║    double-linked    ║
║              ║                     ║                   ║       buckets       ║
╠══════════════╬═════════════════════╩═══════════════════╩═════════════════════╣
║      Is      ║                                                               ║
║ synchronized ║              implementation is not synchronized               ║
╚══════════════╩═══════════════════════════════════════════════════════════════╝

Tất cả ba thể hiện ánh xạ từ các khóa duy nhất đến các giá trị và do đó thực hiện giao diện Bản đồ .

1. HashMap là một bản đồ dựa trên băm các phím. Nó hỗ trợ các thao tác get / put O (1). Các khóa phải có triển khai nhất quán hashCode()vàequals() để làm việc này.

2. LinkedHashMap rất giống với HashMap, nhưng nó bổ sung nhận thức về thứ tự các mục được thêm (hoặc truy cập), do đó thứ tự lặp giống như thứ tự chèn (hoặc thứ tự truy cập, tùy thuộc vào tham số xây dựng).

3. TreeMap là một ánh xạ dựa trên cây. Các hoạt động put / get của nó mất thời gian O (log n). Nó đòi hỏi các mục phải có một số cơ chế so sánh, với So sánh hoặc So sánh. Thứ tự lặp được xác định bởi cơ chế này.

Xem vị trí của mỗi lớp trong hệ thống phân cấp lớp trong sơ đồ sau (lớp lớn hơn ). TreeMap thực hiện SortedMapvà NavigableMaptrong khi HashMapkhông.

HashTableđã lỗi thời và ConcurrentHashMaplớp tương ứng nên được sử dụng.

Bản đồ băm

• Nó có cặp giá trị (khóa, giá trị)
• KHÔNG có giá trị khóa trùng lặp
• không có thứ tự
• nó cho phép một khóa null và nhiều hơn một giá trị null

HashTable

• giống như bản đồ băm
• nó không cho phép khóa null và giá trị null

LinkedHashMap

• Nó được đặt hàng phiên bản thực hiện bản đồ
• Dựa trên danh sách liên kết và cấu trúc dữ liệu băm

Bản đồ cây

• Phiên bản đặt hàng và sắp xếp
• dựa trên cấu trúc dữ liệu băm

Chỉ cần thêm một số thông tin từ trải nghiệm của riêng tôi với bản đồ, khi tôi sẽ sử dụng từng bản đồ:

• HashMap - Hữu ích nhất khi tìm kiếm một triển khai hiệu suất tốt nhất (nhanh).
• TreeMap (Giao diện SortedMap) - Hữu ích nhất khi tôi quan tâm đến việc có thể sắp xếp hoặc lặp lại các khóa theo thứ tự cụ thể mà tôi xác định.
• LinkedHashMap - Kết hợp các lợi thế của việc đặt hàng được đảm bảo từ TreeMap mà không tăng chi phí duy trì TreeMap. (Nó gần như nhanh như HashMap). Đặc biệt, LinkedHashMap cũng cung cấp một điểm khởi đầu tuyệt vời để tạo một đối tượng Cache bằng cách ghi đè removeEldestEntry()phương thức. Điều này cho phép bạn tạo một đối tượng Cache có thể hết hạn dữ liệu bằng cách sử dụng một số tiêu chí mà bạn xác định.

Cả ba lớp HashMap, TreeMapvà LinkedHashMapdụng cụ java.util.Mapgiao tiếp, và đại diện cho ánh xạ từ khóa duy nhất để các giá trị.

Bản đồ băm

1. A HashMapchứa các giá trị dựa trên khóa.

2. Nó chỉ chứa các yếu tố độc đáo.

3. Nó có thể có một khóa null và nhiều giá trị null.

4. Nó duy trì không có trật tự .

   public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable

LinkedHashMap

1. A LinkedHashMapchứa các giá trị dựa trên khóa.
2. Nó chỉ chứa các yếu tố độc đáo.
3. Nó có thể có một khóa null và nhiều giá trị null.

4. Nó giống như HashMap thay vì duy trì thứ tự chèn . // Xem giảm tốc lớp dưới đây

   public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V>

Bản đồ cây

1. A TreeMapchứa các giá trị dựa trên khóa. Nó triển khai giao diện NavigableMap và mở rộng lớp AbstractMap.
2. Nó chỉ chứa các yếu tố độc đáo.
3. Nó không thể có khóa null nhưng có thể có nhiều giá trị null.

4. Nó giống như HashMapthay vào đó duy trì thứ tự tăng dần (Sắp xếp theo thứ tự tự nhiên của khóa của nó.).

   public class TreeMap<K,V> extends AbstractMap<K,V> implements NavigableMap<K,V>, Cloneable, Serializable

Hashtable

1. Hashtable là một mảng danh sách. Mỗi danh sách được gọi là một cái xô. Vị trí của xô được xác định bằng cách gọi phương thức hashcode (). Hashtable chứa các giá trị dựa trên khóa.
2. Nó chỉ chứa các yếu tố độc đáo.
3. Nó có thể không có bất kỳ khóa hoặc giá trị null.
4. Nó được đồng bộ hóa .

5. Đó là một lớp kế thừa.

   public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, Serializable

Tham chiếu: http://javarevisited.blogspot.in/2015/08/difference-b between-HastMap-vs-TreeMap-vs-LinkedHashMap-Java.html

HashMap hoàn toàn không đảm bảo về thứ tự lặp. Nó thậm chí có thể (và sẽ) thay đổi hoàn toàn khi các yếu tố mới được thêm vào. TreeMap sẽ lặp lại theo "thứ tự tự nhiên" của các khóa theo phương thức so sánh của chúng (hoặc một Bộ so sánh được cung cấp bên ngoài). Ngoài ra, nó thực hiện giao diện SortedMap, chứa các phương thức phụ thuộc vào thứ tự sắp xếp này. LinkedHashMap sẽ lặp lại theo thứ tự các mục được đưa vào bản đồ

Nhìn vào cách hiệu suất khác nhau ..

Bản đồ cây là một triển khai của Bản đồ được sắp xếp. Độ phức tạp của thao tác put, get và chứaKey là O (log n) do thứ tự tự nhiên

@Amit: SortedMaplà một giao diện trong khi đó TreeMaplà một lớp thực hiện SortedMapgiao diện. Điều đó có nghĩa là nếu tuân theo giao thức SortedMapyêu cầu người thực hiện nó thực hiện. Cây trừ khi được triển khai dưới dạng cây tìm kiếm, không thể cung cấp cho bạn dữ liệu theo thứ tự vì cây có thể là bất kỳ loại cây nào. Vì vậy, để làm cho TreeMap hoạt động như thứ tự Sắp xếp, nó triển khai SortedMap (ví dụ: Cây tìm kiếm nhị phân - BST, BST cân bằng như AVL và Cây RB, thậm chí là Cây tìm kiếm Ternary - chủ yếu được sử dụng cho tìm kiếm lặp theo cách có thứ tự).

public class TreeMap<K,V>
extends AbstractMap<K,V>
implements SortedMap<K,V>, Cloneable, Serializable

Trong NUT-SHELL HashMap: cung cấp dữ liệu trong O (1), không đặt hàng

TreeMap : cung cấp dữ liệu trong O (log N), cơ sở 2. với các phím được đặt hàng

LinkedHashMap: là bảng Hash với khả năng danh sách được liên kết (nghĩ về chỉ mục-SkipList) để lưu trữ dữ liệu theo cách nó được chèn vào cây. Phù hợp nhất để thực hiện LRU (ít được sử dụng gần đây).

Sau đây là sự khác biệt lớn giữa HashMap và TreeMap

1. HashMap không duy trì bất kỳ trật tự. Nói cách khác, HashMap không cung cấp bất kỳ đảm bảo nào rằng phần tử được chèn trước sẽ được in trước, trong đó, giống như TreeSet, các phần tử TreeMap cũng được sắp xếp theo thứ tự tự nhiên của các phần tử của nó

2. Việc triển khai HashMap nội bộ sử dụng Hashing và TreeMap bên trong sử dụng triển khai cây Red-Black.

3. HashMap có thể lưu trữ một khóa null và nhiều giá trị null. Bản đồ không thể chứa khóa null nhưng có thể chứa nhiều giá trị null.

4. HashMap có hiệu suất thời gian không đổi cho các hoạt động cơ bản như get và put tức là O (1). Theo tài liệu của Oracle, TreeMap cung cấp chi phí thời gian log (n) được đảm bảo cho phương thức get và put.

5. HashMap nhanh hơn nhiều so với TreeMap, vì thời gian thực hiện của HashMap không đổi so với thời gian đăng nhập TreeMap cho hầu hết các hoạt động.

6. HashMap sử dụng phương thức equals () trong khi so sánh trong khi TreeMap sử dụng phương thức so sánh () để duy trì trật tự.

7. HashMap thực hiện giao diện Bản đồ trong khi TreeMap thực hiện giao diện NavigableMap.

Đây là những triển khai khác nhau của cùng một giao diện. Mỗi triển khai có một số ưu điểm và một số nhược điểm (chèn nhanh, tìm kiếm chậm) hoặc ngược lại.

Để biết chi tiết, hãy xem javadoc của TreeMap , HashMap , LinkedHashMap .

Bản đồ băm không bảo tồn thứ tự chèn.
Thí dụ. Hashmap Nếu bạn đang chèn khóa như

1  3
5  9
4   6
7   15
3   10

Nó có thể lưu trữ nó như là

4  6
5  9
3  10
1  3
7  15

Hashmap được liên kết bảo tồn thứ tự chèn.

Thí dụ.
Nếu bạn đang chèn phím

1  3
5  9
4   6
7   15
3   10

Nó sẽ lưu trữ nó như là

1  3
5  9
4   6
7   15
3   10

tương tự như chúng tôi chèn.

Bản đồ cây lưu trữ các giá trị trong Tăng thứ tự phím. Thí dụ.
Nếu bạn đang chèn phím

1  3
5  9
4   6
7   15
3   10

Nó sẽ lưu trữ nó như là

1  3
3  10
4   6
5   9
7   15

• Bản đồ băm:

  • Lệnh không duy trì
  • Nhanh hơn LinkedHashMap
  • Được sử dụng để lưu trữ đống đồ vật

• LinkedHashMap:

  • Thứ tự chèn LinkedHashMap sẽ được duy trì
  • Chậm hơn HashMap và nhanh hơn TreeMap
  • Nếu bạn muốn duy trì một thứ tự chèn hãy sử dụng cái này.

• Bản đồ cây:

  • TreeMap là một ánh xạ dựa trên cây
  • TreeMap sẽ tuân theo thứ tự tự nhiên của khóa
  • Chậm hơn HashMap và LinkedHashMap
  • Sử dụng TreeMap khi bạn cần duy trì thứ tự tự nhiên (mặc định)

Tất cả đều cung cấp một bản đồ khóa-> giá trị và cách lặp qua các khóa. Sự khác biệt quan trọng nhất giữa các lớp này là đảm bảo thời gian và thứ tự của các khóa.

1. HashMap cung cấp 0 (1) tra cứu và chèn. Tuy nhiên, nếu bạn lặp qua các phím, thứ tự của các phím về cơ bản là tùy ý. Nó được thực hiện bởi một loạt các danh sách liên kết.
2. TreeMap cung cấp tra cứu và chèn O (log N). Các khóa được sắp xếp, vì vậy nếu bạn cần lặp qua các phím theo thứ tự được sắp xếp, bạn có thể. Điều này có nghĩa là các khóa phải triển khai giao diện So sánh. Bản đồ được thực hiện bởi Cây Đỏ-Đen.
3. LinkedHashMap cung cấp 0 (1) tra cứu và chèn. Các phím được sắp xếp theo thứ tự chèn của chúng. Nó được thực hiện bởi các thùng liên kết đôi.

Hãy tưởng tượng bạn đã chuyển một TreeMap, HashMap và LinkedHashMap trống vào hàm sau:

void insertAndPrint(AbstractMap<Integer, String> map) {
  int[] array= {1, -1, 0};
  for (int x : array) {
    map.put(x, Integer.toString(x));
  }
  for (int k: map.keySet()) {
   System.out.print(k + ", ");
  }
}

Đầu ra cho mỗi sẽ trông giống như kết quả dưới đây.

Đối với HashMap, đầu ra là, trong các thử nghiệm của riêng tôi, {0, 1, -1}, nhưng nó có thể là bất kỳ thứ tự nào. Không có đảm bảo về việc đặt hàng.
Treemap, đầu ra là, {-1, 0, 1}
LinkedList, đầu ra là, {1, -1, 0}

Mặc dù có rất nhiều Câu trả lời xuất sắc ở đây, tôi muốn trình bày bảng của riêng tôi mô tả các Maptriển khai khác nhau được gói cùng với Java 11.

Chúng ta có thể thấy những khác biệt được liệt kê trên bảng đồ họa:

• HashMaplà mục đích Map chung thường được sử dụng khi bạn không có nhu cầu đặc biệt.
• LinkedHashMapmở rộng HashMap, thêm hành vi này: Duy trì một trật tự, thứ tự mà các mục nhập ban đầu được thêm vào . Việc thay đổi giá trị cho mục nhập khóa-giá trị không làm thay đổi vị trí của nó theo thứ tự.
• TreeMapquá duy trì một trật tự, nhưng sử dụng một trong hai (a) thứ tự tự nhiên , có nghĩa là giá trị của compareTophương thức trên các đối tượng chính được xác định trên Comparablegiao diện hoặc (b) gọi một Comparatortriển khai bạn cung cấp.
  • TreeMapthực hiện cả SortedMapgiao diện và giao diện của nó NavigableMap.
• NULL s: TreeMapkhông không cho phép một NULL như chìa khóa , trong khi HashMap& LinkedHashMaplàm.
  • Cả ba đều cho phép NULL làm giá trị.
• HashTablelà di sản , từ Java 1 . Được bổ sung bởi các ConcurrentHashMaplớp học. Trích dẫn Javadoc: ConcurrentHashMaptuân theo cùng đặc tả chức năng như Hashtablevà bao gồm các phiên bản của các phương thức tương ứng với từng phương thức Hashtable.

HashMap
có thể chứa một khóa null.

HashMap duy trì không có thứ tự.

Bản đồ cây

TreeMap không thể chứa bất kỳ khóa null nào.

TreeMap duy trì thứ tự tăng dần.

LinkedHashMap

LinkedHashMap có thể được sử dụng để duy trì thứ tự chèn, trên đó các khóa được chèn vào Map hoặc nó cũng có thể được sử dụng để duy trì thứ tự truy cập, trên đó các phím được truy cập.

Ví dụ ::

1) Bản đồ HashMap = HashMap mới ();

    map.put(null, "Kamran");
    map.put(2, "Ali");
    map.put(5, "From");
    map.put(4, "Dir");`enter code here`
    map.put(3, "Lower");
    for (Map.Entry m : map.entrySet()) {
        System.out.println(m.getKey() + "  " + m.getValue());
    } 

2) Bản đồ TreeMap = new TreeMap ();

    map.put(1, "Kamran");
    map.put(2, "Ali");
    map.put(5, "From");
    map.put(4, "Dir");
    map.put(3, "Lower");
    for (Map.Entry m : map.entrySet()) {
        System.out.println(m.getKey() + "  " + m.getValue());
    }

3) Bản đồ LinkedHashMap = new LinkedHashMap ();

    map.put(1, "Kamran");
    map.put(2, "Ali");
    map.put(5, "From");
    map.put(4, "Dir");
    map.put(3, "Lower");
    for (Map.Entry m : map.entrySet()) {
        System.out.println(m.getKey() + "  " + m.getValue());
    }

Điều quan trọng nhất trong cả ba là cách họ lưu thứ tự của các mục.

HashMap- Không lưu thứ tự của các mục. ví dụ.

public static void main(String[] args){
        HashMap<String,Integer> hashMap = new HashMap<>();
        hashMap.put("First",1);// First ---> 1 is put first in the map
        hashMap.put("Second",2);//Second ---> 2 is put second in the map
        hashMap.put("Third",3); // Third--->3 is put third in the map
        for(Map.Entry<String,Integer> entry : hashMap.entrySet())
        {
            System.out.println(entry.getKey()+"--->"+entry.getValue());
        }
    }

LinkedHashMap: Nó lưu thứ tự mà các mục đã được thực hiện. ví dụ:

public static void main(String[] args){
        LinkedHashMap<String,Integer> linkedHashMap = new LinkedHashMap<>();
        linkedHashMap.put("First",1);// First ---> 1 is put first in the map
        linkedHashMap.put("Second",2);//Second ---> 2 is put second in the map
        linkedHashMap.put("Third",3); // Third--->3 is put third in the map
        for(Map.Entry<String,Integer> entry : linkedHashMap.entrySet())
        {
            System.out.println(entry.getKey()+"--->"+entry.getValue());
        }
    }

TreeMap: Nó lưu các mục theo thứ tự tăng dần của các phím. ví dụ:

public static void main(String[] args) throws IOException {
        TreeMap<String,Integer> treeMap = new TreeMap<>();
        treeMap.put("A",1);// A---> 1 is put first in the map
        treeMap.put("C",2);//C---> 2 is put second in the map
        treeMap.put("B",3); //B--->3 is put third in the map
        for(Map.Entry<String,Integer> entry : treeMap.entrySet())
        {
            System.out.println(entry.getKey()+"--->"+entry.getValue());
        }
    }