A Collection- සමහර විට බහාලුමක් ලෙස හැඳින්වේ - හුදෙක් තනි ඒකකයකට බහු මූලද්‍රව්‍ය කාණ්ඩ කරන වස්තුවකි. Collectionසමස්ථ දත්ත ගබඩා කිරීමට, ලබා ගැනීමට, හැසිරවීමට සහ සන්නිවේදනය කිරීමට s භාවිතා කරයි. එකතු කිරීමේ රාමුවක් ඩබ්ලිව් යනු එකතුව නියෝජනය කිරීම සහ හැසිරවීම සඳහා වූ ඒකාබද්ධ ගෘහ නිර්මාණ ශිල්පයකි.
මෙම HashMap JDK1.2සහ Hashtable JDK1.0, දෙකම නියෝජනය කරන බව වස්තූන් පිරිසක් නියෝජනය කිරීම සඳහා භාවිතා වේ <Key, Value>යුගල. සෑම <Key, Value>යුගලයක්ම Entryවස්තුව ලෙස හැඳින්වේ . ඇතුළත් කිරීම් එකතු කිරීම HashMapසහ Hashtable. එකතුවක යතුරු අද්විතීය හෝ සුවිශේෂී විය යුතුය. [විශේෂිත යතුරක් සිතියම්ගත කළ අගය ලබා ගැනීමට ඒවා භාවිතා කරන බැවින්. එකතුවක අගයන් අනුපිටපත් කළ හැකිය.]
« Superclass, උරුමය හා එකතුව රාමුව සාමාජික
හැෂ්ටබල් යනු JDK1.0ශබ්දකෝෂ පන්තියේ උප පංතියක් වන හඳුන්වා දුන් උරුම පන්තියකි. එකතු කිරීමේ රාමුවේ සාමාජිකයෙකු JDK1.2කිරීම සඳහා සිතියම් අතුරුමුහුණත ක්රියාත්මක කිරීම සඳහා හැෂ්ටේබල් වෙතින් නැවත සැලසුම් කර ඇත. හැෂ්මැප් යනු ජාවා එකතු කිරීමේ රාමුවේ සාමාජිකයෙකි JDK1.2. හැෂ්මැප් යනු වියුක්ත සිතියම් පන්තියේ උප පංතියයි.
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 { ... }
Capacity ආරම්භක ධාරිතාව සහ පැටවීමේ සාධකය
ධාරිතාව යනු හැෂ් වගුවේ ඇති බාල්දි ගණන වන අතර ආරම්භක ධාරිතාව හුදෙක් හැෂ් වගුව නිර්මාණය කරන අවස්ථාවේ ධාරිතාවය. හැෂ් වගුව විවෘතව ඇති බව සලකන්න: " hashcollision" නම්, තනි බාල්දියක් බහු ඇතුළත් කිරීම් ගබඩා කරයි, ඒවා අනුපිළිවෙලින් සෙවිය යුතුය. පැටවීමේ සාධකය යනු එහි ධාරිතාව ස්වයංක්‍රීයව වැඩි වීමට පෙර හැෂ් වගුව ලබා ගැනීමට කොපමණ ප්‍රමාණයක් ඉඩ දී ඇත්ද යන්නයි.
පෙරනිමි ආරම්භක ධාරිතාව (16) සහ පෙරනිමි පැටවුම් සාධකය (0.75) සහිත හිස් හැෂ් වගුවක් හැෂ්මැප් විසින් සාදයි . පෙරනිමි ආරම්භක ධාරිතාව (11) සහ පැටවුම් සාධකය / පිරවුම් අනුපාතය (0.75) සමඟ හැෂ්ටේබල් හිස් හැෂ් ටේබල් සාදන විට .
« එහි පූරක ගැටීමේ නඩුවේ ව්යුහාත්මක වෙනස්
HashMap, Hashtableහැෂ් isions ට්ටනයකදී ඔවුන් සිතියම් ඇතුළත් කිරීම් සම්බන්ධිත ලැයිස්තු වල ගබඩා කරයි. ජාවා 8 සිටHashMap හැෂ් බාල්දිය නිශ්චිත සීමාවෙන් ඔබ්බට වැඩෙන්නේ නම්, එම බාල්දිය මාරු වේ linked list of entries to a balanced tree. එය O (n) සිට O (ලොග් n) දක්වා නරකම කාර්ය සාධනය වැඩි දියුණු කරයි. ලැයිස්තුව ද්විමය වෘක්ෂයක් බවට පරිවර්තනය කරන අතරම, හැෂ් කේතය ශාඛා විචල්‍යයක් ලෙස භාවිතා කරයි. එකම බාල්දියේ විවිධ හැෂ් කේත දෙකක් තිබේ නම්, එකක් විශාල යැයි සලකන අතර ගසෙහි දකුණට ද අනෙක වමට ද වේ. නමුත් හැෂ් කේත දෙකම සමාන වන විට, HashMapයතුරු සැසඳිය හැකි යැයි උපකල්පනය කර, යම් අනුපිළිවෙලක් පවත්වා ගත හැකි වන පරිදි දිශාව තීරණය කිරීම සඳහා යතුර සංසන්දනය කරයි. HashMap සංසන්දනය කළ හැකි . බාල්දි ප්‍රමාණය ළඟා වුවහොත් ඇතුළත් කිරීම් එකතු කිරීමේදීTREEIFY_THRESHOLD = 8 පරිවර්තන සම්බන්ධිත ලැයිස්තුවේ සමතුලිත ගසකට යතුරු සෑදීම හොඳ පුරුද්දකි.TREEIFY_THRESHOLD අතර බොහෝ UNTREEIFY_THRESHOLD = 6විට සමතුලිත ගස සම්බන්ධිත ඇතුළත් කිරීම් ලැයිස්තුවට නැවත පරිවර්තනය කරනු ඇත.ජාවා 8 එස්ආර්සී , ස්ටක්පොස්ට්
« එකතු-දර්ශන පුනරාවර්තනය, අසාර්ථක-වේගවත් සහ අසාර්ථක-ආරක්ෂිත
+--------------------+-----------+-------------+
| | Iterator | Enumeration |
+--------------------+-----------+-------------+
| Hashtable | fail-fast | safe |
+--------------------+-----------+-------------+
| HashMap | fail-fast | fail-fast |
+--------------------+-----------+-------------+
| ConcurrentHashMap | safe | safe |
+--------------------+-----------+-------------+
Iteratorසොබාදහමේ අසාර්ථක වේගයකි. එනම්, එකතුවක් තමන්ගේම ඉවත් කිරීමේ () ක්‍රමයට අමතරව නැවත සැකසීමේදී වෙනස් කළ හොත් එය සමගාමී මෝඩිෆිකේෂන් එක්සෙප්ෂන් විසි කරයි. ලෙස එහිදී Enumerationඅසමත්-ආරක්ෂිත ස්වභාවය වේ. එකතුවක් නැවත සැකසීමේදී වෙනස් කළ හොත් එය කිසිදු ව්‍යතිරේකයක් නොදක්වයි.
ජාවා ඒපීඅයි ඩොක්ස් වලට අනුව, ගණනය කිරීමට වඩා ඉටරේටරය සැමවිටම කැමති වේ.
සටහන: ගණන් කිරීමේ අතුරුමුහුණතේ ක්‍රියාකාරිත්වය අනුපිටපත් අතුරුමුහුණත මඟින් අනුපිටපත් කර ඇත. ඊට අමතරව, අයිටරේටර් විකල්ප ඉවත් කිරීමේ මෙහෙයුමක් එක් කරන අතර කෙටි ක්රම නාම ඇත. නව ක්රියාත්මක කිරීම් ගණන් බැලීමට වඩා අයිටරේටර් භාවිතා කිරීම සලකා බැලිය යුතුය.
දී ජාවා 5 ConcurrentMap අතුරුමුහුණත හඳුන්වා : ConcurrentHashMap- ඉතා සමගාමී, ඉහළ කාර්ය ConcurrentMapක්රියාත්මක කිරීම හැෂ් වගුව මගින් පිටුබලය. නැවත ලබා ගැනීමේදී මෙම ක්රියාත්මක කිරීම කිසි විටෙකත් අවහිර නොවන අතර යාවත්කාලීන කිරීම් සඳහා සමගාමී මට්ටම තෝරා ගැනීමට සේවාදායකයාට ඉඩ දෙයි. එය පහත දැක්වෙන ආදේශකයක් ලෙස අදහස් කෙරේ Hashtable: ක්රියාත්මක කිරීමට අමතරව ConcurrentMap, එය සුවිශේෂී “උරුම” ක්රම සියල්ලටම සහය දක්වයි Hashtable.
සෑම HashMapEntryවටිනාකමක්ම වාෂ්පශීලී වන අතර එමඟින් විවාදාත්මක වෙනස් කිරීම් සහ පසු කියවීම් සඳහා සිහින් ධාන්ය අනුකූලතාවයක් සහතික කරයි; සෑම කියවීමක්ම මෑතකදී සම්පුර්ණ කරන ලද යාවත්කාලීන කිරීම පිළිබිඹු කරයි
අනුකාරක සහ ගණන් බැලීම් අසාර්ථකයි - අනුකාරක / ගණන් බැලීම් නිර්මාණය කිරීමෙන් පසු යම් අවස්ථාවක දී රාජ්‍යය පිළිබිඹු කරයි; අඩු අනුකූලතාවයේ පිරිවැය මත එකවර කියවීමට හා වෙනස් කිරීමට මෙය ඉඩ දෙයි. ඔවුන් සමගාමී මෝඩිෆිකේෂන් එක්සෙෂන් විසි නොකරයි. කෙසේ වෙතත්, iterator නිර්මාණය කර ඇත්තේ වරකට එක් නූල් එකක් පමණක් භාවිතා කිරීමටය.
මෙන් 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();
}
}
« NULL යතුරු සහ NULL අගයන්
HashMapඋපරිම එක් ශුන්‍ය යතුරක් සහ ඕනෑම ශුන්‍ය අගයන් ගණනකට ඉඩ දෙයි. කොහෙද ලෙස Hashtableපවා තනි ශූන්ය යතුර සහ හිස් අගයක් ඉඩ දෙන්නේ නැහැ ප්රධාන හෝ අගය NULL එය NullPointerException අවුලට නම්. උදාහරණයක්
« වෙළඳ පොළෙන්, නූල් ආරක්ෂිත
Hashtableඅභ්‍යන්තරව සමමුහුර්ත කර ඇත. එබැවින් Hashtableබහු නූල් යෙදුම්වල භාවිතා කිරීම ඉතා ආරක්ෂිත වේ . කොහෙද ලෙස HashMapඅභ්යන්තර සමමුහුර්ත කර නැත. එබැවින් HashMapබාහිර සමමුහුර්තකරණයකින් තොරව බහු නූල් යෙදුම්වල භාවිතා කිරීම ආරක්ෂිත නොවේ . ඔබ බාහිර එකවර සිදුවීමට හැකි HashMapභාවිතා Collections.synchronizedMap()ක්රමය.
« කාර්ය සාධනය
ලෙස Hashtableඅභ්යන්තර සමමුහුර්ත නම්, මේ කරයි Hashtableතරමක් මන්දගාමී වඩා HashMap.
See බලන්න
