CodeGym /בלוג Java /Random-HE /ממשק מפה ב-Java

רָמָה

San Francisco

14 February 2023
48 views
0 comments

ממשק מפה ב-Java

מהו ממשק מפת Java

ממשק Java Map הוא חלק ממסגרת Java Collection, אך הוא אינו תת-סוג של ממשק האוסף. אז הוא מתנהג בצורה שונה בהשוואה למשל לרשימות או לאובייקטי אוסף אחרים. כל רכיב של Map<Key, Value> מייצג זוג מפתח-ערך. גם מפתח וגם ערך הם כמה אובייקטים. כל המפתחות במפה מסוימת הם ייחודיים, בעוד שהערכים אינם, כך שניתן לשכפל אותם. אתה עשוי לחשוב על מפה ב-Java כמו סוג של מילון או קטלוג חנות מקוונת, שבו אתה יכול למצוא כל פריט באמצעות האינדקס הייחודי שלו. המפתח הוא מזהה ייחודי של הערך במפה. לדוגמה במפה<String, Item> String הוא מזהה של פריט כלשהו מהחנות המקוונת. על פי התיעוד למפה יש את ממשקי המשנה הבאים:

כריכות ;

ConcurrentMap<K,V> ;

ConcurrentNavigableMap<K,V> ;

LogicalMessageContext ;

MessageContext ;

NavigableMap<K,V> ;

SOAPMessageContext ;

SortedMap<K,V> .

ומיישם שיעורים:

מפה מופשטת
תכונות
AuthProvider
ConcurrentHashMap
ConcurrentSkipListMap
EnumMap
מפת גיבוב
טבלת גיבוב
IdentityHashMap
LinkedHashMap
PrinterStateReasons
נכסים
ספק
רמזים לעיבוד
SimpleBindings
TabularDataSupport
מפת עץ
UIDfaults
WeakHashMap

Java AbstractMap היא מחלקה אבסטרקטית המיישמת את רוב ממשק המפה.
Java HashMap הוא מבנה נתונים לאחסון צמדי מפתח-ערך באמצעות טבלת Hash.
Java TreeMap הוא מבנה נתונים לשימוש בעץ, כלומר תצוגה עם מפתחות ממוינים.
WeakHashMap לשימוש בטבלת גיבוב עם מפתחות חלשים, תצוגה עם ערכים שיכולים להימחק על ידי אספן האשפה אם הם אינם בשימוש יותר.
LinkedHashMap היא מפה עם סדר הוספת האלמנטים, מאפשרת איטרציה בסדר ההכנסה.
EnumMap מרחיבה את מחלקת AbstractMap לשימוש עם מפתחות enum.

IdentityHashMap משתמש בבדיקת שוויון התייחסות בעת השוואת מסמכים, מיפוי עם מפתחות השוואה באמצעות פעולת == במקום שיטת equals()

כאן אנו מעוניינים בהטמעות הפופולריות ביותר של ממשק מפה: HashMap, TreeMap ו-LinkedHashMap. אגב, סדר רכיבי המפה תלוי בהטמעות ספציפיות. נניח, ל-TreeMap ול-LinkedHashMap יש סדר צפוי של האלמנטים, בעוד של-HashMap אין.

שיטות מפה

הפעולות העיקריות של כל מפה הן הכנסה, הסרה וחיפוש של אלמנטים.

public Object put (מפתח אובייקט, ערך אובייקט) מכניס אלמנט למפה.
public void putAll(מפת מפה) מוסיף את המפה שצוינה בתוך המפה.
public Object remove(Object key) מוחק ערך לפי המפתח שצוין.
public Object get(Object key) מחזיר את הערך עבור המפתח שצוין.
public boolean containsKey(Object key) מחפש את המפתח שצוין ממפה זו
public Set keySet() מחזיר תצוגת Set המכילה את כל המפתחות
public Set entrySet() מחזיר תצוגת Set עם כל המפתחות והערכים.

מה זה HashMap

מה זה HashMap? זהו היישום הפופולרי ביותר של ממשק Map<Key,Value>. מבנה נתונים זה מבוסס על עקרון הגיבוב.

העיקרון העיקרי של עבודת HashMap: hashing

