HashMap, LinkedHashMap සහ TreeMap අතර වෙනස

අතර ඇති වෙනස කුමක්ද HashMap, LinkedHashMapහා TreeMapජාවා? මම සියලු තුනක් ලෙස ප්රතිදානය අතර යම් වෙනසක් දකින්න තිබෙනවා නැහැ 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, එකතු කිරීමේ රාමුව පැවතීමට පෙර ජාවා 1.1 සිට යල් පැන ගිය පන්තියකි. එය තවදුරටත් භාවිතා නොකළ යුතුය, මන්ද එහි API ක්‍රියාකාරීත්වය අනුපිටපත් කරන යල්පැනගිය ක්‍රම සමඟ පැටලී ඇති අතර එහි ක්‍රම සමමුහුර්ත කර ඇත (එමඟින් ක්‍රියාකාරීත්වය අඩු විය හැකි අතර සාමාන්‍යයෙන් නිෂ් less ල වේ). හැෂ්ටේබල් වෙනුවට සමගාමී හැෂ්මැප් භාවිතා කරන්න .

මම දෘශ්‍ය ඉදිරිපත් කිරීමට කැමතියි:

╔══════════════╦═════════════════════╦═══════════════════╦═════════════════════╗
║   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 මත පදනම් වූ සිතියමේ hashing යතුරු. එය O (1) get / put මෙහෙයුම් සඳහා සහය දක්වයි. යතුරු තිබිය යුතුය නිරතුරුව නිර්මාණයන් hashCode()හාequals() මේ සඳහා වැඩ කිරීමට.

2. LinkedHashMap හැෂ්මැප් වලට බෙහෙවින් සමාන ය, නමුත් එය අයිතම එකතු කරන අනුපිළිවෙලට දැනුවත් කිරීමක් එක් කරයි (හෝ ප්‍රවේශ වේ), එබැවින් පුනරාවර්තන අනුපිළිවෙල ඇතුළු කිරීමේ අනුපිළිවෙලට සමාන වේ (හෝ ඉදිකිරීම් පරාමිතීන් මත පදනම්ව ප්‍රවේශ අනුපිළිවෙල).

3. TreeMap යනු ගස් පදනම් කරගත් සිතියම්කරණයකි. එහි තැබීමේ / ලබා ගැනීමේ මෙහෙයුම් සඳහා O (ලොග් එන්) කාලය ගතවේ. සංසන්දනාත්මක හෝ සංසන්දකය සමඟ සංසන්දනාත්මක යාන්ත්‍රණයක් තිබීම සඳහා අයිතම අවශ්‍ය වේ. පුනරාවර්තන අනුපිළිවෙල තීරණය වන්නේ මෙම යාන්ත්‍රණය මගිනි.

පහත දැක්වෙන රූප සටහනේ ( විශාල එකක් ) පන්ති ධූරාවලිය තුළ එක් එක් පන්තිය කොතැනදැයි බලන්න . TreeMap උපකරණ SortedMapසහ NavigableMapඅතර HashMapනැහැ.

HashTableයල්පැන ඇති අතර අනුරූප ConcurrentHashMapපන්තිය භාවිතා කළ යුතුය.

හැෂ්මැප්

• එයට යුගල අගයන් ඇත (යතුරු, අගයන්)
• අනුපිටපත් යතුරු අගයන් නොමැත
• අනුපිළිවෙලට නොගත්
• එය එක් ශුන්‍ය යතුරකට සහ ශුන්‍ය අගයන් එකකට වඩා ඉඩ දෙයි

හැෂ්ටේබල්

• හැෂ් සිතියම හා සමානයි
• එය ශුන්‍ය යතුරු සහ ශුන්‍ය අගයන්ට ඉඩ නොදේ

LinkedHashMap

• සිතියම් ක්‍රියාත්මක කිරීමේ අනුවාදය ඇණවුම් කර ඇත
• සම්බන්ධිත ලැයිස්තුව සහ හැෂිං දත්ත ව්‍යුහයන් මත පදනම්ව

