Тхе ИдентитиХасхМап имплементира Мапа интерфејс користећи Хасхтабле користећи референтну једнакост уместо једнакости објеката када упоређујемо кључеве (и вредности). Ова класа није имплементација Мапе опште намене. Иако ова класа имплементира интерфејс Мапе, она намерно крши Мап-ин општи уговор који налаже коришћење методе екуалс() приликом поређења објеката. Ова класа се користи када корисник захтева да се објекти пореде преко референце. То припада јава.утил пакет.

Карактеристике ИдентитиХасхМап-а

• Следи референтну једнакост уместо да користи метод екуалс() и користи == оператор.
• Није синхронизовано и мора бити синхронизовано споља.
• Итератори су брзо бацање ЦонцуррентМодифицатионЕкцептион у покушају да се модификује током понављања.
• Ова класа обезбеђује перформансе у константном времену за основне операције (доби и стави) под претпоставком да хеш функција системског идентитета (Систем.идентитиХасхЦоде(Објецт)) правилно распршује елементе међу сегментима. ИдентитиХасхМап не користи метод хасхЦоде() уместо тога користи метод Систем.идентитиХасхЦоде(). Ово је значајна разлика јер сада можете да користите променљиве објекте као кључ у мапи чији ће се хеш код вероватно променити када се мапирање ускладишти унутар ИдентитиХасхМап-а.

Декларација:

јавна класа ИдентитиХасхМаппроширује АбстрацтМапимплементира МапСериализабле Цлонеабле 
 

Ево К је кључни тип објекта и В је вредност Тип објекта.

У Јави ИдентитиХасхМап је класа која имплементира интерфејс мапе. Слично је класи ХасхМап са главном разликом у томе што ИдентитиХасхМап користи референтну једнакост уместо једнакости објеката када упоређује кључеве.

Док ХасхМап користи метод екуалс() за упоређивање кључева, ИдентитиХасхМап користи == оператор за упоређивање кључева. То значи да се у ИдентитиХасхМап-у два кључа сматрају једнакима ако и само ако су исти објекат, а не једнаки у смислу свог садржаја.

схилпа схетти

Ево примера како можете да користите ИдентитиХасхМап у Јави:

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

Класа ИдентитиХасхМап у Јави је имплементација интерфејса Мап заснована на хеш табели која користи референтну једнакост уместо једнакости објеката када упоређује кључеве (и вредности).

Предности коришћења ИдентитиХасхМап у односу на ХасхМап:

1. Брже тражење: Пошто ИдентитиХасхМап користи референтну једнакост за поређење, брже је тражење у поређењу са ХасхМап-ом који користи једнакост објеката.
2. Корисно за поређење инстанци објеката: ИдентитиХасхМап је користан у ситуацијама у којима желите да упоредите инстанце објеката, а не вредности објеката.

Недостаци коришћења ИдентитиХасхМап-а:

1. Користи више меморије: ИдентитиХасхМап користи више меморије у поређењу са ХасхМап-ом јер треба да ускладишти референцу на објекат.
2. Није погодно за све случајеве употребе: ИдентитиХасхМап није погодан за све случајеве употребе и треба га користити са опрезом јер може довести до неочекиваног понашања у одређеним ситуацијама.

Хијерархија ИдентитиХасхМап-а

питхон програм за бинарно претраживање

То имплементира Сериализабле Цлонеабле Мапа интерфејси и проширења АбстрацтМап класе.

Пример:

// 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 ihm = new IdentityHashMap(); (or) Map hm = new IdentityHashMap();

1. ИдентитиХасхМап():  Конструише нову празну хеш мапу идентитета са подразумеваном очекиваном максималном величином. 

ИдентитиХасхМапон = нова ИдентитиХасхМап();

2. ИдентитиХасхМап(инт очекиванаМакСизе):  Конструише нову празну мапу са наведеном очекиваном максималном величином. 

ИдентитиХасхМапихм = нев ИдентитиХасхМап(инт екпецтМакСизе);

3. ИдентитиХасхМап(Мапа м):  Конструише нову хеш мапу идентитета која садржи пресликавања кључ/вредност у наведеној мапи.