כדי להבין מהי hashmap וכיצד היא פועלת, בואו נדבר תחילה על פונקציות hash ו-hash. פונקציית Hash היא רק פונקציה במובן מתמטי. אז יש ערך קלט כלשהו (אובייקט, פיסת נתונים) ופונקציה ממירה אותו באמצעות כלל מתאים לערך פלט - hash. לרוב, hash הוא מספר הקסדצימלי באורך מתאים. הכללים של תהליכי המרה עשויים להיות שונים, אך הם כפופים לעקרונות הבאים:

לקלט מסוים (אובייקט) יש קוד hash מסוים.
אם שני אובייקטים שווים, גם קודי ה-hash שלהם שווים. ההיפך אינו נכון.
אם קודי ה-hash שונים, האובייקטים בהחלט אינם שווים.
לפעמים לאובייקטים שונים יכול להיות אותו קוד hash. זהו אירוע מאוד לא סביר, ששמו "התנגשות" ופונקציית Hash באיכות טובה אמורה למזער את ההסתברות להתנגשויות.

ב-Java, לכל אובייקט יש קוד hash. זה מחושב בשיטת hashCode של מחלקת Object, מחלקה אב של כל אובייקטי Java. בדרך כלל, מפתחים עוקפים שיטה זו עבור המחלקות שלהם, כמו גם שווים לשיטות הקשורות אליה.

HashMap: איך זה עובד

אז Class HashMap<K,V> שכן כל יישום מפה מורכב ממפתחות וערכים. הוא מאחסן מפתחות באמצעות עקרונות hashing. בתוך ה-HashMap צמדי מפתח-ערך מאוחסנים ב"דליים", דליים אלה בונים יחד "טבלה", מערך פנימי של רשימות מקושרות וגודלו הראשוני הוא 16 . HashMap ב-Java משתמש בקוד ה-hash של המפתח כדי לקבוע דלי שבו זוג המפתח/ערך צריך למפות: התכונה המסובכת של HashMap היא שכל תא (דלי) של הטבלה [] שומר לא רק זוג אחד אלא כמה. הם לא מאוחסנים כאובייקט מפורש (כמו LinkedList), אלא כשרשרת מרומזת. הרשת נוצרת בשל העובדה שכל זוג מאחסן קישור לזוג הבא. כלומר, כל זוגות ה-HashMap מפוזרים על פני 16 שרשראות. כאשר אתה מכניס זוג חדש לטבלה, ה-hash של המפתח נחשב. Hash זה אינו פונקציית Hashcode המובנית באובייקט המפתח. זה נחשב בטווח של 0-15. הזוג מתווסף לשרשרת הזוגות המאוחסנים בדלי עם אינדקס ה-hash. גישה זו מעניקה לנו האצת חיפוש. בזמן חיפוש זוג לפי מפתח, אין צורך לעבור על כל הטבלה. ה-hash של המפתח נחשב ורק השרשרת המאוחסנת בתא עם אינדקס ה-hash נבדקת. אם יש יותר מדי זוגות ב-HashMap, השרשראות נעשות ארוכות מדי. ואז גודל המערך גדל, ה-hash של כל האובייקטים המאוחסנים מחושב מחדש, והם מפוזרים לאורך שרשראות חדשות.

הצהרת HashMap

אם תלך לקוד HashMap של הכיתה תמצא את ההצהרה הבאה:

public class HashMap extends AbstractMap implements Map, Cloneable, Serializable

כאשר K הוא סוג המפתחות המתוחזק על ידי מפה זו ו- V - סוג הערכים הממופים. זוהי דוגמה של הצהרת HashMap עם מפתח שלם וערך מחרוזת בקוד שלך:

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

שיטות HashMap

להלן רשימת שיטות HashMap.

