ה IdentityHashMap מיישם מַפָּה ממשק באמצעות Hastable שימוש בשוויון התייחסות במקום שוויון אובייקט בעת השוואת מפתחות (וערכים). מחלקה זו אינה יישום מפה למטרות כלליות. בעוד מחלקה זו מיישמת את ממשק Map היא מפרה בכוונה את החוזה הכללי של Map המחייב את השימוש בשיטת equals() בעת השוואת אובייקטים. מחלקה זו משמשת כאשר המשתמש דורש שהאובייקטים יושוו באמצעות הפניה. זה שייך ל java.util חֲבִילָה.

תכונות של IdentityHashMap

• זה עוקב אחר שוויון התייחסות במקום להשתמש בשיטת equals() הוא משתמש באופרטור ==.
• זה לא מסונכרן וחייב להיות מסונכרן חיצונית.
• איטרטורים הם זריקת כשל מהיר ConcurrentModificationException בניסיון לשנות תוך כדי איטרציה.
• מחלקה זו מספקת ביצועים בזמן קבוע עבור הפעולות הבסיסיות (קבל ו-put) בהנחה שפונקציית הגיבוב של זהות המערכת (System.identityHashCode(Object)) מפזרת אלמנטים כראוי בין הדליים. IdentityHashMap אינו משתמש בשיטת hashCode() במקום זאת הוא משתמש בשיטת System.identityHashCode() . זהו הבדל משמעותי מכיוון שכעת אתה יכול להשתמש באובייקטים הניתנים לשינוי כמפתח במפה שקוד ה-hash שלו עשוי להשתנות כאשר המיפוי מאוחסן בתוך IdentityHashMap.

הַצהָרָה:

כיתה ציבורית IdentityHashMapמרחיב את AbstractMapמיישם את מפהניתן לשכפול בסידרה 
 

כָּאן ק הוא סוג האובייקט המפתח ו V הוא הערך סוג אובייקט.

ב-Java IdentityHashMap היא מחלקה המיישמת את ממשק המפה. זה דומה למחלקה HashMap כשההבדל העיקרי הוא ש-IdentityHashMap משתמש בשוויון הפניות במקום בשוויון אובייקטים בהשוואה בין מפתחות.

בעוד HashMap משתמש בשיטת equals() כדי להשוות את המפתחות. IdentityHashMap משתמש באופרטור == כדי להשוות בין המפתחות. המשמעות היא שב-IdentityHashMap שני מפתחות נחשבים שווים אם ורק אם הם אותו אובייקט ולא שווים מבחינת תוכנם.

איך להשיג משחק יונה באנדרואיד

הנה דוגמה לאופן שבו אתה יכול להשתמש ב-IdentityHashMap ב-Java:

