ความแตกต่างระหว่าง HashMap, LinkedHashMap และ TreeMap

ความแตกต่างระหว่างคืออะไรHashMap, LinkedHashMapและTreeMapใน Java? ผมไม่เห็นความแตกต่างในการส่งออกใด ๆ ที่เป็นทั้งสามมีและkeySet valuesอะไรคือHashtableS?

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());

ทั้งสามคลาสใช้Mapอินเตอร์เฟสและให้การทำงานเหมือนกัน ความแตกต่างที่สำคัญที่สุดคือลำดับของการวนซ้ำผ่านรายการที่จะเกิดขึ้น:

• HashMapไม่รับประกันอย่างแน่นอนเกี่ยวกับคำสั่งการวนซ้ำ มันสามารถ (และจะ) เปลี่ยนแปลงได้อย่างสมบูรณ์แม้เมื่อมีการเพิ่มองค์ประกอบใหม่
• TreeMapจะทำซ้ำตาม "ลำดับธรรมชาติ" ของปุ่มตามcompareTo()วิธีการของพวกเขา(หรือจัดหาจากภายนอกComparator) นอกจากนี้ยังใช้SortedMapอินเทอร์เฟซซึ่งประกอบด้วยวิธีการที่ขึ้นอยู่กับลำดับการจัดเรียงนี้
• LinkedHashMap จะวนซ้ำในลำดับที่รายการถูกใส่ลงในแผนที่

"Hashtable"เป็นชื่อสามัญสำหรับแผนที่ที่ใช้แฮช ในบริบทของ Java API Hashtableเป็นคลาสที่ล้าสมัยจากวันของ Java 1.1 ก่อนที่เฟรมเวิร์กการรวบรวมจะมีอยู่ ไม่ควรใช้อีกต่อไปเพราะ API ของมันเต็มไปด้วยวิธีการล้าสมัยที่ทำซ้ำการทำงานและวิธีการของมันจะถูกซิงโครไนซ์ (ซึ่งสามารถลดประสิทธิภาพและไม่ได้ผลโดยทั่วไป) ใช้ConcurrentHashMapแทน Hashtable

ฉันชอบการนำเสนอด้วยภาพ:

╔══════════════╦═════════════════════╦═══════════════════╦═════════════════════╗
║   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               ║
╚══════════════╩═══════════════════════════════════════════════════════════════╝

ทั้งสามแสดงถึงการแมปจากคีย์ที่ไม่ซ้ำกันกับค่าและใช้แผนที่อินเทอร์เฟซ

1. HashMap คือแผนที่ซึ่งเป็นไปตามคร่ำเครียดของคีย์ รองรับ O / 1 การดำเนินงานรับ / วาง คีย์ต้องมีการใช้งานที่สอดคล้องกันhashCode()และequals()เพื่อให้สามารถใช้งานได้

2. LinkedHashMap นั้นคล้ายกับ HashMap มาก แต่จะเพิ่มการรับรู้ในลำดับที่ไอเท็มถูกเพิ่ม (หรือเข้าถึง) ดังนั้นคำสั่งวนซ้ำจะเหมือนกับคำสั่งแทรก (หรือคำสั่งการเข้าถึงขึ้นอยู่กับพารามิเตอร์การก่อสร้าง)

3. TreeMap คือการแม็ปตามต้นไม้ การดำเนินการย้าย / รับมันใช้เวลา O (log n) มันต้องการรายการที่จะมีกลไกการเปรียบเทียบทั้งที่มี Comparable หรือ Comparator คำสั่งวนซ้ำถูกกำหนดโดยกลไกนี้

ดูว่าแต่ละคลาสอยู่ในลำดับชั้นของชั้นเรียนในแผนภาพต่อไปนี้ ( ใหญ่กว่า ) TreeMap ดำเนินการSortedMapและNavigableMapในขณะที่HashMapไม่

HashTableล้าสมัยและConcurrentHashMapควรใช้คลาสที่ สอดคล้องกัน

HashMap