රුක් සිතියම

• ඇණවුම් කරන ලද සහ සැකසූ අනුවාදය
• දත්ත ව්‍යුහයන් හැෂිං මත පදනම්ව

සිතියම් පිළිබඳ මගේ අත්දැකීම් වලින් තවත් ආදාන කිහිපයක්, මම ඒවා භාවිතා කරන්නේ කවදාද යන්න මත:

• හැෂ්මැප් - හොඳම ක්‍රියාකාරී (වේගවත්) ක්‍රියාත්මක කිරීමක් සොයන විට වඩාත් ප්‍රයෝජනවත් වේ.
• TreeMap (SortedMap අතුරුමුහුණත) - මා විසින් නිර්වචනය කර ඇති විශේෂිත අනුපිළිවෙලකට යතුරු වර්ග කිරීමට හෝ නැවත සැකසීමට හැකි වීම ගැන මම සැලකිලිමත් වන විට වඩාත් ප්‍රයෝජනවත් වේ.
• LinkedHashMap - TreeMap නඩත්තු කිරීමේ වැඩි පිරිවැයකින් තොරව TreeMap වෙතින් සහතික කළ ඇණවුමේ වාසි ඒකාබද්ධ කරයි. (එය හැෂ්මැප් තරම් වේගවත් ය). විශේෂයෙන්, LinkedHashMap removeEldestEntry()ක්‍රමවේදය ඉක්මවා යාමෙන් හැඹිලි වස්තුවක් නිර්මාණය කිරීම සඳහා හොඳ ආරම්භක ස්ථානයක් සපයයි . ඔබ අර්ථ දක්වන සමහර නිර්ණායක භාවිතා කරමින් දත්ත කල් ඉකුත්විය හැකි හැඹිලි වස්තුවක් නිර්මාණය කිරීමට මෙය ඔබට ඉඩ දෙයි.

පංති තුනම HashMap, TreeMapසහ අතුරු මුහුණත LinkedHashMapක්‍රියාත්මක කරන java.util.Mapඅතර අද්විතීය යතුරේ සිට අගයන් දක්වා සිතියම්ගත කිරීම නිරූපණය කරයි.

හැෂ්මැප්

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. එය හැෂ්මැප් වෙනුවට ඇතුළත් කිරීමේ අනුපිළිවෙල පවත්වා ගෙන යයි . // පංති පරිහානිය පහතින් බලන්න

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

රුක් සිතියම

1. A TreeMapයතුර මත පදනම් වූ අගයන් අඩංගු වේ. එය NavigableMap අතුරුමුහුණත ක්‍රියාත්මක කරන අතර සාරාංශ සිතියම් පන්තිය පුළුල් කරයි.
2. එහි අඩංගු වන්නේ අද්විතීය අංග පමණි.
3. එයට ශුන්‍ය යතුරක් තිබිය නොහැකි නමුත් බහු ශුන්‍ය අගයන් තිබිය හැක.

4. එය ඒ HashMapවෙනුවට නගින අනුපිළිවෙල පවත්වා ගෙන යයි (එහි යතුරේ ස්වාභාවික අනුපිළිවෙල අනුව වර්ග කර ඇත.).

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

කඩිනම්

1. හැෂ්ටබල් යනු ලැයිස්තුවේ පෙළකි. සෑම ලැයිස්තුවක්ම බාල්දියක් ලෙස හැඳින්වේ. හැෂ්කෝඩ් () ක්‍රමය ඇමතීමෙන් බාල්දියේ පිහිටීම හඳුනා ගැනේ. හැෂ් ටේබල් යතුර මත පදනම් වූ අගයන් අඩංගු වේ.
2. එහි අඩංගු වන්නේ අද්විතීය අංග පමණි.
3. එයට කිසිදු ශුන්‍ය යතුරක් හෝ අගයක් නොතිබිය හැකිය.
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

