แผนที่ส่วนต่อประสานใน Java

Java Map Interface คืออะไร

อินเทอร์เฟซ Java Map เป็นส่วนหนึ่งของเฟรมเวิร์ก Java Collection แต่ไม่ใช่ประเภทย่อยของอินเทอร์เฟซ Collection ดังนั้นมันจึงมีพฤติกรรมที่แตกต่างออกไปเมื่อเทียบกับ Lists หรือ Collection Objects อื่นๆ แต่ละองค์ประกอบของ Map<Key, Value> แสดงถึงคู่ของคีย์-ค่า ทั้งคีย์และค่าเป็นวัตถุบางอย่าง คีย์ทั้งหมดในแผนที่หนึ่งๆ นั้นไม่ซ้ำกัน ในขณะที่ค่าต่างๆ จะไม่ซ้ำกัน ดังนั้นจึงสามารถทำซ้ำได้ คุณอาจนึกถึง Map ใน Java เช่น พจนานุกรมประเภทหนึ่งหรือแคตตาล็อกร้านค้าออนไลน์ ซึ่งคุณสามารถค้นหารายการใดๆ โดยใช้ดัชนีเฉพาะของมัน คีย์คือตัวระบุเฉพาะของค่าในแผนที่ ตัวอย่างเช่น ใน Map<String, Item> String คือรหัสของบางรายการจากร้านค้าออนไลน์ ตามเอกสารประกอบแผนที่มีอินเทอร์เฟซย่อยถัดไป:

การผูก ;
• ConcurrentMap<K,V> ;
• ConcurrentNavigableMap<K,V> ;
• LogicalMessageContext ;
• บริบทข้อความ ;
• NavigableMap<K,V> ;
• SOAPMessageContext ;
• SortedMap<K,V> .

และใช้คลาส:

• แผนที่บทคัดย่อ
• คุณลักษณะ
• ผู้ให้สิทธิ์
• ConcurrentHashMap
• ConcurrentSkipListMap
• EnumMap
• แฮชแมป
• แฮชเทเบิล
• IdentityHashMap
• LinkedHashMap
• เครื่องพิมพ์สถานะเหตุผล
• คุณสมบัติ
• ผู้ให้บริการ
• คำแนะนำในการแสดงผล
• การผูกแบบง่าย
• รองรับข้อมูลแบบตาราง
• แผนที่ต้นไม้
• UIDefaults
• WeakHashMap

• Java AbstractMapเป็นคลาสนามธรรมที่ใช้อินเทอร์เฟซแผนที่ส่วนใหญ่
• Java HashMapเป็นโครงสร้างข้อมูลสำหรับจัดเก็บคู่คีย์-ค่าโดยใช้ตารางแฮช
• Java TreeMapเป็นโครงสร้างข้อมูลที่ใช้ต้นไม้ เช่น แสดงผลด้วยคีย์ที่เรียงลำดับ
• WeakHashMapเพื่อใช้ตารางแฮชที่มีคีย์อ่อนแอแสดงด้วยค่าที่ตัวรวบรวมขยะสามารถลบได้หากไม่ได้ใช้งานอีกต่อไป
• LinkedHashMapเป็นแผนที่ที่มีลำดับของการเพิ่มองค์ประกอบ อนุญาตให้มีการวนซ้ำในลำดับการแทรก
• EnumMapขยาย คลาส AbstractMapเพื่อใช้กับคีย์ enum
IdentityHashMapใช้การตรวจสอบความเท่าเทียมกันของการอ้างอิงเมื่อเปรียบเทียบเอกสาร การแมปกับคีย์ที่เปรียบเทียบโดยใช้ การดำเนินการ ==แทนวิธีการ เท่ากับ ()

ที่นี่เราสนใจในการใช้งาน Map Interface ที่เป็นที่นิยมมากที่สุด: HashMap, TreeMap และ LinkedHashMap อย่างไรก็ตาม ลำดับขององค์ประกอบแผนที่ขึ้นอยู่กับการใช้งานเฉพาะ สมมติว่า TreeMap และ LinkedHashMap มีลำดับองค์ประกอบที่สามารถคาดเดาได้ ในขณะที่ HashMap ไม่มี

วิธีการแผนที่

