ए Collection- कभी-कभी कंटेनर कहा जाता है - बस एक वस्तु है जो कई तत्वों को एक इकाई में समूहित करता है। Collections का उपयोग कुल डेटा को संग्रहीत करने, पुनः प्राप्त करने, हेरफेर करने और संचार करने के लिए किया जाता है। एक संग्रह फ्रेमवर्क डब्ल्यू प्रतिनिधित्व करने और हेरफेर करने के लिए एक एकीकृत वास्तुकला है।
HashMap JDK1.2और Hashtable JDK1.0, दोनों वस्तुओं है कि में प्रतिनिधित्व कर रहे हैं के एक समूह का प्रतिनिधित्व करने के लिए उपयोग किया जाता <Key, Value>जोड़ी। प्रत्येक <Key, Value>जोड़ी को Entryऑब्जेक्ट कहा जाता है। प्रविष्टियों का संग्रह की वस्तु से जाना जाता है HashMapऔर Hashtable। एक संग्रह की कुंजी विशिष्ट या विशिष्ट होनी चाहिए। [के रूप में वे एक विशेष मूल्य एक प्रतिचित्रित मूल्य को प्राप्त करने के लिए उपयोग किया जाता है। एक संग्रह में मूल्यों को दोहराया जा सकता है।]
« सुपरक्लास, लिगेसी और कलेक्शन फ्रेमवर्क सदस्य
हैशटेबल एक विरासत श्रेणी है जिसे शुरू किया गया JDK1.0, जो कि शब्दकोश वर्ग का एक उपवर्ग है। से JDK1.2Hashtable लागू करने के लिए फिर से इंजीनियर है मानचित्र इंटरफ़ेस संग्रह ढांचे के एक सदस्य बनाने के लिए। HashMap अपने संग्रह की शुरुआत से ही जावा संग्रह फ्रेमवर्क का एक सदस्य है 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) के । जहां हैशटेबल डिफ़ॉल्ट प्रारंभिक क्षमता (11) और लोड फैक्टर / भराव अनुपात (0.75) के साथ खाली हैशटेब का निर्माण करता है ।
« हैश टक्कर के मामले में संरचनात्मक संशोधन
HashMap, Hashtableहैश टक्कर के मामले में वे लिंक प्रविष्टियों में मानचित्र प्रविष्टियों को संग्रहीत करते हैं। के लिए Java8 सेHashMap अगर हैश बाल्टी एक निश्चित सीमा से आगे बढ़ती है, तो वह बाल्टी से स्विच हो जाएगी । जो ओ (एन) से ओ (लॉग एन) से सबसे खराब स्थिति के प्रदर्शन में सुधार करता है। सूची को बाइनरी ट्री में परिवर्तित करते समय, हैशकोड का उपयोग ब्रांचिंग चर के रूप में किया जाता है। यदि एक ही बाल्टी में दो अलग-अलग हैशकोड हैं, तो एक बड़ा माना जाता है और पेड़ के दाईं ओर और दूसरा एक बाईं ओर जाता है। लेकिन जब दोनों हैशकोड समान होते हैं, तो माना जाता है कि चाबियाँ तुलनीय हैं, और कुंजी को दिशा निर्धारित करने के लिए तुलना करता है ताकि कुछ आदेश बनाए रखा जा सके। तुलनीय की कुंजी बनाने के लिए यह एक अच्छा अभ्यास है । यदि बकेट का आकार पहुँचता है तो प्रविष्टियाँ जोड़ने पर और अधिक से अधिक प्रविष्टियों की लिंक की गई सूची के लिए संतुलित पेड़ को वापस कर देगा। जावा 8 एसआरसीlinked list of entries to a balanced treeHashMapHashMap TREEIFY_THRESHOLD = 8प्रविष्टियों की लिंक की गई सूची को एक संतुलित पेड़ में परिवर्तित करें, प्रविष्टियों को कम से कम हटाने पर , स्टैकपोस्टTREEIFY_THRESHOLDUNTREEIFY_THRESHOLD = 6
« संग्रह-दृश्य पुनरावृत्ति, विफल-फास्ट और विफल-सुरक्षित
+--------------------+-----------+-------------+
| | Iterator | Enumeration |
+--------------------+-----------+-------------+
| Hashtable | fail-fast | safe |
+--------------------+-----------+-------------+
| HashMap | fail-fast | fail-fast |
+--------------------+-----------+-------------+
| ConcurrentHashMap | safe | safe |
+--------------------+-----------+-------------+
Iteratorप्रकृति में एक असफल-उपवास है। अगर यह एक संग्रह को संशोधित करने के अलावा अन्य है, तो यह समवर्तीModificationException फेंकता है। जहां Enumerationप्रकृति में असफल-सुरक्षित है। यदि पुनरावृति करते समय कोई संग्रह संशोधित किया जाता है तो यह कोई अपवाद नहीं फेंकता है।
जावा एपीआई डॉक्स के अनुसार, Iterator को हमेशा Enumeration से अधिक पसंद किया जाता है।
ध्यान दें: गणना इंटरफ़ेस की कार्यक्षमता Iterator इंटरफ़ेस द्वारा दोहराई गई है। इसके अलावा, Iterator एक वैकल्पिक निष्कासन ऑपरेशन जोड़ता है, और इसमें कम विधि नाम होते हैं। गणना के लिए नए कार्यान्वयन को Iterator का उपयोग करने पर विचार करना चाहिए।
में जावा 5 पेश किया ConcurrentMap इंटरफ़ेस : ConcurrentHashMap- एक उच्च समवर्ती, उच्च प्रदर्शन ConcurrentMapकार्यान्वयन एक हैश तालिका पर आधारित। पुनर्प्राप्ति करते समय यह कार्यान्वयन कभी भी अवरुद्ध नहीं होता है और क्लाइंट को अपडेट के लिए संगामिति स्तर का चयन करने की अनुमति देता है। यह एक ड्रॉप-इन प्रतिस्थापन के रूप में है Hashtable: ConcurrentMapइसे लागू करने के अलावा , यह "विरासत" के सभी तरीकों का समर्थन करता है Hashtable।
प्रत्येक HashMapEntryएस मूल्य अस्थिर है, जिससे संशोधित संशोधनों और बाद में पढ़ने के लिए ठीक अनाज स्थिरता सुनिश्चित होती है; प्रत्येक पढ़ा सबसे हाल ही में पूरा किया गया अद्यतन दर्शाता है
Iterators और Enumerations विफल सुरक्षित हैं - कुछ बिंदु पर राज्य को दर्शाते हैं जब से पुनरावृत्ति / गणन की रचना; यह एक साथ पढ़ता है और कम स्थिरता की कीमत पर संशोधन के लिए अनुमति देता है। वे ConcurrentModificationException को नहीं फेंकते हैं। हालांकि, पुनरावृत्तियों को एक समय में केवल एक थ्रेड द्वारा उपयोग करने के लिए डिज़ाइन किया गया है।
जैसा Hashtableलेकिन विपरीत HashMap, इस वर्ग के रिक्त एक कुंजी या मूल्य के रूप में इस्तेमाल किया जा करने की अनुमति नहीं देता है।
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();
}
}
« नल कीज और नल मान
HashMapअधिकतम एक अशक्त कुंजी और किसी भी शून्य मान की अनुमति देता है। जहाँ के रूप में Hashtableएक भी अशक्त कुंजी और अशक्त मूल्य की अनुमति नहीं है, अगर कुंजी या मूल्य अशक्त है तो यह NullPointerException फेंकता है। उदाहरण
« सिंक्रनाइज़, थ्रेड सुरक्षित
Hashtableआंतरिक रूप से सिंक्रनाइज़ है। इसलिए, Hashtableबहु थ्रेडेड अनुप्रयोगों में उपयोग करना बहुत सुरक्षित है । जहां HashMapआंतरिक रूप से सिंक्रनाइज़ नहीं है। इसलिए, HashMapबाहरी सिंक्रनाइज़ेशन के बिना बहु थ्रेडेड अनुप्रयोगों में उपयोग करना सुरक्षित नहीं है । आप बाह्य रूप से विधि HashMapका उपयोग करके सिंक्रनाइज़ कर सकते हैं Collections.synchronizedMap()।
« प्रदर्शन
जैसा Hashtableकि आंतरिक रूप से सिंक्रनाइज़ किया जाता है, यह Hashtableतुलना में थोड़ा धीमा बनाता है HashMap।
@देख