හැෂ්මැප් නැවත අනුපිළිවෙල ගැන සහතිකයක් ලබා නොදේ. නව මූලද්‍රව්‍ය එකතු කළ විට එය සම්පූර්ණයෙන්ම වෙනස් විය හැකිය. TreeMap යතුරු වල සංසන්දනාත්මක () ක්‍රමයට අනුව (හෝ බාහිරව සපයන ලද සංසන්දකය) අනුව යතුරු “ස්වාභාවික අනුපිළිවෙලට” අනුව නැවත ක්‍රියාත්මක වේ. මීට අමතරව, මෙම වර්ග කිරීමේ අනුපිළිවෙල මත රඳා පවතින ක්‍රම අඩංගු වන SortedMap අතුරුමුහුණත ක්‍රියාත්මක කරයි. LinkedHashMap සිතියමට ඇතුළත් කළ අනුපිළිවෙලට නැවත කියනු ඇත

කාර්ය සාධනය වෙනස් වන ආකාරය දෙස බලන්න ..

වර්ග කළ සිතියම ක්‍රියාත්මක කරන රුක් සිතියම. ස්වාභාවික අනුපිළිවෙල නිසා තැබීමේ, ලබා ගැනීමේ සහ අඩංගු කිරීමේ සංකීර්ණත්වය O (log n) වේ

ImAmit: SortedMapඅතුරු මුහුණතක් වන අතර අතුරු මුහුණත TreeMapක්‍රියාත්මක කරන පන්තියකි SortedMap. එයින් අදහස් කරන්නේ SortedMapඑහි ක්‍රියාත්මක කරන්නන්ගෙන් ඉල්ලා සිටින ප්‍රොටෝකෝලය අනුගමනය කරන්නේ නම් . ගසක් සෙවුම් ගසක් ලෙස ක්‍රියාත්මක නොකරන්නේ නම්, ඔබට ඇණවුම් කළ දත්ත ලබා දිය නොහැක, මන්ද ගස ඕනෑම ආකාරයක ගසක් විය හැකිය. එබැවින් TreeMap වර්ග කළ අනුපිළිවෙල මෙන් ක්‍රියා කිරීම සඳහා, එය SortedMap ක්‍රියාත්මක කරයි (උදා: ද්විමය සෙවුම් ගස - BST, AVL සහ RB Tree වැනි සමබර BST, තෘතීය සෙවුම් ගස පවා - බොහෝ විට ඇණවුම් කළ ආකාරයට නැවත සෙවීම් සඳහා භාවිතා කරයි).

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

NUT-SHELL හි HashMap: O (1) හි දත්ත ලබා දෙයි, ඇණවුම් කිරීමක් නොමැත

TreeMap : ඇණවුම් කළ යතුරු සමඟ O (ලොග් එන්), බේස් 2 හි දත්ත ලබා දෙයි

LinkedHashMap: සම්බන්ධිත ලැයිස්තුවක් සහිත හැෂ් වගුව (සුචිගත-මඟහරින්න ලැයිස්තුව ගැන සිතන්න) ගස තුළට දත්ත ඇතුල් කරන ආකාරයට ගබඩා කිරීමේ හැකියාව. LRU ක්‍රියාත්මක කිරීමට වඩාත් සුදුසුය (අවම වශයෙන් මෑතකදී භාවිතා කරන ලදි).

HashMap සහ TreeMap අතර ප්‍රධාන වෙනස පහත දැක්වේ

1. හැෂ්මැප් කිසිදු ඇණවුමක් පවත්වාගෙන යන්නේ නැත. වෙනත් වචන වලින් කිවහොත්, මුලින් ඇතුළත් කළ මූලද්‍රව්‍යය පළමුව මුද්‍රණය වන බවට හැෂ්මැප් කිසිදු සහතිකයක් ලබා නොදෙන අතර, ට්‍රීසෙට් මෙන්ම ට්‍රීමැප් මූලද්‍රව්‍ය ද එහි මූලද්‍රව්‍යයන්ගේ ස්වාභාවික අනුපිළිවෙල අනුව වර්ග කර ඇත.