• มันมีค่าคู่ (กุญแจค่า)
• ไม่มีค่าคีย์ซ้ำซ้อน
• ไม่ได้เรียงลำดับ
• มันอนุญาตหนึ่งคีย์ว่างและมากกว่าหนึ่งค่า null

HashTable

• เช่นเดียวกับแผนที่แฮช
• ไม่อนุญาตให้ใช้คีย์ null และค่าว่าง

LinkedHashMap

• เป็นรุ่นที่สั่งให้มีการนำแผนที่ไปใช้
• ขึ้นอยู่กับรายการที่เชื่อมโยงและโครงสร้างข้อมูลที่คร่ำครวญ

TreeMap

• รุ่นที่สั่งซื้อและเรียงลำดับ
• ขึ้นอยู่กับโครงสร้างข้อมูล hashing

ข้อมูลเพิ่มเติมจากประสบการณ์ของฉันเองในแผนที่เมื่อฉันจะใช้แต่ละคน:

• HashMap - มีประโยชน์มากที่สุดเมื่อค้นหาการใช้งานที่มีประสิทธิภาพสูงสุด (เร็ว)
• TreeMap (อินเทอร์เฟซ SortedMap) - มีประโยชน์มากที่สุดเมื่อฉันกังวลเกี่ยวกับความสามารถในการเรียงลำดับหรือทำซ้ำผ่านปุ่มตามลำดับที่ฉันกำหนด
• LinkedHashMap - รวมข้อดีของการรับประกันการสั่งซื้อจาก TreeMap โดยไม่มีค่าใช้จ่ายเพิ่มขึ้นในการดูแล TreeMap (มันเกือบจะเร็วเท่ากับ HashMap) โดยเฉพาะอย่างยิ่ง LinkedHashMap ยังเป็นจุดเริ่มต้นที่ดีสำหรับการสร้างวัตถุแคชโดยการแทนที่removeEldestEntry()เมธอด สิ่งนี้ช่วยให้คุณสร้างวัตถุแคชที่สามารถหมดอายุข้อมูลโดยใช้เกณฑ์บางอย่างที่คุณกำหนด

ทั้งหมดสามชั้นHashMap, TreeMapและLinkedHashMapดำเนินการjava.util.Mapติดต่อและแสดงให้เห็นถึงการทำแผนที่จากคีย์ที่ไม่ซ้ำกับค่า

HashMap

1. A HashMapมีค่าตามคีย์

2. มันมีองค์ประกอบที่ไม่ซ้ำกันเท่านั้น

3. มันอาจจะมีหนึ่งคีย์ที่สำคัญและหลายค่าเป็นโมฆะ

4. มันจะเก็บไม่มีการสั่งซื้อ

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

LinkedHashMap

1. A LinkedHashMapมีค่าตามคีย์
2. มันมีองค์ประกอบที่ไม่ซ้ำกันเท่านั้น
3. มันอาจจะมีหนึ่งคีย์ที่สำคัญและหลายค่าเป็นโมฆะ

4. มันเป็นเช่นเดียวกับ HashMap แทนที่จะรักษาเพื่อแทรก // ดูการลดคลาสลงด้านล่าง

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

TreeMap

1. A TreeMapมีค่าตามคีย์ ใช้ส่วนต่อประสาน NavigableMap และขยายคลาส AbstractMap
2. มันมีองค์ประกอบที่ไม่ซ้ำกันเท่านั้น
3. มันไม่สามารถมีคีย์ null แต่สามารถมีได้หลายค่า

4. มันเหมือนกับการHashMapรักษาลำดับจากน้อยไปหามาก (เรียงลำดับโดยใช้ลำดับธรรมชาติของคีย์)

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

Hashtable

1. Hashtable เป็นอาร์เรย์ของรายการ แต่ละรายการเรียกว่าที่ฝากข้อมูล ตำแหน่งของที่ฝากข้อมูลจะถูกระบุด้วยการเรียกเมธอด hashcode () Hashtable มีค่าตามคีย์
2. มันมีองค์ประกอบที่ไม่ซ้ำกันเท่านั้น
3. อาจไม่มีคีย์หรือค่า Null ใด ๆ
4. มันเป็นข้อมูลให้ตรงกัน