การทำงานหลักของแผนที่คือการแทรก ลบ และค้นหาองค์ประกอบต่างๆ

• วางวัตถุสาธารณะ (คีย์วัตถุ, ค่าวัตถุ)แทรกองค์ประกอบลงในแผนที่
• โมฆะสาธารณะ putAll (แผนที่แผนที่)แทรกแผนที่ที่ระบุภายในแผนที่
• public Object remove(Object key)ลบรายการตามคีย์ที่ระบุ
• สาธารณะ Object get(Object key)ส่งคืนค่าสำหรับคีย์ที่ระบุ
• บูลีนสาธารณะมีคีย์ (คีย์วัตถุ)ค้นหาคีย์ที่ระบุจากแผนที่นี้
• สาธารณะ Set keySet()ส่งคืนมุมมอง Set ที่มีคีย์ทั้งหมด
• สาธารณะ Set entrySet()ส่งคืนมุมมอง Set พร้อมคีย์และค่าทั้งหมด

HashMap คืออะไร

HashMap คืออะไร เป็นการใช้งานอินเทอร์เฟซ Map<Key,Value> ที่ได้รับความนิยมมากที่สุด โครงสร้างข้อมูลนี้ใช้หลักการแฮช

หลักการทำงานของ HashMap: การแฮช

เพื่อทำความเข้าใจว่าแฮชแมปคืออะไรและทำงานอย่างไร เรามาพูดถึงแฮชและฟังก์ชันแฮชกันก่อน ฟังก์ชันแฮชเป็นเพียงฟังก์ชันในความหมายทางคณิตศาสตร์ ดังนั้นจึงมีค่าอินพุต (วัตถุ ชิ้นส่วนของข้อมูล) และฟังก์ชันแปลงโดยใช้กฎที่เหมาะสมเป็นค่าเอาต์พุต - แฮช แฮชมักจะเป็นเลขฐานสิบหกของความยาวที่เหมาะสม กฎของกระบวนการแปลงอาจแตกต่างกัน แต่อยู่ภายใต้หลักการต่อไปนี้:

1. อินพุตเฉพาะ (วัตถุ) มีรหัสแฮชเฉพาะ
2. หากวัตถุสองชิ้นมีค่าเท่ากัน รหัสแฮชของวัตถุทั้งสองก็จะเท่ากันเช่นกัน สิ่งที่ตรงกันข้ามไม่เป็นความจริง
3. หากรหัสแฮชต่างกัน แสดงว่าวัตถุนั้นไม่เท่ากันอย่างแน่นอน
4. บางครั้งออบเจกต์ที่แตกต่างกันสามารถมีรหัสแฮชเดียวกันได้ เป็นเหตุการณ์ที่ไม่น่าเป็นไปได้มาก ตั้งชื่อว่า "การชนกัน" และฟังก์ชันแฮชที่มีคุณภาพดีควรลดความน่าจะเป็นของการชนกันให้น้อยที่สุด

ใน Java ทุกวัตถุมีรหัสแฮช คำนวณโดยเมธอด hashCode ของคลาส Object ซึ่งเป็นคลาสพาเรนต์ของ Java Objects ทั้งหมด โดยปกติแล้ว นักพัฒนาจะแทนที่เมธอดนี้สำหรับคลาสของตัวเอง เช่นเดียวกับเมธอด เท่ากับที่ เชื่อมโยงกับเมธอดนี้

HashMap: วิธีการทำงาน

