The IdentityHashMap toteuttaa Kartta käyttöliittymää käyttämällä Hashtable käyttämällä viite-yhtälöä objektien tasa-arvon sijasta avaimia (ja arvoja) vertailtaessa. Tämä luokka ei ole yleiskäyttöinen karttatoteutus. Vaikka tämä luokka toteuttaa Map-käyttöliittymän, se rikkoo tarkoituksella Mapin yleissopimusta, joka velvoittaa käyttämään equals()-metodia objektien vertailussa. Tätä luokkaa käytetään, kun käyttäjä vaatii objektien vertailua viittauksen kautta. Se kuuluu java.util paketti.

IdentityHashMapin ominaisuudet

• Se seuraa viiteyhtälöä yhtäläisen()-menetelmän sijaan, se käyttää ==-operaattoria.
• Sitä ei synkronoida, ja se on synkronoitava ulkoisesti.
• Iteraattorit ovat nopeita heittoja ConcurrentModificationException yrittää muokata iteroinnin aikana.
• Tämä luokka tarjoaa vakioaikaisen suorituskyvyn perusoperaatioille (get ja put) olettaen, että järjestelmän identiteetin hajautusfunktio (System.identityHashCode(Object)) hajottaa elementit oikein ryhmiin. IdentityHashMap ei käytä hashCode()-metodia, vaan se käyttää System.identityHashCode()-metodia. Tämä on merkittävä ero, koska nyt voit käyttää Map-avaimena muuttuvia objekteja, joiden hash-koodi todennäköisesti muuttuu, kun kartoitus tallennetaan IdentityHashMapiin.

Ilmoitus:

julkinen luokka IdentityHashMaplaajentaa AbstractMapiatoteuttaa MapSarjoitettava kloonattava 
 

Tässä K on avainobjektityyppi ja V on arvo Objektityyppi.

Javassa IdentityHashMap on luokka, joka toteuttaa Map-rajapinnan. Se on samanlainen kuin HashMap-luokka, sillä pääerona on, että IdentityHashMap käyttää viitetasa-arvoa objektien tasa-arvon sijaan avaimien vertailussa.

Vaikka HashMap käyttää equals()-menetelmää avaimien vertaamiseen, IdentityHashMap käyttää ==-operaattoria avaimien vertailuun. Tämä tarkoittaa, että IdentityHashMapissa kahta avainta pidetään samanarvoisena silloin ja vain, jos ne ovat sama objekti sen sijaan, että ne olisivat samanarvoisia sisällöltään.

mitkä kuukaudet ovat Q1

Tässä on esimerkki siitä, kuinka voit käyttää IdentityHashMapia Javassa:

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

tuotos;

2 

1

Javan IdentityHashMap-luokka on Map-käyttöliittymän hash-taulukkopohjainen toteutus, joka käyttää viitetasa-arvoa objektien tasa-arvon sijaan avaimien (ja arvojen) vertailussa.

IdentityHashMapin käytön edut HashMapiin verrattuna:

1. Nopeammat haut: Koska IdentityHashMap käyttää vertailun tasa-arvoa, se on nopeampi hauissa verrattuna HashMapiin, joka käyttää objektien tasa-arvoa.
2. Hyödyllinen objektiinstanssien vertailuun: IdentityHashMap on hyödyllinen tilanteissa, joissa haluat vertailla objektiinstanssia objektien arvojen sijaan.

IdentityHashMapin käytön haitat:

1. Käyttää enemmän muistia: IdentityHashMap käyttää enemmän muistia verrattuna HashMapiin, koska sen on tallennettava viittaus objektiin.
2. Ei sovellu kaikkiin käyttötapauksiin: IdentityHashMap ei sovellu kaikkiin käyttötapauksiin, ja sitä tulee käyttää varoen, koska se voi johtaa odottamattomaan toimintaan tietyissä tilanteissa.

IdentityHashMapin hierarkia

Se toteuttaa Sarjasoitavissa Kloonattavissa Kartta rajapintoja ja laajenee AbstractMap luokkaa.

Esimerkki:

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

IdentityHashMapin rakentajat

Voimme luoda esiintymän IdentityHashMap kahdella tavalla:

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

1. IdentityHashMap():  Muodostaa uuden tyhjän identiteetin hajautuskartan oletusarvoisella enimmäiskoolla. 

IdentityHashMaphän = uusi IdentityHashMap();

2. IdentityHashMap(int odotetaanMaxSize):  Luo uuden tyhjän kartan määritetyllä odotetulla enimmäiskoolla. 

IdentityHashMapihm = new IdentityHashMap(int odotettuMaxSize);

3. IdentityHashMap(Kartta m):  Muodostaa uuden identiteetin hajautuskartan, joka sisältää määritetyn kartan avainarvovastaukset.