5. มันเป็นคลาสดั้งเดิม

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

Ref: http://javarevisited.blogspot.in/2015/08/difference-between-HashMap-vs-TreeMap-vs-LinkedHashMap-Java.html

HashMap ไม่รับประกันอย่างแน่นอนเกี่ยวกับคำสั่งซ้ำ มันสามารถ (และจะ) เปลี่ยนแปลงได้อย่างสมบูรณ์แม้เมื่อมีการเพิ่มองค์ประกอบใหม่ TreeMap จะทำซ้ำตาม "ลำดับตามธรรมชาติ" ของปุ่มตามวิธี comparTo () ของพวกเขา (หรือ Comparator ที่จัดหาจากภายนอก) นอกจากนี้ยังใช้อินเตอร์เฟส SortedMap ซึ่งมีเมธอดที่ขึ้นอยู่กับลำดับการเรียงนี้ LinkedHashMap จะทำซ้ำตามลำดับที่มีการใส่ข้อมูลลงในแผนที่

ดูว่าประสิทธิภาพแตกต่างกันอย่างไร ..

แผนผังต้นไม้ซึ่งเป็นการนำแผนที่เรียงลำดับมาใช้ ความซับซ้อนของการดำเนินการ put, get และ containKey คือ O (log n) เนื่องจากการเรียงลำดับแบบธรรมชาติ

@Amit: SortedMapเป็นอินเตอร์เฟสในขณะที่TreeMapเป็นคลาสที่ใช้SortedMapอินเทอร์เฟซ ซึ่งหมายความว่าหากทำตามโพรโทคอลซึ่งSortedMapขอให้ผู้ดำเนินการทำ ต้นไม้ยกเว้นว่ามีการนำไปใช้เป็นแผนผังการค้นหาไม่สามารถให้ข้อมูลที่คุณสั่งซื้อได้เนื่องจากต้นไม้สามารถเป็นต้นไม้ชนิดใดก็ได้ ดังนั้นเพื่อให้ TreeMap ทำงานเหมือนการเรียงลำดับจึงใช้ SortedMap (เช่น Binary Search Tree - BST, BST ที่สมดุลเช่น AVL และ RB Tree, แม้แต่ Ternary Search Tree - ส่วนใหญ่ใช้สำหรับการค้นหาซ้ำในทางที่สั่ง)

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

ใน NUT-SHELL HashMap: ให้ข้อมูลใน O (1) ไม่มีการสั่งซื้อ

TreeMap : ให้ข้อมูลใน O (บันทึก N), ฐาน 2 พร้อมคีย์ที่สั่ง

LinkedHashMap: เป็นตารางแฮชที่มีรายการที่เชื่อมโยง (คิดว่าเป็นดัชนี - SkipList) เพื่อเก็บข้อมูลในแบบที่มันถูกแทรกในทรี เหมาะสมที่สุดที่จะใช้ LRU (ใช้น้อยที่สุดเมื่อเร็ว ๆ นี้)

ต่อไปนี้เป็นข้อแตกต่างที่สำคัญระหว่าง HashMap และ TreeMap

1. HashMap ไม่รักษาคำสั่งใด ๆ กล่าวอีกนัยหนึ่ง HashMap ไม่ได้รับประกันใด ๆ ว่าองค์ประกอบที่แทรกไว้ก่อนจะถูกพิมพ์ออกมาก่อนเช่นเดียวกับ TreeSet องค์ประกอบ TreeMap จะเรียงลำดับตามลำดับธรรมชาติขององค์ประกอบ

2. การใช้งาน HashMap ภายในใช้ Hashing และ TreeMap ภายในใช้การปรับใช้ต้นไม้ Red-Black

3. HashMap สามารถเก็บคีย์หนึ่งค่าได้และค่า Null หลายค่า TREEMap ไม่สามารถมีคีย์ Null แต่อาจมีค่า Null หลายค่า

4. HashMap ใช้เวลาอย่างต่อเนื่องสำหรับการดำเนินงานพื้นฐานเช่นการรับและวางเช่น O (1). ตามเอกสาร Oracle, TreeMap มีการรับประกันบันทึกเวลา (n) ค่าใช้จ่ายเวลาสำหรับวิธีการรับและใส่