2. අභ්‍යන්තර හැෂ්මැප් ක්‍රියාත්මක කිරීමේ භාවිතය හැෂිං සහ ට්‍රීමැප් අභ්‍යන්තරව රතු-කළු ගස් ක්‍රියාත්මක කිරීම භාවිතා කරයි.

3. හැෂ්මැප් හට එක් ශුන්‍ය යතුරක් සහ බොහෝ ශුන්‍ය අගයන් ගබඩා කළ හැකිය.

4. ලබා ගැනීම සහ තැබීම වැනි මූලික මෙහෙයුම් සඳහා හැෂ්මැප් නිරන්තර කාර්ය සාධනයක් ලබා ගනී .එය ඔරකල් ලියකියවිලි වලට අනුව, ට්‍රීමැප් විසින් ලබා ගැනීමේ සහ තැබීමේ ක්‍රමය සඳහා සහතික කළ ලොග් (එන්) කාල පිරිවැය සපයයි.

5. HashMap TreeMap වලට වඩා වේගවත් ය, බොහෝ මෙහෙයුම් සඳහා TashMap ලොග් වේලාවට සාපේක්ෂව HashMap හි ක්‍රියාකාරී කාලය නියත වේ.

6. හැෂ්මැප් සාපේක්ෂව සමාන () ක්‍රමයක් භාවිතා කරන අතර ට්‍රීමැප් ඇණවුම් කිරීම පවත්වා ගැනීම සඳහා සංසන්දනාත්මක () ක්‍රමය භාවිතා කරයි.

7. HashMap සිතියම් අතුරුමුහුණත ක්‍රියාත්මක කරන අතර TreeMap NavigableMap අතුරුමුහුණත ක්‍රියාත්මක කරයි.

මේවා එකම අතුරු මුහුණතේ වෙනස් ක්‍රියාත්මක කිරීම් ය. සෑම ක්‍රියාත්මක කිරීමකටම යම් වාසි සහ අවාසි ඇත (වේගයෙන් ඇතුළු කිරීම, මන්දගාමී සෙවීම) හෝ අනෙක් අතට.

විස්තර සඳහා වන javadoc දිහා TreeMap , HashMap , LinkedHashMap .

හැෂ් සිතියම ඇතුළු කිරීමේ අනුපිළිවෙල ආරක්ෂා නොකරයි.
උදාහරණයක්. හැෂ්මැප් ඔබ යතුරු ඇතුළු කරන්නේ නම්

1  3
5  9
4   6
7   15
3   10

එය එය ලෙස ගබඩා කළ හැකිය

4  6
5  9
3  10
1  3
7  15

සම්බන්ධිත හැෂ්මාප් ඇතුළු කිරීමේ අනුපිළිවෙල ආරක්ෂා කරයි.

උදාහරණයක්.
ඔබ යතුරු ඇතුළු කරන්නේ නම්

1  3
5  9
4   6
7   15
3   10

එය එය ලෙස ගබඩා කරනු ඇත

1  3
5  9
4   6
7   15
3   10

අපි ඇතුළු කරන ආකාරයටම.

රුක් සිතියම මඟින් යතුරු වල වැඩි කිරීමේ පිළිවෙලෙහි වේල්ස් ගබඩා කරයි. උදාහරණයක්.
ඔබ යතුරු ඇතුළු කරන්නේ නම්

1  3
5  9
4   6
7   15
3   10

එය එය ලෙස ගබඩා කරනු ඇත

1  3
3  10
4   6
5   9
7   15