import java.util.IdentityHashMap; public class Example {  public static void main(String[] args) {  IdentityHashMap<String Integer> identityHashMap = new IdentityHashMap<>();  identityHashMap.put('A' 1);  identityHashMap.put(new String('A') 2);  System.out.println(identityHashMap.size()); // 2  System.out.println(identityHashMap.get('A')); // 1  } } 

תְפוּקָה;

2 

1

המחלקה IdentityHashMap ב-Java היא מימוש מבוסס טבלת גיבוב של ממשק Map המשתמשת ב-Reference-equality במקום ב-object-equality בעת השוואת מפתחות (וערכים).

יתרונות השימוש ב-IdentityHashMap על פני HashMap:

1. חיפושים מהירים יותר: מכיוון ש-IdentityHashMap משתמש ב-Reference-Equality לצורך השוואה, הוא מהיר יותר עבור חיפושים בהשוואה ל-HashMap שמשתמש ב-object-equality.
2. שימושי להשוואת מופעי אובייקט: IdentityHashMap שימושי במצבים שבהם ברצונך להשוות מופעי אובייקט ולא ערכי אובייקט.

חסרונות השימוש ב-IdentityHashMap:

1. משתמש ביותר זיכרון: IdentityHashMap משתמש ביותר זיכרון בהשוואה ל-HashMap מכיוון שהיא צריכה לאחסן את ההפניה לאובייקט.
2. לא מתאים לכל מקרי השימוש: IdentityHashMap אינה מתאימה לכל מקרי השימוש ויש להשתמש בה בזהירות מכיוון שהיא עלולה להוביל להתנהגות בלתי צפויה במצבים מסוימים.

ההיררכיה של IdentityHashMap

פונקציות מחרוזת java

זה מיישם ניתן להסדרה ניתן לשחזור מַפָּה ממשק ומרחיב מפה מופשטת מַחלָקָה.

דוּגמָה:

// Java code to demonstrate IdentityHashMap  import java.util.Map; import java.util.HashMap; import java.util.IdentityHashMap; public class IdentityHashMapExample  {  public static void main(String[] args)   {  // creating an instance of IdentityHashMap  Map<String String> ihm = new IdentityHashMap<>();  // Putting key and value pair  // in a IdentityHashMap Object  ihm.put('ihmkey''ihmvalue');   ihm.put(new String('ihmkey')'ihmvalue1');     // ihm.size() will print 2 since it   // compares the objects by reference  System.out.println('Size of IdentityHashMap--'+ihm.size());    } } 

Size of IdentityHashMap--2 

בונים של IdentityHashMap

אנחנו יכולים ליצור מופע של IdentityHashMap בשתי דרכים:

IdentityHashMap ihm = new IdentityHashMap(); (or) Map hm = new IdentityHashMap();

1. IdentityHashMap():  בונה מפת hash ריקה של זהות חדשה עם ברירת מחדל לגודל מקסימלי צפוי. 

IdentityHashMaphim = חדש IdentityHashMap();

2. IdentityHashMap(int expectedMaxSize):  בונה מפה ריקה חדשה עם הגודל המרבי הצפוי. 

IdentityHashMapihm = new IdentityHashMap(int expectedMaxSize);

3. IdentityHashMap(Map m):  בונה מפת גיבוב חדשה של זהות המכילה את מיפויי מפתח-ערך במפה שצוינה.

IdentityHashMapihm = new IdentityHashMap(Map m);

פעולות בסיסיות ב-IdentityHashMap

1. הוספת אלמנטים

כדי להוסיף או להוסיף מיפוי לתוך IdentityHashMap יש לנו לָשִׂים() ו putAll() שיטות. put() יכול להכניס מפתח ספציפי ואת הערך שהוא ממפה למפה מסוימת. אם מפתח קיים מועבר אז הערך הקודם יוחלף בערך החדש. putAll() מעתיק את כל האלמנטים, כלומר את המיפויים ממפה אחת לאחרת. 

// Java code to illustrate // adding elements to IdentityHashMap import java.util.*; public class AddingElementsToIdentityHashMap {    public static void main(String[] args)  {  // Creating an empty IdentityHashMap  Map<Integer String> identity_hash  = new IdentityHashMap<Integer String>();  // Mapping string values to int keys  // using put() method  identity_hash.put(10 'Geeks');  identity_hash.put(15 '4');  identity_hash.put(20 'Geeks');  identity_hash.put(25 'Welcomes');  identity_hash.put(30 'You');  // Displaying the IdentityHashMap  System.out.println('Initial Mappings are: '  + identity_hash);  // Inserting existing key along with new value  // previous value gets returned and stored in  // returned_value  String returned_value  = (String)identity_hash.put(20 'All');  // Verifying the returned value  System.out.println('Returned value is: '  + returned_value);  // Displaying the new map  System.out.println('New map is: ' + identity_hash);  // Creating a new Identityhash map and copying  Map<Integer String> new_Identityhash_map  = new IdentityHashMap<Integer String>();  new_Identityhash_map.putAll(identity_hash);  // Displaying the final IdentityHashMap  System.out.println('The new map: '  + new_Identityhash_map);  } } 

Initial Mappings are: {30=You 10=Geeks 15=4 25=Welcomes 20=Geeks} Returned value is: Geeks New map is: {30=You 10=Geeks 15=4 25=Welcomes 20=All} The new map: {30=You 10=Geeks 15=4 25=Welcomes 20=All} 

2. הסרת אלמנטים
כדי להסיר מיפויים אנו משתמשים לְהַסִיר() שיטה מובנית של המחלקה IdentityHashMap ומשמשת להסרת המיפוי של מפתח מסוים מהמפה.

// Java code to illustrate removing // elements from IdentityHashMap import java.util.*;  public class RemovingMappingsFromIdentityHashMap {   public static void main(String[] args)   {   // Creating an empty IdentityHashMap   Map<Integer String> Identity_hash = new  IdentityHashMap<Integer String>();     // Mapping string values to int keys   Identity_hash.put(10 'Geeks');   Identity_hash.put(15 '4');   Identity_hash.put(20 'Geeks');   Identity_hash.put(25 'Welcomes');   Identity_hash.put(30 'You');   // Displaying the IdentityHashMap   System.out.println('Initial Mappings are: ' +   Identity_hash);   // Removing the existing key mapping   String returned_value =   (String)Identity_hash.remove(20);   // Verifying the returned value   System.out.println('Returned value is: ' +   returned_value);   // Displaying the new map   System.out.println('New map is: ' + Identity_hash);   }  }  

Initial Mappings are: {30=You 10=Geeks 15=4 25=Welcomes 20=Geeks} Returned value is: Geeks New map is: {30=You 10=Geeks 15=4 25=Welcomes} 

3. גישה לאלמנטים

מצביע הפנייה ג

אנו יכולים לגשת לאלמנטים של IdentityHashMap באמצעות ה לְקַבֵּל() השיטה הדוגמה לכך ניתנת להלן.

// Java code to illustrate the accessing // elements from IdentityHashMap import java.util.*; public class AccessingElementsFromIdentityHashMap {  public static void main(String[] args)  {  // Creating an empty IdentityHashMap  Map<Integer String> identity_hash  = new IdentityHashMap<Integer String>();  // Mapping string values to int keys  identity_hash.put(10 'Geeks');  identity_hash.put(15 '4');  identity_hash.put(20 'Geeks');  identity_hash.put(25 'Welcomes');  identity_hash.put(30 'You');  // Displaying the IdentityHashMap  System.out.println('Initial Mappings are: '  + identity_hash);  // Getting the value of 25  System.out.println('The Value is: '  + identity_hash.get(25));  // Getting the value of 10  System.out.println('The Value is: '  + identity_hash.get(10));    // Using keySet() to get the set view of keys   System.out.println('The set is: ' + identity_hash.keySet());     // Using entrySet() to get the set view   System.out.println('The set is: ' +   identity_hash.entrySet());   } } 

Initial Mappings are: {30=You 10=Geeks 15=4 25=Welcomes 20=Geeks} The Value is: Welcomes The Value is: Geeks The set is: [30 10 15 25 20] The set is: [30=You 10=Geeks 15=4 25=Welcomes 20=Geeks] 

4. מעבר
אנו יכולים להשתמש בממשק Iterator כדי לעבור על כל מבנה של מסגרת האוסף. מכיוון ש-Iterators עובדים עם סוג אחד של נתונים אנו משתמשים ב-Entry< ? ? >כדי לפתור את שני הסוגים הנפרדים לפורמט תואם. לאחר מכן באמצעות שיטת next() אנו מדפיסים את האלמנטים של IdentityHashMap.

// Java code to illustrate the  // iterating over IdentityHashmap import java.util.*; public class IteratingIdentityHashMap {  public static void main(String[] args)  {  // Creating an empty IdentityHashMap  IdentityHashMap<Integer String> identity_hash  = new IdentityHashMap<Integer String>();  // Mapping string values to int keys  identity_hash.put(10 'Geeks');  identity_hash.put(15 '4');  identity_hash.put(20 'Geeks');  identity_hash.put(25 'Welcomes');  identity_hash.put(30 'You');  // Displaying the IdentityHashMap  System.out.println('Initial Mappings are: '  + identity_hash);  // Create an Iterator over the  // IdentityHashMap  Iterator<IdentityHashMap.Entry<Integer String> >  itr = identity_hash.entrySet().iterator();  // The hasNext() method is used to check if there is  // a next element The next() method is used to  // retrieve the next element  while (itr.hasNext()) {  IdentityHashMap.Entry<Integer String> entry  = itr.next();  System.out.println('Key = ' + entry.getKey()  + ' Value = '  + entry.getValue());  }  } } 

Initial Mappings are: {30=You 10=Geeks 15=4 25=Welcomes 20=Geeks} Key = 30 Value = You Key = 10 Value = Geeks Key = 15 Value = 4 Key = 25 Value = Welcomes Key = 20 Value = Geeks 

Synchronized IdentityHashMap

אם שרשורים מרובים ניגשים למפת hash של זהות במקביל ולפחות אחד מהשרשורים משנה את המפה מבחינה מבנית, יש לסנכרן אותו חיצונית. (שינוי מבני הוא כל פעולה שמוסיפה או מוחקת מיפוי אחד או יותר; עצם שינוי הערך המשויך למפתח שמופע כבר מכיל אינו שינוי מבני.) זה נעשה בדרך כלל על ידי סנכרון על אובייקט כלשהו שמכיל את המפה באופן טבעי. אם לא קיים אובייקט כזה יש 'לעטוף' את המפה באמצעות ה- Collections.synchronizedMap שִׁיטָה. הדבר נעשה בצורה הטובה ביותר בזמן היצירה כדי למנוע גישה לא מסונכרנת מקרית למפה. 

Map m = Collections.synchronizedMap(new IdentityHashMap(...));

שיטות של IdentityHashMap

ק– סוג המפתחות במפה.V– סוג הערכים הממופים במפה.

שיטות שהוכרזו במחלקה java.util.AbstractMap

שיטות המוצהרות בממשק java.util.Map

IdentityHashMap לעומת  HashMap

• IdentityHashMap משתמש באופרטור השוויון '==' להשוואת מפתחות וערכים בעוד HashMap משתמש בשיטת equals להשוואת מפתחות וערכים בתוך Map.
• מכיוון ש-IdentityHashMap לא משתמש ב-equals() זה מהיר יחסית מ-HashMap עבור אובייקט עם יקר equals().
• IdentityHashMap אינו דורש מפתחות בלתי ניתנים לשינוי מכיוון שהוא אינו מסתמך על equals().

התוכנית שלהלן ממחישה את ההבדל בין IdentityHashMap ליישום HashMap.

// Java code to demonstrate IdentityHashMap and // illustration of how it is different from HashMap  import java.util.Map; import java.util.HashMap; import java.util.IdentityHashMap; public class IdentityHashMapExample  {  public static void main(String[] args)   {  // Creating HashMap and IdentityHashMap objects  Map<String String> hm = new HashMap<>();  Map<String String> ihm = new IdentityHashMap<>();  // Putting key and value in HashMap and IdentityHashMap Object  hm.put('hmkey''hmvalue');  hm.put(new String('hmkey')'hmvalue1');   ihm.put('ihmkey''ihmvalue');   ihm.put(new String('ihmkey')'ihmvalue1');     // Print Size of HashMap and WeakHashMap Object  // hm.size() will print 1 since it compares the objects logically  // and both the keys are same  System.out.println('Size of HashMap is : '+hm.size());    // ihm.size() will print 2 since it compares the objects by reference  System.out.println('Size of IdentityHashMap is : '+ihm.size());    } } 

Size of HashMap is : 1 Size of IdentityHashMap is : 2 

IdentityHashMap היא מחלקה ב-Java המיישמת את ממשק המפה ומשתמשת בשוויון התייחסות כדי להשוות מפתחות. זה דומה ל- HashMap רגיל אבל הוא משתמש באופרטור == כדי להשוות מפתחות במקום בשיטת equals() . המשמעות היא ששני מפתחות עם אותו תוכן אך הפניות שונות לאובייקט יטופלו כמפתחות נפרדים ב-IdentityHashMap.

הנה דוגמה לשימוש ב-IdentityHashMap ב-Java:

import java.util.IdentityHashMap; public class IdentityHashMapExample {  public static void main(String[] args) {  IdentityHashMap<String Integer> map = new IdentityHashMap<>();  // Add key-value pairs to the map  String key1 = new String('key');  String key2 = new String('key');  map.put(key1 1);  map.put(key2 2);  // Get values from the map using the same and different keys  System.out.println(map.get(key1)); // Output: 1  System.out.println(map.get(key2)); // Output: 2  System.out.println(map.get(new String('key'))); // Output: null  } } 

1 2 null 

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

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

בנאי ב-java