5. HashMap เร็วกว่า TreeMap มากเนื่องจากประสิทธิภาพของ HashMap นั้นมีค่าคงที่เมื่อเทียบกับเวลาในการบันทึก TreeMap สำหรับการทำงานส่วนใหญ่

6. HashMap ใช้วิธีเท่ากับ () ในการเปรียบเทียบในขณะที่ TreeMap ใช้วิธี comparTo () สำหรับการรักษาการสั่งซื้อ

7. HashMap ใช้แผนที่อินเตอร์เฟสในขณะที่ TreeMap ใช้อินเตอร์เฟส NavigableMap

เหล่านี้คือการใช้งานที่แตกต่างกันของอินเทอร์เฟซเดียวกัน การใช้งานแต่ละอย่างมีข้อดีและข้อเสียบางประการ (การแทรกอย่างรวดเร็วการค้นหาช้า) หรือในทางกลับกัน

สำหรับรายละเอียดดูที่ Javadoc ของTreeMap , HashMap , LinkedHashMap

แผนที่แฮไม่ได้รักษาคำสั่งแทรก
ตัวอย่าง. Hashmap หากคุณใส่กุญแจเป็น

1  3
5  9
4   6
7   15
3   10

มันสามารถเก็บไว้เป็น

4  6
5  9
3  10
1  3
7  15

Hashmap ที่เชื่อมโยงจะคงไว้ซึ่งลำดับการแทรก

ตัวอย่าง.
หากคุณใส่กุญแจ

1  3
5  9
4   6
7   15
3   10

มันจะเก็บมันไว้เป็น

1  3
5  9
4   6
7   15
3   10

เช่นเดียวกับที่เราใส่

แผนผังต้นไม้จัดเก็บ vales ในลำดับที่เพิ่มขึ้นของคีย์ ตัวอย่าง.
หากคุณใส่กุญแจ

1  3
5  9
4   6
7   15
3   10

มันจะเก็บมันไว้เป็น

1  3
3  10
4   6
5   9
7   15

• HashMap:

  • คำสั่งซื้อไม่รักษา
  • เร็วกว่า LinkedHashMap
  • ใช้สำหรับเก็บกองวัตถุ

• LinkedHashMap:

  • คำสั่งแทรก LinkedHashMap จะได้รับการดูแล
  • ช้ากว่า HashMap และเร็วกว่า TreeMap
  • หากคุณต้องการรักษาลำดับการแทรกให้ใช้สิ่งนี้

• TreeMap:

  • TreeMap เป็นการทำแผนที่แบบใช้ต้นไม้
  • TreeMap จะทำตามคำสั่งที่เป็นธรรมชาติของคีย์
  • ช้ากว่า HashMap และ LinkedHashMap
  • ใช้ TreeMap เมื่อคุณต้องการรักษาการสั่งซื้อตามธรรมชาติ (ค่าเริ่มต้น)

ทั้งหมดเสนอแผนที่คีย์ -> ค่าและวิธีการวนซ้ำผ่านคีย์ ความแตกต่างที่สำคัญที่สุดระหว่างคลาสเหล่านี้คือการรับประกันเวลาและการเรียงลำดับของคีย์

1. HashMap เสนอการค้นหาและการแทรก 0 (1) หากคุณวนซ้ำผ่านคีย์การเรียงลำดับของคีย์นั้นเป็นสิ่งที่ไม่มีข้อ จำกัด มันจะดำเนินการโดยอาร์เรย์ของรายการที่เชื่อมโยง
2. TreeMap เสนอการค้นหาและแทรก O (บันทึก N) มีการสั่งซื้อคีย์ดังนั้นหากคุณจำเป็นต้องทำซ้ำผ่านคีย์ตามลำดับที่เรียงคุณสามารถ ซึ่งหมายความว่าคีย์จะต้องนำไปใช้กับส่วนต่อประสานที่เปรียบเทียบได้ TreeMap ถูกใช้งานโดยทรีสีแดง - ดำ
3. LinkedHashMap เสนอการค้นหาและการแทรก 0 (1) คีย์จะเรียงลำดับตามลำดับการแทรก มันดำเนินการโดยถังที่เชื่อมโยงเป็นสองเท่า