IdentityHashMapihm = uusi IdentityHashMap(Kartta m);

monisäikeinen java

IdentityHashMapin perustoiminnot

1. Elementtien lisääminen

Voit lisätä tai lisätä kartoituksen IdentityHashMapiin laittaa() ja laita kaikki() menetelmiä. put() voi lisätä tietyn avaimen ja arvon, jonka se kuvaa tiettyyn karttaan. Jos olemassa oleva avain välitetään, edellinen arvo korvataan uudella arvolla. putAll() kopioi kaikki elementit eli kartoitukset kartasta toiseen. 

python-jäännösoperaattori

// 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. Elementtien poistaminen
Käytämme kartoitusten poistamiseen poistaa() IdentityHashMap-luokan sisäänrakennettu menetelmä ja sitä käytetään poistamaan minkä tahansa tietyn avaimen kartoitus kartalta.

// 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. Elementtien käyttö

Voimme käyttää IdentityHashMap-elementtejä käyttämällä saada() menetelmä esimerkki tästä on alla.

// 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. Kuljetus
Voimme käyttää Iterator-käyttöliittymää liikkuaksemme minkä tahansa kokoelmakehyksen rakenteen yli. Koska Iteraattorit työskentelevät yhden tyyppisten tietojen kanssa, käytämme Entryä< ? ? >ratkaista nämä kaksi erillistä tyyppiä yhteensopivaan muotoon. Sitten tulostamme next()-menetelmällä IdentityHashMapin elementit.

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

Synkronoitu IdentityHashMap

Jos useat säikeet käyttävät identiteetin hash-karttaa samanaikaisesti ja ainakin yksi säikeistä muokkaa karttaa rakenteellisesti, se on synkronoitava ulkoisesti. (Rakennemuutos on mikä tahansa toiminto, joka lisää tai poistaa yhden tai useamman kartoituksen. Pelkästään ilmentymän sisältämään avaimeen liittyvän arvon muuttaminen ei ole rakenteellista muutosta.) Tämä tehdään yleensä synkronoimalla karttaa luonnollisesti koteloivan objektin kanssa. Jos tällaista objektia ei ole, kartta tulee "kääriä" käyttämällä Collections.synchronizedMap menetelmä. Tämä on parasta tehdä luontihetkellä, jotta vältetään vahingossa tapahtuva synkronoimaton pääsy karttaan. 

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

IdentityHashMapin menetelmät

K– Kartan avainten tyyppi.V– Karttaan kartoitettujen arvojen tyyppi.

Luokassa java.util.AbstractMap ilmoitetut menetelmät

Käyttöliittymässä java.util.Map ilmoitetut menetelmät

IdentityHashMap vs  HashMap

• IdentityHashMap käyttää yhtäläisyysoperaattoria '==' avainten ja arvojen vertaamiseen, kun taas HashMap käyttää yhtäläisyysmenetelmää avaimien ja arvojen vertaamiseen Mapissa.
• Koska IdentityHashMap ei käytä equals():tä, se on suhteellisen nopeampi kuin HashMap objektille, jolla on kallis equals().
• IdentityHashMap ei vaadi avaimien olevan muuttumattomia, koska siihen ei vedota equals().

Alla oleva ohjelma havainnollistaa eroa IdentityHashMap- ja HashMap-toteutuksen välillä.

// 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 on Java-luokka, joka toteuttaa Map-rajapinnan ja käyttää viitetasa-arvoa avaimien vertailuun. Se on samanlainen kuin tavallinen HashMap, mutta se käyttää ==-operaattoria avaimien vertaamiseen equals()-menetelmän sijaan. Tämä tarkoittaa, että kahta avainta, joilla on sama sisältö, mutta eri objektiviittaukset, käsitellään erillisinä avaimina IdentityHashMapissa.

Tässä on esimerkki IdentityHashMapin käytöstä Javassa:

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 

Tässä esimerkissä luomme IdentityHashMapin, joka yhdistää merkkijonoavaimet kokonaislukuarvoihin. Lisäämme karttaan kaksi avainarvoparia käyttämällä kahta eri merkkijono-objektia, joilla on sama sisältö. Haemme sitten arvot kartalta käyttämällä samoja ja eri merkkijono-objekteja. Huomaamme, että voimme hakea arvoja kartasta käyttämällä kahta eri avainta, joilla on sama sisältö, mutta emme voi hakea arvoa käyttämällä merkkijono-objektia, jolla on sama sisältö mutta joka on eri objektiviittaus.

Huomaa, että IdentityHashMap käyttäytyy hieman eri tavalla kuin tavallinen HashMap ja on yleensä hyödyllinen vain tietyissä tilanteissa, joissa viitetasa-arvo on tärkeä. Useimmissa tapauksissa tavallinen HashMap on riittävä ja sopivampi.

python kirjoittaa json tiedostoon