ดังนั้น Class HashMap<K,V> เนื่องจากการใช้งานแผนที่ทุกครั้งประกอบด้วยคีย์และค่าต่างๆ มันเก็บคีย์โดยใช้หลักการแฮช ภายในคู่คีย์-ค่าของ HashMap จะถูกจัดเก็บไว้ใน "ที่เก็บข้อมูล" ที่เก็บข้อมูลเหล่านี้ร่วมกันสร้าง "ตาราง" ซึ่งเป็นอาร์เรย์ภายในของรายการที่เชื่อมโยงและขนาดเริ่มต้นคือ 16. HashMap ใน Java ใช้รหัสแฮชของคีย์เพื่อกำหนดบัคเก็ตที่คู่คีย์/ค่าควรแมป: คุณลักษณะที่ยุ่งยากของ HashMap คือแต่ละเซลล์ (บัคเก็ต) ของตาราง [] ไม่ได้เก็บเพียงคู่เดียว แต่มีหลายคู่ด้วย พวกมันไม่ได้ถูกจัดเก็บเป็นวัตถุที่ชัดเจน (เช่น LinkedList) แต่เป็นแบบลูกโซ่โดยนัย ห่วงโซ่ถูกสร้างขึ้นเนื่องจากแต่ละคู่เก็บลิงก์ไปยังคู่ถัดไป นั่นคือ คู่ HashMap ทั้งหมดกระจายอยู่ใน 16 สายโซ่ เมื่อคุณใส่คู่ใหม่ลงในตาราง ระบบจะพิจารณาแฮชของคีย์ แฮชนี้ไม่ใช่ฟังก์ชันแฮชโค้ดที่สร้างขึ้นในวัตถุคีย์ ถือว่าอยู่ในช่วง 0-15 ทั้งคู่จะถูกเพิ่มไปยังห่วงโซ่ของคู่ที่จัดเก็บไว้ในบัคเก็ตที่มีดัชนีแฮช วิธีการนี้ทำให้เราเร่งความเร็วการค้นหา ในขณะที่ค้นหาคู่ด้วยคีย์ ไม่จำเป็นต้องค้นหาทั้งตาราง มีการพิจารณาแฮชของคีย์และตรวจสอบเฉพาะเชนที่จัดเก็บไว้ในเซลล์ที่มีดัชนีแฮชเท่านั้น หากมีคู่มากเกินไปใน HashMap สายโซ่จะยาวเกินไป จากนั้นขนาดของอาร์เรย์จะเพิ่มขึ้น แฮชของออบเจกต์ที่เก็บไว้ทั้งหมดจะถูกคำนวณใหม่ และกระจายไปตามสายโซ่ใหม่

การประกาศ HashMap

หากคุณไปที่รหัสคลาส HashMap คุณจะพบการประกาศถัดไป:

public class HashMap extends AbstractMap implements Map, Cloneable, Serializable

โดยที่Kคือประเภทของคีย์ที่ดูแลโดยแผนที่นี้ และVคือประเภทของค่าที่แมป นี่คือตัวอย่างการประกาศ HashMap ด้วยคีย์จำนวนเต็มและค่าสตริงในโค้ดของคุณ:

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

วิธีการ HashMap

นี่คือรายการของเมธอด HashMap

• รับวัตถุ (คีย์วัตถุ)ส่งคืนค่าสำหรับคีย์ที่ระบุ
• วางวัตถุ (คีย์ k, ค่า v)แทรกการแมปค่าคีย์ลงในแผนที่
• ลบวัตถุ (คีย์วัตถุ)ลบการแมปสำหรับคีย์ที่ระบุออกจากแมปนี้หากมีอยู่
• void clear()ลบคู่คีย์-ค่าทั้งหมดออกจาก HashMap
• Object clone()ส่งคืนสำเนาตื้นของอินสแตนซ์ HashMap นี้โดยไม่ต้องทำการโคลนคีย์และค่า
• บูลีนมีคีย์ (คีย์วัตถุ)คืนค่าจริงหากพบคีย์ที่ระบุในแมป และเป็นเท็จหากไม่ใช่
• บูลีนประกอบด้วยค่า (ค่าวัตถุ)คืนค่าจริงหากพบคีย์ที่ระบุในแมป เท็จหากไม่ใช่
• บูลีน isEmpty()คืนค่าจริงหากแผนที่ว่างเปล่า คืนค่าเท็จหากไม่ใช่
• Set keySet()ส่งคืนชุดของคีย์ที่ดึงมาจากแผนที่
• int size()ส่งคืนปริมาณของการแมปคีย์-ค่า
• ค่าคอลเลกชัน ()ส่งคืนชุดค่าของแผนที่
• ลบวัตถุ(คีย์วัตถุ)ลบคู่ของคีย์-ค่าสำหรับคีย์ที่ระบุ
• void putAll(Map m)คัดลอกองค์ประกอบทั้งหมดของแผนที่ไปยังแผนที่อื่น

ตัวอย่าง Java HashMap

มาสร้างโปรแกรมด้วย Java HashMap Example เพื่อสาธิตวิธีการทำงาน:

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