Object get(Object key) מחזיר את הערך עבור המפתח שצוין;
אובייקט put(Key k, Value v) מוסיף מיפוי ערך מפתח לתוך המפה;
Object remove(Object key) מסיר את המיפוי עבור המפתח שצוין ממפה זו אם קיים;
void clear() מסיר את כל צמדי המפתח-ערך מה-HashMap;
Object clone() מחזיר עותק רדוד של מופע HashMap זה מבלי לשכפל את המפתחות והערכים;
boolean containsKey(Object key) מחזירה true אם המפתח שצוין נמצא במפה, false אם לא;
boolean containsValue(Object Value) מחזירה true אם המפתח שצוין נמצא במפה, false אם לא;
boolean isEmpty() מחזירה true אם המפה ריקה, false אם לא;
Set keySet() מחזיר את ערכת המפתחות שנלקחה מהמפה;
int size() מחזירה את הכמות של מיפוי מפתח-ערך;
Collection values() מחזיר אוסף של ערכי המפה;
Object remove(Object key) מסיר את צמד המפתח-ערך עבור המפתח שצוין;
void putAll(Map m) מעתיק את כל הרכיבים של המפה למפה האחרת.

דוגמה של Java HashMap

בואו ניצור תוכנית עם Java HashMap לדוגמה כדי להדגים איך זה עובד:

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>, אך הוא מבוסס על מבנה נתוני עץ אדום-שחור. עץ מורכב מ"צמתים" וקווים המחברים צמתים - ענפים. צומת ה"שורש" נמצא בראש העץ. מהשורש יכולים להיות ענפים וצמתים. זה מבנה היררכי, אולי תחשבו עליו צמתים אלה כ"ילדים" של השורש. לצומת ילד יכולים להיות ילדים משלו - צמתים נמוכים יותר. צמתים ללא ילדים נקראים "צמתים קצה" או "עלים". עץ בינארי הוא עץ, שבו לכל צומת יש אפס, אחד , או שני ילדים. עץ החיפוש הבינארי הוא מבנה, שבו כל צומת פנימי מאחסן מפתח, ולפעמים ערך משויך, ויש לו שני תתי-עצים נבדלים ("שמאל" ו"ימין"). חיפוש בינארי המאזן את עצמו עץ הוא עץ חיפוש בינארי מבוסס צומת ששומר אוטומטית על גובהו (מספר רמות מרבי מתחת לשורש) קטן מול הוספת פריטים ומחיקות שרירותיות. עץ אדום-שחור הוא עץ בינארי מאוזן עם המאפיינים:

כל צומת הוא אדום או שחור
השורש תמיד שחור
כל עלה הוא NIL (סוג של ריק, null) צומת והוא שחור
אם צומת אדום, ילדיו הם בהחלט שחורים.
כל נתיב פשוט מצמת לעלה צאצא מכיל את אותו מספר של צמתים שחורים.

תכונות של TreeMap

TreeMap משתמש במבנה נתוני עץ כדי לאחסן את המפתחות כצמתים וממיין את המפתחות באמצעות אלגוריתם העץ האדום-שחור. אז, TreeMap שומר את הערכים שלו ממוינים לפי הסדר הטבעי של המפתחות שלו. עבור מספרים טבעי הוא סדר עולה, עבור מחרוזות - סדר אלפביתי. אתה יכול להשתמש במשוואה אם אתה צריך לשנות את ההיגיון של ההזמנה. מיון אובייקטים בצורה טבעית הוא יתרון גדול של TreeMap, כמו גם מציאת אובייקטים מסוימים באמצעות מסננים ותנאים שונים.

שיטות TreeMap

Object get(Object key) מחזיר את הערך של המפתח המתאים;
Object put(Object key, Object value) מוסיף מיפוי למפה;
Object remove(Object key) מסיר את המיפוי עבור מפתח זה אם TreeMap מכיל אותו;
boolean containsKey(Object key) מחזירה true אם המפה הזו מכילה מיפוי עבור המפתח שצוין;
boolean containsValue(Object value) מחזירה true אם TreeMap ממפה מפתח אחד או יותר לערך שצוין;
אובייקט firstKey() מחזיר את המפתח הראשון שנמצא כעת במפה הממוינת;
Object lastKey() מחזיר את המפתח האחרון שנמצא כעת במפה הממוינת;
void putAll(מפת מפה) מעתיק את כל המיפויים מהמפה שצוינה למפה;
Set entrySet() מחזיר תצוגה מוגדרת של המיפויים
int size() מחזירה את הכמות של מיפוי מפתח-ערך
Collection values() מחזיר תצוגת אוסף של הערכים
Object clone() מחזיר עותק רדוד של TreeMap
void clear() מסיר את כל המיפויים מ-TreeMap
SortedMap headMap(Object key_value) מחזיר תצוגה של החלק של המפה הקטן מהפרמטר key_value
Set keySet() מחזיר תצוגת Set של המפתחות הכלולים במפת העץ
SortedMap subMap(K fromKey, K toKey) מחזירה תצוגה של החלק של המפה הזו שהמפתחות שלו נעים בין fromKey, כולל, ל-toKey, בלעדי
אובייקט 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 ומיישם את ממשק Map, אבל מה זה קשור לרשימות מקושרות? ההצהרה של LinkedHashMap:

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

