เอCollection- บางครั้งเรียกว่าภาชนะบรรจุ - เป็นเพียงวัตถุที่จัดกลุ่มหลายองค์ประกอบเป็นหน่วยเดียว Collections ใช้เพื่อจัดเก็บเรียกใช้จัดการและสื่อสารข้อมูลรวม เฟรมเวิร์กคอลเล็กชันWเป็นสถาปัตยกรรมแบบครบวงจรสำหรับการแสดงและจัดการคอลเลกชัน
กระบวนการHashMap JDK1.2และ Hashtable JDK1.0ทั้งสองถูกใช้เพื่อแสดงกลุ่มของวัตถุที่แสดงเป็น<Key, Value>คู่ แต่ละ<Key, Value>คู่เรียกว่าEntryวัตถุ คอลเลกชันของรายการจะเรียกวัตถุของและHashMap Hashtableกุญแจในคอลเลกชันจะต้องไม่ซ้ำกันหรือโดดเด่น [เนื่องจากใช้เพื่อดึงค่าที่แม็พคีย์เฉพาะ ค่าในคอลเลกชันสามารถทำซ้ำ]
«สมาชิก Superclass, Legacy และ Collection Framework
Hashtable เป็นคลาสดั้งเดิมที่นำมาใช้JDK1.0ซึ่งเป็นคลาสย่อยของคลาส Dictionary จากJDK1.2Hashtable ได้รับการออกแบบใหม่เพื่อใช้งานอินเทอร์เฟซแผนที่เพื่อทำให้สมาชิกของกรอบงานการรวบรวม HashMap เป็นสมาชิกของ Java JDK1.2เก็บกรอบทางด้านขวาจากจุดเริ่มต้นของการเปิดตัวใน HashMap เป็นคลาสย่อยของคลาส AbstractMap
public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, Serializable { ... }
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable { ... }
« กำลังการผลิตเริ่มต้นและตัวประกอบภาระ
ความจุคือจำนวนที่เก็บข้อมูลในตารางแฮชและความจุเริ่มต้นเป็นเพียงความจุ ณ เวลาที่สร้างตารางแฮช โปรดทราบว่าตารางแฮชเปิดอยู่: ในกรณีของ " hashcollision" ถังเก็บข้อมูลเดียวจะเก็บหลายรายการซึ่งจะต้องค้นหาตามลำดับ ตัวประกอบภาระคือการวัดความเต็มของตารางแฮชที่ได้รับก่อนที่ความจุจะเพิ่มขึ้นโดยอัตโนมัติ
HashMap สร้างตารางแฮชว่างเปล่าที่มีความจุเริ่มต้นเริ่มต้น(16)และปัจจัยการโหลดเริ่มต้น (0.75) โดยที่ Hashtable สร้าง hashtable ว่างเปล่าด้วยความจุเริ่มต้นเริ่มต้น(11)และอัตราส่วนตัวคูณ / อัตราส่วนการเติม (0.75)
« การดัดแปลงโครงสร้างในกรณีที่มีการชนกันของแฮช
HashMap, Hashtableในกรณีของการชนกันของกัญชาที่พวกเขาเก็บรายการแผนที่ในรายการเชื่อมโยง จาก Java8 สำหรับHashMaplinked list of entries to a balanced treeถ้าถังกัญชาเติบโตเกินกว่าเกณฑ์ที่กำหนดถังที่จะเปลี่ยนจาก ซึ่งปรับปรุงประสิทธิภาพกรณีที่เลวร้ายที่สุดจาก O (n) ถึง O (log n) ในขณะที่แปลงรายการเป็นต้นไม้ไบนารี hashcode จะใช้เป็นตัวแปรการแยกสาขา หากมีแฮชโค้ดที่แตกต่างกันสองอันในที่เก็บข้อมูลเดียวกันอันที่หนึ่งจะถือว่าใหญ่กว่าและไปทางขวาของต้นไม้และอีกอันหนึ่งอยู่ทางซ้าย แต่เมื่อแฮชโค้ดทั้งสองมีค่าเท่ากันHashMapสมมติว่าคีย์นั้นเปรียบได้และเปรียบเทียบคีย์เพื่อกำหนดทิศทางเพื่อให้สามารถรักษาลำดับไว้ได้ มันเป็นวิธีที่ดีที่จะทำให้คีย์ของเทียบเคียงHashMap ในการเพิ่มรายการหากขนาดถังถึงTREEIFY_THRESHOLD = 8แปลงรายการที่เชื่อมโยงของรายการไปยังทรีแบบสมดุลในการลบรายการที่น้อยกว่าTREEIFY_THRESHOLD และมากที่สุดUNTREEIFY_THRESHOLD = 6จะแปลงทรีแบบสมดุลให้กลับเป็นรายการที่ลิงก์ Java 8 SRC , stackpost
«การ รวบรวมซ้ำเพื่อรับชมล้มเหลวเร็วและไม่ปลอดภัย
+--------------------+-----------+-------------+
| | Iterator | Enumeration |
+--------------------+-----------+-------------+
| Hashtable | fail-fast | safe |
+--------------------+-----------+-------------+
| HashMap | fail-fast | fail-fast |
+--------------------+-----------+-------------+
| ConcurrentHashMap | safe | safe |
+--------------------+-----------+-------------+
Iteratorเป็นธรรมชาติที่ล้มเหลวอย่างรวดเร็ว นั่นคือมันจะโยน ConcurrentModificationException ถ้าคอลเลกชันมีการแก้ไขในขณะที่ทำซ้ำอื่น ๆ กว่ามันเป็นวิธีการลบ () ของตัวเอง ในกรณีที่Enumerationไม่ปลอดภัยในธรรมชาติ มันจะไม่ส่งข้อยกเว้นใด ๆ หากมีการแก้ไขคอลเล็กชันในขณะที่วนซ้ำ
ตามเอกสาร API ของ Java, Iterator เป็นที่ต้องการมากกว่าการแจงนับ
หมายเหตุ:ฟังก์ชันการทำงานของอินเทอร์เฟซการแจงนับซ้ำโดยอินเทอร์เฟซ Iterator นอกจากนี้ Iterator เพิ่มการดำเนินการลบทางเลือกและมีชื่อวิธีการที่สั้นกว่า การนำไปใช้ใหม่ควรพิจารณาใช้ Iterator ในการตั้งค่าการแจงนับ
ในJava 5 ได้แนะนำ ConcurrentMap Interface : ConcurrentHashMap- การใช้งานที่มีประสิทธิภาพสูงพร้อมกันซึ่งConcurrentMapได้รับการสนับสนุนโดยตารางแฮช การนำไปใช้งานนี้จะไม่บล็อกเมื่อทำการค้นคืนและอนุญาตให้ไคลเอ็นต์เลือกระดับการทำงานพร้อมกันสำหรับการอัพเดต มันมีวัตถุประสงค์เพื่อเป็นดรอปแทนสำหรับHashtable: นอกเหนือจากการดำเนินการConcurrentMapจะสนับสนุนทุกวิธีการ "ดั้งเดิม" Hashtableเฉพาะ
HashMapEntryค่า s แต่ละค่ามีความผันผวนดังนั้นจึงมั่นใจได้ว่ามีความสอดคล้องของเม็ดละเอียดสำหรับการดัดแปลงแก้ไขและการอ่านตามมา การอ่านแต่ละครั้งสะท้อนถึงการอัปเดตที่เสร็จสมบูรณ์ล่าสุด
Iterator และ Enumerations นั้นไม่ปลอดภัย - สะท้อนสถานะในบางจุดตั้งแต่การสร้างตัววนซ้ำ / การแจงนับ สิ่งนี้ช่วยให้สามารถอ่านและแก้ไขพร้อมกันได้ในราคาที่ลดลงอย่างสม่ำเสมอ พวกเขาจะไม่โยน ConcurrentModificationException อย่างไรก็ตามตัววนซ้ำได้รับการออกแบบให้ใช้งานได้ครั้งละหนึ่งเธรดเท่านั้น
เหมือนHashtableแต่แตกต่างจากHashMapชั้นนี้ไม่อนุญาตให้ null ที่จะนำมาใช้เป็นคีย์หรือค่า
public static void main(String[] args) {
//HashMap<String, Integer> hash = new HashMap<String, Integer>();
Hashtable<String, Integer> hash = new Hashtable<String, Integer>();
//ConcurrentHashMap<String, Integer> hash = new ConcurrentHashMap<>();
new Thread() {
@Override public void run() {
try {
for (int i = 10; i < 20; i++) {
sleepThread(1);
System.out.println("T1 :- Key"+i);
hash.put("Key"+i, i);
}
System.out.println( System.identityHashCode( hash ) );
} catch ( Exception e ) {
e.printStackTrace();
}
}
}.start();
new Thread() {
@Override public void run() {
try {
sleepThread(5);
// ConcurrentHashMap traverse using Iterator, Enumeration is Fail-Safe.
// Hashtable traverse using Enumeration is Fail-Safe, Iterator is Fail-Fast.
for (Enumeration<String> e = hash.keys(); e.hasMoreElements(); ) {
sleepThread(1);
System.out.println("T2 : "+ e.nextElement());
}
// HashMap traverse using Iterator, Enumeration is Fail-Fast.
/*
for (Iterator< Entry<String, Integer> > it = hash.entrySet().iterator(); it.hasNext(); ) {
sleepThread(1);
System.out.println("T2 : "+ it.next());
// ConcurrentModificationException at java.util.Hashtable$Enumerator.next
}
*/
/*
Set< Entry<String, Integer> > entrySet = hash.entrySet();
Iterator< Entry<String, Integer> > it = entrySet.iterator();
Enumeration<Entry<String, Integer>> entryEnumeration = Collections.enumeration( entrySet );
while( entryEnumeration.hasMoreElements() ) {
sleepThread(1);
Entry<String, Integer> nextElement = entryEnumeration.nextElement();
System.out.println("T2 : "+ nextElement.getKey() +" : "+ nextElement.getValue() );
//java.util.ConcurrentModificationException at java.util.HashMap$HashIterator.nextNode
// at java.util.HashMap$EntryIterator.next
// at java.util.Collections$3.nextElement
}
*/
} catch ( Exception e ) {
e.printStackTrace();
}
}
}.start();
Map<String, String> unmodifiableMap = Collections.unmodifiableMap( map );
try {
unmodifiableMap.put("key4", "unmodifiableMap");
} catch (java.lang.UnsupportedOperationException e) {
System.err.println("UnsupportedOperationException : "+ e.getMessage() );
}
}
static void sleepThread( int sec ) {
try {
Thread.sleep( 1000 * sec );
} catch (InterruptedException e) {
e.printStackTrace();
}
}
« Null Keys และ Null Values
HashMapอนุญาตหนึ่งคีย์ว่างสูงสุดหนึ่งคีย์และจำนวนค่า null ใด ๆ ในกรณีที่Hashtableไม่อนุญาตให้ใช้แม้แต่คีย์ null เดียวและค่า null หากคีย์หรือค่าว่างเป็นโมฆะก็จะโยน NullPointerException ตัวอย่าง
« ซิงโครไนซ์เธรดอย่างปลอดภัย
Hashtableถูกซิงโครไนซ์ภายใน ดังนั้นจึงปลอดภัยมากที่จะใช้Hashtableในแอปพลิเคชันแบบมัลติเธรด โดยที่HashMapไม่ถูกซิงโครไนซ์ภายใน ดังนั้นจึงไม่ปลอดภัยที่จะใช้HashMapในแอปพลิเคชันแบบมัลติเธรดโดยไม่มีการซิงโครไนซ์ภายนอก คุณสามารถซิงโครไนซ์ภายนอกHashMapโดยใช้Collections.synchronizedMap()วิธีการ
« ประสิทธิภาพ
ในฐานะที่Hashtableจะตรงภายในนี้จะทำให้ช้ากว่าเล็กน้อยHashtableHashMap
@ดู