ผลลัพธ์ของการเรียกใช้โปรแกรม:

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:
{}

แผนที่ต้นไม้

TreeMap ใน Java ยังใช้อินเทอร์เฟซ Map<Key,Value> แต่อิงตามโครงสร้างข้อมูล Red-Black tree ต้นไม้ประกอบด้วย "โหนด" และเส้นที่เชื่อมต่อโหนด - กิ่งก้าน "โหนด" รูทอยู่ที่ด้านบนสุดของต้นไม้ จากรากสามารถมีกิ่งและโหนดได้ เป็นโครงสร้างแบบลำดับชั้น คุณอาจนึกถึง โหนดเหล่านี้เป็น "ลูก" ของราก โหนดลูกสามารถมีโหนดลูกของตัวเองได้ - โหนดล่าง โหนดที่ไม่มีลูกเรียกว่า "end-nodes" หรือ "leave" ไบนารีทรีคือต้นไม้ซึ่งทุกโหนดมีศูนย์หนึ่ง หรือลูกสองคน ต้นไม้ค้นหาแบบทวิภาคเป็นโครงสร้างที่โหนดภายในทุกโหนดเก็บคีย์และบางครั้งก็เป็นค่าที่เกี่ยวข้อง ต้นไม้ค้นหาแบบไบนารีที่ปรับสมดุลในตัวเองคือต้นไม้ค้นหาแบบไบนารีแบบโหนดที่รักษาความสูง (จำนวนสูงสุดของระดับที่ต่ำกว่ารูท) โดยอัตโนมัติเมื่อเผชิญกับการแทรกและลบรายการโดยอำเภอใจ ต้นไม้สีแดงดำเป็นต้นไม้ไบนารีที่สมดุลซึ่งมีคุณสมบัติ:

• ทุกโหนดเป็นสีแดงหรือสีดำ
• รากเป็นสีดำเสมอ
• ทุกลีฟเป็นโหนด NIL (ชนิดของค่าว่าง, null) และเป็นสีดำ
• หากโหนดเป็นสีแดง ลูกของโหนดจะเป็นสีดำอย่างแน่นอน
• เส้นทางธรรมดาทุกเส้นทางจากโหนดไปยังโหนดย่อยมีจำนวนโหนดสีดำเท่ากัน

คุณสมบัติ TreeMap

TreeMap ใช้โครงสร้างข้อมูลแบบต้นไม้เพื่อจัดเก็บคีย์เป็นโหนดและจัดเรียงคีย์โดยใช้อัลกอริทึม Red-Black Tree ดังนั้น TreeMap จึงจัดเรียงรายการตามลำดับคีย์ตามธรรมชาติ สำหรับตัวเลขธรรมชาติคือลำดับจากน้อยไปหามาก สำหรับสตริง — ลำดับตัวอักษร คุณสามารถใช้ตัวเปรียบเทียบหากคุณต้องการเปลี่ยนตรรกะของการสั่งซื้อ การจัดเรียงวัตถุอย่างเป็นธรรมชาติเป็นข้อได้เปรียบที่สำคัญของ TreeMap เช่นเดียวกับการค้นหาวัตถุบางอย่างโดยใช้ตัวกรองและเงื่อนไขที่แตกต่างกัน

วิธีทรีแมป