• හැෂ්මැප්:

  • ඇණවුම නඩත්තු නොවේ
  • LinkedHashMap ට වඩා වේගවත්
  • වස්තු ගබඩා කිරීම සඳහා භාවිතා වේ

• LinkedHashMap:

  • LinkedHashMap ඇතුළු කිරීමේ අනුපිළිවෙල පවත්වාගෙන යනු ඇත
  • හැෂ්මැප් වලට වඩා මන්දගාමී සහ ට්‍රීමැප් වලට වඩා වේගවත්
  • ඇතුළත් කිරීමේ ඇණවුමක් පවත්වා ගැනීමට ඔබට අවශ්‍ය නම් මෙය භාවිතා කරන්න.

• රුක් සිතියම:

  • TreeMap යනු ගස පදනම් කරගත් සිතියම්කරණයකි
  • TreeMap යතුරේ ස්වාභාවික අනුපිළිවෙල අනුගමනය කරනු ඇත
  • HashMap සහ LinkedHashMap වලට වඩා සෙමින්
  • ඔබට ස්වාභාවික (පෙරනිමි) ඇණවුමක් පවත්වා ගැනීමට අවශ්‍ය වූ විට TreeMap භාවිතා කරන්න

සියල්ලම යතුරු-> වටිනාකම් සිතියමක් සහ යතුරු හරහා නැවත යෙදීමට ක්‍රමයක් ඉදිරිපත් කරයි. මෙම පංති අතර වඩාත්ම වැදගත් වෙනස වන්නේ කාලය සහතික කිරීම සහ යතුරු ඇණවුම් කිරීමයි.

1. හැෂ්මැප් 0 (1) බැලීම සහ ඇතුළත් කිරීම ඉදිරිපත් කරයි. ඔබ යතුරු හරහා නැවත ක්‍රියා කරන්නේ නම්, යතුරු ඇණවුම් කිරීම අත්‍යවශ්‍යයෙන්ම අත්තනෝමතික ය. එය ක්‍රියාත්මක වන්නේ සම්බන්ධිත ලැයිස්තු සමූහයක් මගිනි.
2. TreeMap මඟින් O (ලොග් එන්) බැලීම සහ ඇතුළත් කිරීම ඉදිරිපත් කරයි. යතුරු ඇණවුම් කර ඇත, එබැවින් ඔබට යතුරු පිළිවෙලට පිළිවෙලට කිරීමට අවශ්‍ය නම්, ඔබට හැකිය. මෙයින් අදහස් කරන්නේ යතුරු සංසන්දනාත්මක අතුරු මුහුණත ක්‍රියාත්මක කළ යුතු බවයි. ට්‍රීමැප් ක්‍රියාත්මක කරන්නේ රතු-කළු ගසක් විසිනි.
3. LinkedHashMap මඟින් 0 (1) බැලීම සහ ඇතුළත් කිරීම ඉදිරිපත් කරයි. යතුරු ඇණවුම් කරන්නේ ඒවායේ ඇතුළත් කිරීමේ අනුපිළිවෙල අනුව ය. එය ක්‍රියාත්මක වන්නේ ද්විත්ව සම්බන්ධිත බාල්දි මගිනි.

පහත දැක්වෙන ශ්‍රිතයට ඔබ හිස් ට්‍රීමැප්, හැෂ්මැප් සහ ලින්ක්ඩ් හැෂ්මැප් සම්මත කර ඇතැයි සිතන්න:

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

එක් එක් සඳහා ප්‍රතිදානය පහත ප්‍රති results ල මෙන් පෙනෙනු ඇත.