ลองจินตนาการว่าคุณผ่าน TreeMap, HashMap และ LinkedHashMap ที่ว่างเปล่าไปยังฟังก์ชันต่อไปนี้:

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 + ", ");
  }
}

ผลลัพธ์สำหรับแต่ละรายการจะมีลักษณะผลลัพธ์ด้านล่าง

สำหรับ HashMap ผลลัพธ์คือในการทดสอบของฉันเอง {0, 1, -1} แต่มันอาจเป็นการเรียงลำดับใด ๆ ไม่มีการรับประกันในการสั่งซื้อ
Treemap, เอาต์พุตคือ {-1, 0, 1}
LinkedList, เอาต์พุตคือ {1, -1, 0}

ในขณะที่มีคำตอบที่ยอดเยี่ยมมากมายที่นี่ฉันต้องการนำเสนอตารางของฉันเองที่อธิบายถึงการMapใช้งานที่หลากหลายที่มาพร้อมกับ Java 11

เราสามารถเห็นความแตกต่างเหล่านี้แสดงไว้ในกราฟิกตาราง:

• HashMapเป็นวัตถุประสงค์ Mapทั่วไปที่ใช้กันทั่วไปเมื่อคุณไม่มีความต้องการพิเศษ
• LinkedHashMapขยายHashMapเพิ่มพฤติกรรมนี้: รักษาคำสั่งที่สั่งซื้อซึ่งรายการที่ถูกเพิ่มเข้ามา แต่เดิม การเปลี่ยนแปลงค่าสำหรับรายการคีย์ - ค่าจะไม่เปลี่ยนตำแหน่งในลำดับ
• TreeMapเกินไปรักษาคำสั่งซื้อ แต่ใช้อย่างใดอย่างหนึ่ง (ก) เพื่อ“ธรรมชาติ”หมายถึงค่าของcompareToวิธีการที่สำคัญในวัตถุที่กำหนดไว้ในComparableอินเตอร์เฟซหรือ (ข) เรียกการดำเนินการที่คุณให้ Comparator
  • TreeMapใช้ทั้งSortedMapอินเตอร์เฟสและตัวต่อของNavigableMapอินเตอร์เฟส
• โมฆะ s: TreeMapไม่ได้ช่วยให้เป็นโมฆะเป็นกุญแจสำคัญที่ในขณะที่HashMapและLinkedHashMapทำ
  • ทั้งสามอนุญาตให้ NULL เป็นค่า
• HashTableเป็นมรดกจาก Java 1 Supplanted โดยConcurrentHashMapชั้นเรียน อ้าง Javadoc: ConcurrentHashMapเชื่อฟังคุณสมบัติการทำงานเช่นเดียวกับและรวมถึงรุ่นของวิธีการที่สอดคล้องกับแต่ละวิธีการHashtableHashtable

HashMap
สามารถมีหนึ่งคีย์ว่าง

HashMap ไม่มีคำสั่ง

TreeMap

TreeMap ไม่สามารถมีคีย์ว่างใด ๆ

TreeMap ดูแลรักษาลำดับ

LinkedHashMap

LinkedHashMap สามารถใช้เพื่อรักษาลำดับการแทรกซึ่งคีย์ถูกแทรกลงในแผนที่หรือสามารถใช้เพื่อรักษาลำดับการเข้าถึงซึ่งการเข้าถึงคีย์

ตัวอย่าง ::

1) แผนที่ HashMap = HashMap ใหม่ ();

    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) TreeMap map = 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) LinkedHashMap map = 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());
    }

สิ่งสำคัญที่สุดในบรรดาทั้งสามคือวิธีที่พวกเขาบันทึกลำดับของรายการ

HashMap- ไม่บันทึกลำดับของรายการ เช่น.

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: มันบันทึกลำดับที่มีการทำรายการ เช่น:

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: มันบันทึกรายการตามลำดับของคีย์ เช่น:

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());
        }
    }