• รับวัตถุ (คีย์วัตถุ)ส่งคืนค่าของคีย์ที่เกี่ยวข้อง
• วางวัตถุ (คีย์วัตถุ, ค่าวัตถุ)แทรกการแมปลงในแผนที่
• ลบวัตถุ (คีย์วัตถุ)ลบการแมปสำหรับคีย์นี้หาก TreeMap มีอยู่
• บูลีนมีคีย์ (คีย์วัตถุ)คืนค่าจริงหากแผนที่นี้มีการแมปสำหรับคีย์ที่ระบุ
• บูลีนประกอบด้วยค่า (ค่าวัตถุ)คืนค่าจริงหากทรีแมปจับคู่คีย์ตั้งแต่หนึ่งคีย์ขึ้นไปกับค่าที่ระบุ
• Object firstKey()ส่งคืนคีย์แรกที่อยู่ในแผนที่ที่เรียงลำดับ
• Object lastKey()ส่งคืนคีย์สุดท้ายที่อยู่ในแผนที่ที่เรียงลำดับ
• เป็นโมฆะ putAll (แผนที่แผนที่)คัดลอกการแมปทั้งหมดจากแผนที่ที่ระบุไปยังแผนที่
• ตั้งค่า entrySet()ส่งคืนมุมมองชุดของการแมป
• int size()ส่งคืนปริมาณของการแมปคีย์-ค่า
• ค่าคอลเลกชัน ()ส่งคืนมุมมองคอลเลกชันของค่า
• Object clone()ส่งคืนสำเนาแบบตื้นของ TreeMap
• void clear()ลบการแมปทั้งหมดออกจาก TreeMap
• SortedMap headMap(Object key_value)ส่งคืนมุมมองของส่วนของแผนที่น้อยกว่าพารามิเตอร์ key_value
• Set keySet()ส่งคืนมุมมอง Set ของคีย์ที่มีอยู่ในทรีแมป
• SortedMap แผนที่ย่อย (K fromKey, K toKey)ส่งคืนมุมมองของส่วนของแผนที่นี้ซึ่งมีคีย์ตั้งแต่ fromKey, รวม, toKey, พิเศษ
• Object firstKey()ส่งคืนคีย์แรกจาก 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);
   }
}

ผลลัพธ์ของการเรียกใช้โปรแกรม:

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 เป็นโครงสร้างข้อมูลที่รวมรายการเชื่อมโยงและแผนที่แฮช แท้จริงแล้ว LinkedHashMap ขยายคลาส HashMap และนำส่วนต่อประสานแผนที่ไปใช้ แต่มันเกี่ยวกับรายการที่เชื่อมโยงอย่างไร การประกาศของ LinkedHashMap:

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

LinkHashMap ใหม่นี้สืบทอดคุณสมบัติจาก HashMap (เช่น ตาราง, loadFactor, เกณฑ์, ขนาด, ชุดรายการ) ยังได้รับคุณสมบัติพิเศษสองอย่าง:

• ส่วนหัวคือส่วนหัวของรายการที่เชื่อมโยงแบบทวีคูณ ในระหว่างการเริ่มต้น มันบ่งชี้ตัวเอง
• accessOrder ระบุวิธีเข้าถึงองค์ประกอบโดยใช้ตัววนซ้ำ หากเป็นจริง ตามลำดับการเข้าถึงล่าสุด หากเป็นเท็จ การเข้าถึงจะเป็นไปตามลำดับที่องค์ประกอบถูกแทรก

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

วิธี LinkedHashMap

• Object get(Object key)ส่งคืนค่าที่มีการแมปคีย์ที่ระบุ หรือค่า null หากแมปนี้ไม่มีการแมปสำหรับคีย์
• void clear()ลบการแมปทั้งหมดออกจากแผนที่
• บูลีนมีคีย์ (คีย์วัตถุ)คืนค่าจริงหากองค์ประกอบที่ระบุถูกแมปโดยคีย์ตั้งแต่หนึ่งคีย์ขึ้นไป
• บูลีน removeEldestEntry(Map.Entry eldest)ส่งคืนค่าจริงหากแผนที่ลบรายการที่เก่าที่สุดออกจากแผนที่
• Set<Map.Entry<K,V>> entrySet()ส่งคืนมุมมอง Set ของการแมปที่มีอยู่ในแผนที่นี้
• void forEach(BiConsumer<? super K,? super V> action)ดำเนินการตามที่กำหนดสำหรับแต่ละรายการในแผนที่นี้จนกว่ารายการทั้งหมดจะได้รับการประมวลผลหรือการดำเนินการแสดงข้อยกเว้น
• วัตถุ getOrDefault (คีย์วัตถุ, V defaultValue)ส่งคืนค่าที่แมปคีย์ที่ระบุ หากแผนที่ไม่มีการแมปสำหรับคีย์จะส่งกลับค่า defaultValue
• Set<K> keySet()ส่งคืนมุมมอง Set ของคีย์ที่มีอยู่ในแผนที่
• บูลีน removeEldestEntry(Map.Entry<K,V> eldest)คืนค่าจริงหากแผนที่นี้ควรลบรายการที่เก่าที่สุดออก
• โมฆะแทนที่ทั้งหมด (BiFunction<? super K,? super V,? ขยาย V> ฟังก์ชัน)แทนที่แต่ละค่ารายการด้วยผลลัพธ์ของการเรียกใช้ฟังก์ชันที่กำหนดในรายการนั้นจนกว่ารายการทั้งหมดจะได้รับการประมวลผลหรือฟังก์ชันโยนข้อยกเว้น
• Collection<v>values()ส่งคืนมุมมอง Collection ของค่าที่มีอยู่ในแผนที่