හැෂ්මැප් සඳහා, ප්‍රතිදානය මගේම පරීක්ෂණ වලදී {0, 1, -1 was විය, නමුත් එය ඕනෑම ඇණවුමක් විය හැකිය. ඇණවුම් කිරීම පිළිබඳ සහතිකයක් නොමැත.
Treemap, ප්‍රතිදානය {-1, 0, 1}
LinkedList, ප්‍රතිදානය {1, -1, 0 was

මෙම තිදෙනා අතර වඩාත්ම වැදගත් වන්නේ ඔවුන් ඇතුළත් කිරීම් අනුපිළිවෙල සුරකින ආකාරයයි.

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

මෙහි විශිෂ්ට පිළිතුරු ඕනෑ තරම් තිබියදීත්, Mapජාවා 11 සමඟ එකතු කර ඇති විවිධ ක්‍රියාත්මක කිරීම් විස්තර කරන මගේම වගුවක් ඉදිරිපත් කිරීමට මම කැමතියි .

වගු ග්‍රැෆික් හි ලැයිස්තුගත කර ඇති මෙම වෙනස්කම් අපට දැකිය හැකිය:

• HashMapමෙම වන පොදු කාර්යය Map නැහැ, ඔබ විශේෂ අවශ්යතා ඇති විට පොදුවේ භාවිතා.
• LinkedHashMapHashMapමෙම හැසිරීම එකතු කරමින් විස්තාරණය කරයි: ඇණවුමක් පවත්වා ගෙන යයි, ඇතුළත් කිරීම් මුලින් එකතු කළ අනුපිළිවෙල . යතුරු-අගය ඇතුළත් කිරීම සඳහා අගය වෙනස් කිරීම අනුපිළිවෙලෙහි එහි ස්ථානය වෙනස් නොකරයි.
• TreeMap(අ) “ස්වාභාවික” අනුපිළිවෙල භාවිතා කරයි , එනම් අතුරු මුහුණතේ compareToඅර්ථ දක්වා ඇති ප්‍රධාන වස්තූන් මත ක්‍රමයේ වටිනාකම Comparableහෝ (ආ) ඔබ සපයන ක්‍රියාත්මක කිරීමක්Comparator ඉල්ලා සිටී .
  • TreeMapSortedMapඅතුරු මුහුණත සහ එහි අනුප්‍රාප්තිකයා වන අතුරු මුහුණත යන දෙකම ක්‍රියාත්මක කරයි NavigableMap.
• NULL න්: TreeMapනැත නැත ප්රධාන ලෙස NULL ඉඩ ඇති අතර, HashMapසහ LinkedHashMapකරන්න.
  • මේ තුනම NULL අගය ලෙස ඉඩ දෙයි.
• HashTableය උරුමය ජාවා 1 සිට, . ConcurrentHashMapපංතිය විසින් ආදේශ කරනු ලැබේ . Javadoc උපුටා දැක්වීම: ConcurrentHashMapඑකම ක්‍රියාකාරී පිරිවිතරයන්ට අවනත වන අතර Hashtable, එක් එක් ක්‍රමයට අනුරූප වන ක්‍රමවේදයන්ගේ අනුවාදයන්ද ඇතුළත් වේ Hashtable.

HashMap හි
එක් ශුන්‍ය යතුරක් අඩංගු විය හැකිය.

හැෂ්මැප් කිසිදු ඇණවුමක් පවත්වාගෙන යන්නේ නැත.

රුක් සිතියම

TreeMap හි කිසිදු ශුන්‍ය යතුරක් අඩංගු විය නොහැක.

TreeMap නැගීමේ අනුපිළිවෙල පවත්වා ගනී.

LinkedHashMap

ඇතුළත් කළ අනුපිළිවෙල පවත්වා ගැනීම සඳහා LinkedHashMap භාවිතා කළ හැකිය, කුමන යතුරු සිතියමට ඇතුළත් කර ඇත්ද නැතහොත් යතුරු ප්‍රවේශ කළ හැකි ප්‍රවේශ ඇණවුමක් පවත්වා ගැනීමටද එය භාවිතා කළ හැකිය.

උදාහරණ ::

1) හැෂ්මැප් සිතියම = නව හැෂ්මැප් ();

    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 සිතියම = නව 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 සිතියම = නව 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());
    }