ИдентитиХасхМапихм = нев ИдентитиХасхМап(Мап м);

Основне операције на ИдентитиХасхМап-у

1. Додавање елемената

Да бисте уметнули или додали мапирање у ИдентитиХасхМап који имамо стави() и ставиСве() методе. пут() може да убаци одређени кључ и вредност коју мапира у одређену мапу. Ако се проследи постојећи кључ, претходна вредност се замењује новом вредношћу. путАлл() копира све елементе, тј. пресликавања из једне мапе у другу. 

// 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. Уклањање елемената
За уклањање мапирања користимо уклони() уграђени метод класе ИдентитиХасхМап и користи се за уклањање мапирања било ког одређеног кључа са мапе.

// 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. Приступ елементима

стринг јава низ

Можемо приступити елементима ИдентитиХасхМап користећи гет() метод, пример овога је дат у наставку.

// 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. Траверсинг
Можемо да користимо интерфејс Итератор за прелазак преко било које структуре оквира колекције. Пошто итератори раде са једном врстом података, користимо Ентри< ? ? >да бисте раздвојили два одвојена типа у компатибилан формат. Затим помоћу методе нект() штампамо елементе ИдентитиХасхМап-а.

// 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 

Синцхронизед ИдентитиХасхМап

Ако више нити истовремено приступа хеш мапи идентитета и барем једна од нити структурно модификује мапу, она мора бити синхронизована споља. (Структурна модификација је свака операција која додаје или брише једно или више мапирања; само промена вредности повезане са кључем који инстанца већ садржи није структурна модификација.) Ово се обично постиже синхронизацијом на неком објекту који природно инкапсулира мапу. Ако такав објекат не постоји, мапу треба 'умотати' користећи Цоллецтионс.синцхронизедМап методом. Ово је најбоље урадити у време креирања како би се спречио случајни несинхронизовани приступ мапи. 

Мапа м = Цоллецтионс.синцхронизедМап(нев ИдентитиХасхМап(...));

Методе ИдентитиХасхМап-а

К– Тип кључева на мапи.В– Тип вредности мапираних на мапи.

Методе декларисане у класи јава.утил.АбстрацтМап

Методе декларисане у интерфејсу јава.утил.Мап

ИдентитиХасхМап вс  ХасхМап

• ИдентитиХасхМап користи оператор једнакости '==' за поређење кључева и вредности док ХасхМап користи метод једнакости за поређење кључева и вредности унутар Мапе.
• Пошто ИдентитиХасхМап не користи екуалс(), он је релативно бржи од ХасхМап-а за објекат са скупим екуалс().
• ИдентитиХасхМап не захтева да кључеви буду непроменљиви јер се не ослања на екуалс().

Програм у наставку илуструје разлику између имплементације ИдентитиХасхМап и ХасхМап.

// 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 

ИдентитиХасхМап је класа у Јави која имплементира интерфејс мапе и користи референтну једнакост за упоређивање кључева. Сличан је обичном ХасхМап-у, али користи == оператор за упоређивање кључева уместо методе екуалс(). То значи да ће се два кључа са истим садржајем али различитим референцама објеката третирати као различити кључеви у ИдентитиХасхМап-у.

Ево примера како да користите ИдентитиХасхМап у Јави:

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 

У овом примеру креирамо ИдентитиХасхМап који пресликава стринг кључеве у вредности Интегер. Додајемо два пара кључ/вредност на мапу користећи два различита Стринг објекта који имају исти садржај. Затим преузимамо вредности са мапе користећи исте и различите Стринг објекте. Открили смо да можемо да преузмемо вредности са мапе користећи два различита кључа који имају исти садржај, али не можемо да преузмемо вредност користећи Стринг објекат који има исти садржај, али је другачија референца објекта.

Имајте на уму да ИдентитиХасхМап има нешто другачије понашање од обичног ХасхМап-а и генерално је користан само у одређеним ситуацијама када је референтна једнакост важна. У већини случајева обичан ХасхМап је довољан и прикладнији.

поо