ตัวอย่าง LinkedHashMap

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

ที่นี่ เราสร้าง LinkedHashMap ใหม่ โดยเพิ่มองค์ประกอบห้ารายการ จากนั้นพิมพ์ออกมาโดยใช้ตัววนซ้ำด้วยวิธีดั้งเดิม อย่างที่คุณเห็น LinkedHashMap จะรักษาลำดับการแทรก หลังจากที่เราลบองค์ประกอบออกจากแผนที่ของเราแล้ว เพิ่มองค์ประกอบใหม่และหลังจากนั้น - อีกหนึ่งองค์ประกอบที่มีคีย์ซึ่งอยู่บนแผนที่แล้ว โดยจะแทนที่ค่าเก่าที่แมปกับคีย์นี้ ผลลัพธ์ของการรันโปรแกรม:

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}

HashMap, TreeMap, การเปรียบเทียบ LinkedHashMap

HashMap, TreeMap และ LinkedHashMap เป็นการนำส่วนต่อประสานแผนที่ไปใช้ HashMap และ LinkedHashMap เป็นโครงสร้างข้อมูลที่แฮชคีย์ TreeMap ใช้ลำดับตามธรรมชาติของคีย์เพื่อจัดระเบียบแผนผังการค้นหา คำสั่ง:

• HashMap ไม่รักษาลำดับใดๆ
• TreeMap จัดเรียงรายการตามลำดับคีย์จากน้อยไปมาก
• LinkedHashMap รักษาลำดับการแทรก

ปุ่ม Null:

• HashMap และ LinkedHashMap อนุญาตให้มีคีย์ว่างหนึ่งคีย์
• LinkedHashMap ไม่อนุญาตคีย์ null ในกรณีที่คีย์ใช้การเรียงลำดับตามธรรมชาติหรือ Comparator ไม่รองรับการเปรียบเทียบบน null leys

มาดูตัวอย่างแผนที่ Java ที่รวมการนำไปใช้งานทั้งสามแบบที่ได้รับการตรวจสอบในบทความนี้:

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

นี่คือผลลัพธ์ของการเรียกใช้โปรแกรมนี้:

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}

อย่างที่เราเห็น ลำดับขององค์ประกอบใน HashMap ไม่ชัดเจน ใน treeMap จะขึ้นอยู่กับคีย์ ใน LinkedHashMap จะเกี่ยวกับลำดับการแทรก หากเราพยายามใส่ null key ลงใน LinkedInHashMap เราจะได้รับ NullPointerException แต่ใน LinkedInHashMap1 โดยที่คีย์เป็น String เราสามารถทำได้ แผนที่แฮชเป็นการนำแผนที่ไปใช้งานทั่วไปที่ดีที่สุด ให้ความเร็วในการค้นหาสูงสุด พื้นที่จัดเก็บที่รวดเร็ว และการดำเนินการเรียกค้นข้อมูล แต่คุณควรจำเกี่ยวกับลำดับที่ยุ่งเหยิงของมัน แผนที่แฮชที่เชื่อมโยงสืบทอดข้อดีของ HashMap และได้รับคำสั่งสำหรับคีย์ อย่างไรก็ตาม มันมีลิงค์ลิสต์ซึ่งค่อนข้างแพงในแง่ของหน่วยความจำ มันช้ากว่า HashMap ในการค้นหาและช้ากว่าเล็กน้อยสำหรับการเพิ่ม / ลบเนื่องจากการรักษารายการที่เชื่อมโยง แผนผังต้นไม้จัดเก็บคีย์ที่เรียงลำดับจากน้อยไปหามาก อย่างไรก็ตาม, เพื่อเสริมสิ่งที่คุณได้เรียนรู้ เราขอแนะนำให้คุณดูบทเรียนวิดีโอจากหลักสูตร Java ของเรา