LinkedHashMap החדש הזה יורש מאפיינים מ-HashMap (כגון table, loadFactor, threshold, size, entrySet), מקבל גם שני מאפיינים מיוחדים:

header הוא ראש רשימה מקושרת כפול. במהלך האתחול, הוא מציין את עצמו
accessOrder מציין כיצד לקבל גישה לאלמנטים באמצעות איטרטור. אם נכון, לפי סדר הגישה האחרונה. אם false, הגישה תהיה בסדר שבו הרכיבים הוכנסו.

רשימה מקושרת זו מגדירה את סדר האיטרציה. בדרך כלל, זהו סדר הכנסת המפתחות למפה.

שיטות LinkedHashMap

Object get(Object key) מחזיר את הערך שאליו ממופה המפתח שצוין, או null אם המפה הזו לא מכילה מיפוי עבור המפתח
void clear() מסיר את כל המיפויים מהמפה.
boolean containsKey(Object key) מחזירה true אם האלמנט שצוין ממופה על ידי מפתח אחד או יותר
בוליאני removeEldestEntry(Map.Entry eldest) מחזירה true אם המפה מסירה את הערך הבכור שלה מהמפה
Set<Map.Entry<K,V>> entrySet() מחזיר תצוגת Set של המיפויים הכלולים במפה זו
void forEach(BiConsumer<? super K,? super V> action) מבצע את הפעולה הנתונה עבור כל ערך במפה זו עד שכל הערכים עברו עיבוד או שהפעולה גוררת חריגה.
Object getOrDefault(Object key, V defaultValue) מחזיר את הערך שאליו ממופה המפתח שצוין. אם המפה אינה מכילה מיפוי עבור המפתח מחזירה defaultValue.
Set<K> keySet() מחזיר תצוגת Set של המפתחות הכלולים במפה
בוליאני removeEldestEntry(Map.Entry<K,V> eldest) מחזירה true אם המפה הזו צריכה להסיר את הערך הבכור שלה
void replaceAll(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 שומרת על סדר ההכנסה.

מפתחות אפס:

HashMap ו-LinkedHashMap מאפשרים להחזיק מפתח null אחד.
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 לתוך linkedHashMap, נקבל את NullPointerException, אבל ב-linkedHashMap1, כאשר המפתחות הם String, נוכל לעשות זאת. מפת hash היא המימוש הטוב ביותר של מפה לשימוש כללי. הוא מספק מהירות חיפוש מקסימלית, פעולות אחסון ואחזור מהירות, אך כדאי לזכור את הסדר הכאוטי שלו. מפת hash מקושרת יורשת את יתרונות HashMap ומקבלת הזמנה למפתחות. עם זאת, הוא מכיל linkedList, שהוא יקר יחסית מבחינת זיכרון. זה איטי יותר מ-HashMap בחיפוש וקצת יותר איטי להוספה/הסרה בגלל שמירה על רשימה מקושרת. מפת עץ מאחסנת מפתחות ממוינים בסדר עולה. עם זאת, הוא מציע ביצועים כלליים גרועים יותר מאשר HashMap ו-LinkedHashMap. כדי לחזק את מה שלמדת, אנו מציעים לך לצפות בשיעור וידאו מקורס Java שלנו

קריאה נוספת:
כיצד לעדכן את הערך של מפתח קיים ב-HashMap שיטת HashMap getOrDefault ב-Java שיטת KeySet ב-java.util.Map

הערות

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION