Javassa HashMap on osa Javan kokoelmaa Java 1.2:sta lähtien. Tämä luokka löytyy osoitteesta java.util paketti. Se tarjoaa Javan karttaliittymän perustoteutuksen. Java:n HashMap tallentaa tiedot (avain, arvo) pareihin, ja voit käyttää niitä muun tyyppisen indeksin (esim. kokonaisluku) avulla. Yhtä objektia käytetään avaimena (indeksinä) toiselle objektille (arvo). Jos yrität lisätä kaksoisavaimen HashMapiin, se korvaa vastaavan avaimen elementin.
Mikä on HashMap?
Java HashMap on samanlainen kuin HashTable , mutta sitä ei ole synkronoitu. Se mahdollistaa myös nolla-avainten tallentamisen, mutta siinä saa olla vain yksi nolla-avainobjekti ja nolla-arvoja voi olla kuinka monta tahansa. Tämä luokka ei takaa kartan järjestystä. Jotta voit käyttää tätä luokkaa ja sen menetelmiä, sinun on tuotava java.util.HashMap paketti tai sen huippuluokka.
Sisällysluettelo
- Mikä on HashMap?
- Java HashMap -esimerkkejä
- HashMap-ilmoitus
- Java HashMapin hierarkia
- HashMapin luominen Javassa
- Java HashMap -konstruktorit
- Erilaisten toimintojen suorittaminen HashMapissa
- HashMapin monimutkaisuus Javassa
- HashMapin sisäinen rakenne
- Java HashMapin edut ja haitat
Java HashMap -esimerkkejä
Alla on esimerkki Java HashMap -sovelluksesta:
Java
// Java program to illustrate HashMap class> // of java.util package> // Importing HashMap class> import> java.util.HashMap;> // Main class> public> class> GFG {> >// Main driver method> >public> static> void> main(String[] args)> >{> >// Create an empty hash map by declaring object> >// of string and integer type> >HashMap map =>new> HashMap();> >// Adding elements to the Map> >// using standard put() method> >map.put(>'vishal'>,>10>);> >map.put(>'sachin'>,>30>);> >map.put(>'vaibhav'>,>20>);> >// Print size and content of the Map> >System.out.println(>'Size of map is:- '> >+ map.size());> >// Printing elements in object of Map> >System.out.println(map);> >// Checking if a key is present and if> >// present, print value by passing> >// random element> >if> (map.containsKey(>'vishal'>)) {> >// Mapping> >Integer a = map.get(>'vishal'>);> >// Printing value for the corresponding key> >System.out.println(>'value for key'> >+>' 'vishal' is:- '> + a);> >}> >}> }> |
>
java kartat
>Lähtö
Size of map is:- 3 {vaibhav=20, vishal=10, sachin=30} value for key 'vishal' is:- 10> HashMap julistus
public class HashMap extends AbstractMap implements Map, Cloneable, Serializable>
Parametrit:
Se vaatii kaksi parametria, nimittäin seuraavasti:
- Tämän kartan ylläpitämien avainten tyyppi
- Yhdistettyjen arvojen tyyppi
Huomautus: K eys ja value eivät voi olla primitiivisiä tietotyyppejä. Hashmapin avain on kelvollinen, jos se toteutuu hashCode() ja equals() -metodi , sen tulee myös olla muuttumaton (muuttumaton mukautettu objekti ), jotta hashcode ja yhtäläisyys pysyvät vakioina. Arvo hashmapissa voi olla mikä tahansa kääreluokka, mukautetut objektit, taulukot, mikä tahansa viitetyyppi tai jopa null .
Esimerkiksi : Hashmapin arvona voi olla taulukko, mutta ei avaimena.
HashMap Java-koneissa Sarjasoitavissa , Kloonattavissa , Kartta käyttöliittymät.Java HashMap laajenee AbstractMap luokkaa. Suorat alaluokat ovat LinkedHashMap ja PrinterStateReasons .
Java HashMapin hierarkia
Java HashMapin ominaisuudet
HashMap on tietorakenne, jota käytetään arvojen tallentamiseen ja hakemiseen avaimien perusteella. Jotkut hashmapin tärkeimmistä ominaisuuksista ovat:
- Nopea pääsyaika : HashMaps tarjoaa jatkuvan ajan pääsyn elementteihin, mikä tarkoittaa, että elementtien haku ja lisääminen on erittäin nopeaa, yleensä O(1)-aikaista monimutkaisuutta.
- Käyttää hajautustoimintoa : HashMaps käyttää tiivistefunktiota avainten yhdistämiseen taulukon indekseihin. Tämä mahdollistaa arvojen nopean haun avaimien perusteella.
- Tallentaa avainarvoparit: Jokainen HashMapin elementti koostuu avain-arvo-parista. Avainta käytetään siihen liittyvän arvon etsimiseen.
- Tukee nolla-avaimia ja arvoja : HashMaps sallii nolla-arvot ja avaimet. Tämä tarkoittaa, että nolla-avainta voidaan käyttää arvon tallentamiseen ja nolla-arvo voidaan liittää avaimeen.
- Ei tilattu: HashMaps-karttoja ei järjestetä, mikä tarkoittaa, että järjestys, jossa elementit lisätään karttaan, ei säily. LinkedHashMap on kuitenkin HashMapin muunnelma, joka säilyttää lisäysjärjestyksen.
- Sallii kaksoiskappaleet : HashMaps sallii päällekkäiset arvot, mutta ei päällekkäisiä avaimia. Jos päällekkäinen avain lisätään, avaimeen liittyvä edellinen arvo korvataan.
- Lanka ei ole turvallinen : HashMaps eivät ole säikeen turvallisia, mikä tarkoittaa, että jos useat säikeet käyttävät samaa hashmappia samanaikaisesti, se voi johtaa tietojen epäjohdonmukaisuuksiin. Jos kierteiden turvallisuutta vaaditaan, voidaan käyttää ConcurrentHashMapia.
- Kapasiteetti ja kuormituskerroin : HashMapsilla on kapasiteetti, joka on siinä olevien elementtien lukumäärä, ja kuormituskerroin, joka mittaa, kuinka täynnä hashmap voi olla ennen sen koon muuttamista.
HashMapin luominen Javassa
Ymmärrämme, kuinka voimme luoda HashMapin Javassa alla mainitulla esimerkillä:
Java
// Java Program to Create> // HashMap in Java> import> java.util.HashMap;> // Driver Class> public> class> ExampleHashMap {> >// main function> >public> static> void> main(String[] args) {> > >// Create a HashMap> >HashMap hashMap =>new> HashMap();> > >// Add elements to the HashMap> >hashMap.put(>'John'>,>25>);> >hashMap.put(>'Jane'>,>30>);> >hashMap.put(>'Jim'>,>35>);> > >// Access elements in the HashMap> >System.out.println(hashMap.get(>'John'>));> >// Output: 25> > >// Remove an element from the HashMap> >hashMap.remove(>'Jim'>);> > >// Check if an element is present in the HashMap> >System.out.println(hashMap.containsKey(>'Jim'>));> >// Output: false> > >// Get the size of the HashMap> >System.out.println(hashMap.size());> >// Output: 2> >}> }> |
>
>Lähtö
25 false 2>
Java HashMap -konstruktorit
HashMap tarjoaa 4 rakentajaa ja jokaisen pääsyn muokkaaja on julkinen, jotka on lueteltu seuraavasti:
- HashMap()
- HashMap (alkuperäinen kapasiteetti)
- HashMap (alkuperäinen kapasiteetti, float loadFactor)
- HashMap (karttakartta)
Nyt keskustellaan yllä olevista rakentajista yksitellen ja toteutetaan ne puhtaiden Java-ohjelmien avulla.
1. HashMap()
Se on oletuskonstruktori, joka luo HashMapin esiintymän, jonka alkukapasiteetti on 16 ja latauskerroin 0,75.
Syntaksi:
HashMap hm = new HashMap();>
Esimerkki
Java
// Java program to Demonstrate the HashMap() constructor> // Importing basic required classes> import> java.io.*;> import> java.util.*;> // Main class> // To add elements to HashMap> class> GFG {> >// Main driver method> >public> static> void> main(String args[])> >{> >// No need to mention the> >// Generic type twice> >HashMap hm1 =>new> HashMap();> >// Initialization of a HashMap using Generics> >HashMap hm2> >=>new> HashMap();> >// Adding elements using put method> >// Custom input elements> >hm1.put(>1>,>'one'>);> >hm1.put(>2>,>'two'>);> >hm1.put(>3>,>'three'>);> >hm2.put(>4>,>'four'>);> >hm2.put(>5>,>'five'>);> >hm2.put(>6>,>'six'>);> >// Print and display mapping of HashMap 1> >System.out.println(>'Mappings of HashMap hm1 are : '> >+ hm1);> >// Print and display mapping of HashMap 2> >System.out.println(>'Mapping of HashMap hm2 are : '> >+ hm2);> >}> }> |
>
>Lähtö
Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {4=four, 5=five, 6=six}> 2. HashMap (alkuperäinen kapasiteetti)
Se luo HashMap-esiintymän, jossa on a määritetty alkukapasiteetti ja kuormituskerroin 0,75.
Syntaksi:
HashMap hm = new HashMap(int initialCapacity);>
Esimerkki
Java
// Java program to Demonstrate> // HashMap(int initialCapacity) Constructor> // Importing basic classes> import> java.io.*;> import> java.util.*;> // Main class> // To add elements to HashMap> class> AddElementsToHashMap {> >// Main driver method> >public> static> void> main(String args[])> >{> >// No need to mention the> >// Generic type twice> >HashMap hm1 =>new> HashMap(>10>);> >// Initialization of a HashMap using Generics> >HashMap hm2> >=>new> HashMap(>2>);> >// Adding elements to object of HashMap> >// using put method> >// HashMap 1> >hm1.put(>1>,>'one'>);> >hm1.put(>2>,>'two'>);> >hm1.put(>3>,>'three'>);> >// HashMap 2> >hm2.put(>4>,>'four'>);> >hm2.put(>5>,>'five'>);> >hm2.put(>6>,>'six'>);> >// Printing elements of HashMap 1> >System.out.println(>'Mappings of HashMap hm1 are : '> >+ hm1);> >// Printing elements of HashMap 2> >System.out.println(>'Mapping of HashMap hm2 are : '> >+ hm2);> >}> }> |
>
>Lähtö
Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {4=four, 5=five, 6=six}> 3. HashMap (alkuperäinen kapasiteetti, float loadFactor)
Se luo HashMap-esiintymän, jolla on määritetty alkukapasiteetti ja määritetty kuormituskerroin.
Syntaksi:
HashMap hm = new HashMap(int initialCapacity, float loadFactor);>
Esimerkki
Java
// Java program to Demonstrate> // HashMap(int initialCapacity,float loadFactor) Constructor> // Importing basic classes> import> java.io.*;> import> java.util.*;> // Main class> // To add elements to HashMap> class> GFG {> >// Main driver method> >public> static> void> main(String args[])> >{> >// No need to mention the generic type twice> >HashMap hm1> >=>new> HashMap(>5>,>0>.75f);> >// Initialization of a HashMap using Generics> >HashMap hm2> >=>new> HashMap(>3>,>0>.5f);> >// Add Elements using put() method> >// Custom input elements> >hm1.put(>1>,>'one'>);> >hm1.put(>2>,>'two'>);> >hm1.put(>3>,>'three'>);> >hm2.put(>4>,>'four'>);> >hm2.put(>5>,>'five'>);> >hm2.put(>6>,>'six'>);> >// Print and display elements in object of hashMap 1> >System.out.println(>'Mappings of HashMap hm1 are : '> >+ hm1);> >// Print and display elements in object of hashMap 2> >System.out.println(>'Mapping of HashMap hm2 are : '> >+ hm2);> >}> }> |
>
>Lähtö
Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {4=four, 5=five, 6=six}> 4. HashMap (karttakartta)
Se luo HashMap-esiintymän, jolla on samat kartoitukset kuin määritetty kartta.
HashMap hm = uusi HashMap(Karttakartta);
Java
// Java program to demonstrate the> // HashMap(Map map) Constructor> import> java.io.*;> import> java.util.*;> class> AddElementsToHashMap {> >public> static> void> main(String args[])> >{> >// No need to mention the> >// Generic type twice> >Map hm1 =>new> HashMap();> >// Add Elements using put method> >hm1.put(>1>,>'one'>);> >hm1.put(>2>,>'two'>);> >hm1.put(>3>,>'three'>);> >// Initialization of a HashMap> >// using Generics> >HashMap hm2> >=>new> HashMap(hm1);> >System.out.println(>'Mappings of HashMap hm1 are : '> >+ hm1);> > >System.out.println(>'Mapping of HashMap hm2 are : '> >+ hm2);> >}> }> |
>
>Lähtö
inttostr java
Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {1=one, 2=two, 3=three}> Erilaisten toimintojen suorittaminen HashMapissa
1. Elementtien lisääminen HashMapissa Javassa
Elementin lisäämiseksi karttaan voimme käyttää laittaa() menetelmä. Lisäysjärjestys ei kuitenkaan säily Hashmappissa. Sisäisesti jokaiselle elementille luodaan erillinen tiiviste ja elementit indeksoidaan tämän tiivisteen perusteella sen tehostamiseksi.
Java
// Java program to add elements> // to the HashMap> import> java.io.*;> import> java.util.*;> class> AddElementsToHashMap {> >public> static> void> main(String args[])> >{> >// No need to mention the> >// Generic type twice> >HashMap hm1 =>new> HashMap();> >// Initialization of a HashMap> >// using Generics> >HashMap hm2> >=>new> HashMap();> >// Add Elements using put method> >hm1.put(>1>,>'Geeks'>);> >hm1.put(>2>,>'For'>);> >hm1.put(>3>,>'Geeks'>);> >hm2.put(>1>,>'Geeks'>);> >hm2.put(>2>,>'For'>);> >hm2.put(>3>,>'Geeks'>);> >System.out.println(>'Mappings of HashMap hm1 are : '> >+ hm1);> >System.out.println(>'Mapping of HashMap hm2 are : '> >+ hm2);> >}> }> |
>
>Lähtö
Mappings of HashMap hm1 are : {1=Geeks, 2=For, 3=Geeks} Mapping of HashMap hm2 are : {1=Geeks, 2=For, 3=Geeks}> 2. Elementtien muuttaminen Javan HashMapissa
Kun elementit on lisätty, jos haluamme muuttaa elementtiä, se voidaan tehdä lisäämällä elementti uudelleen laittaa() menetelmä. Koska kartan elementit indeksoidaan avaimilla, avaimen arvoa voidaan muuttaa yksinkertaisesti lisäämällä päivitetty arvo avaimelle, jota haluamme muuttaa.
Java
// Java program to change> // elements of HashMap> import> java.io.*;> import> java.util.*;> class> ChangeElementsOfHashMap {> >public> static> void> main(String args[])> >{> >// Initialization of a HashMap> >HashMap hm> >=>new> HashMap();> >// Change Value using put method> >hm.put(>1>,>'Geeks'>);> >hm.put(>2>,>'Geeks'>);> >hm.put(>3>,>'Geeks'>);> >System.out.println(>'Initial Map '> + hm);> >hm.put(>2>,>'For'>);> >System.out.println(>'Updated Map '> + hm);> >}> }> |
>
>Lähtö
Initial Map {1=Geeks, 2=Geeks, 3=Geeks} Updated Map {1=Geeks, 2=For, 3=Geeks}> 3. Elementin poistaminen Java HashMapista
Elementin poistamiseksi kartalta voimme käyttää Poista() menetelmä. Tämä menetelmä ottaa avaimen arvon ja poistaa avaimen kartoituksen tästä kartasta, jos se on kartalla.
Java
// Java program to remove> // elements from HashMap> import> java.io.*;> import> java.util.*;> class> RemoveElementsOfHashMap{> >public> static> void> main(String args[])> >{> >// Initialization of a HashMap> >Map hm> >=>new> HashMap();> >// Add elements using put method> >hm.put(>1>,>'Geeks'>);> >hm.put(>2>,>'For'>);> >hm.put(>3>,>'Geeks'>);> >hm.put(>4>,>'For'>);> >// Initial HashMap> >System.out.println(>'Mappings of HashMap are : '> >+ hm);> >// remove element with a key> >// using remove method> >hm.remove(>4>);> >// Final HashMap> >System.out.println(>'Mappings after removal are : '> >+ hm);> >}> }> |
>
>Lähtö
Mappings of HashMap are : {1=Geeks, 2=For, 3=Geeks, 4=For} Mappings after removal are : {1=Geeks, 2=For, 3=Geeks}> 4. Java HashMapin läpikäynti
Voimme käyttää Iterator-käyttöliittymää liikkuaksemme minkä tahansa kokoelmakehyksen rakenteen yli. Koska iteraattorit työskentelevät yhden tyyppisen datan kanssa, käytämme Entryä kahden erillisen tyypin ratkaisemiseen yhteensopivaan muotoon. Sitten tulostetaan HashMapin merkinnät next()-menetelmällä.
Java
// Java program to traversal a> // Java.util.HashMap> import> java.util.HashMap;> import> java.util.Map;> public> class> TraversalTheHashMap {> >public> static> void> main(String[] args)> >{> >// initialize a HashMap> >HashMap map =>new> HashMap();> >// Add elements using put method> >map.put(>'vishal'>,>10>);> >map.put(>'sachin'>,>30>);> >map.put(>'vaibhav'>,>20>);> >// Iterate the map using> >// for-each loop> >for> (Map.Entry e : map.entrySet())> >System.out.println(>'Key: '> + e.getKey()> >+>' Value: '> + e.getValue());> >}> }> |
>
>Lähtö
Key: vaibhav Value: 20 Key: vishal Value: 10 Key: sachin Value: 30>
HashMapin monimutkaisuus Javassa
HashMap tarjoaa jatkuvan aikamonimutkaisuuden perusoperaatioille, hanki ja laita, jos hash-funktio on kirjoitettu oikein ja se hajauttaa elementit oikein ämpäriin. HashMapin iterointi riippuu HashMapin kapasiteetista ja avainarvoparien määrästä. Periaatteessa se on suoraan verrannollinen kapasiteettiin + kokoon. Kapasiteetti on HashMapissa olevien kauhojen lukumäärä. Joten ei ole hyvä idea pitää suurta määrää kauhoja HashMapissa aluksi.
| menetelmät | Aika monimutkaisuus | Avaruuden monimutkaisuus |
|---|---|---|
| Elementtien lisääminen HashMapissa | O(1) | PÄÄLLÄ) |
| Elementin poistaminen HashMapista | O(1) | PÄÄLLÄ) |
| Elementin purkaminen Javasta | O(1) | PÄÄLLÄ) |
HashMapin tärkeitä ominaisuuksia
Arvon saamiseksi on tiedettävä sen avain. HashMap tunnetaan nimellä HashMap, koska se käyttää Hashing-nimistä tekniikkaa. Hashing on tekniikka suuren merkkijonon muuntamiseksi pieneksi merkkijonoksi, joka edustaa samaa merkkijonoa. Lyhyempi arvo auttaa indeksoinnissa ja nopeampia hakuja. HashSet käyttää myös HashMapia sisäisesti.
Muutamia tärkeitä HashMapin ominaisuuksia ovat:
- HashMap on osa java.util-pakettia.
- HashMap laajentaa abstraktia luokkaa AbstractMap, joka tarjoaa myös Map-käyttöliittymän epätäydellisen toteutuksen.
- Se toteuttaa myös a Kloonattavissa ja Sarjasoitavissa käyttöliittymät. K ja V yllä olevassa määritelmässä edustavat avainta ja arvoa.
- HashMap ei salli päällekkäisiä avaimia, mutta sallii päällekkäiset arvot. Tämä tarkoittaa, että yksi avain voi sisältää enintään yhden arvon, mutta useampi kuin yksi avain voi sisältää yhden arvon.
- HashMap sallii myös nolla-avaimen, mutta vain kerran ja useita nolla-arvoja.
- Tämä luokka ei takaa kartan järjestystä; etenkään se ei takaa, että järjestys pysyy muuttumattomana ajan kuluessa. Se on suunnilleen samanlainen kuin HashTable, mutta sitä ei ole synkronoitu.
HashMapin sisäinen rakenne
Sisäisesti HashMap sisältää joukon solmuja ja solmu on esitetty luokkana, joka sisältää 4 kenttää:
- int hash
- K avain
- V arvo
- Solmu seuraavaksi
Voidaan nähdä, että solmu sisältää viittauksen omaan objektiinsa. Kyseessä on siis linkitetty lista.
HashMap:
Solmu:
HashMapin suorituskyky
HashMapin suorituskyky riippuu kahdesta parametrista, jotka on nimetty seuraavasti:
- Alkukapasiteetti
- Kuormituskerroin
1. Alkukapasiteetti – Se on HashMapin kapasiteetti sen luomishetkellä (Se on ämpärien määrä, jonka HashMap voi sisältää, kun HashMap instantioidaan). Javassa se on alun perin 2^4=16, mikä tarkoittaa, että siihen mahtuu 16 avainarvoparia.
2. Kuormituskerroin – Se on kapasiteetin prosentuaalinen arvo, jonka jälkeen Hashmapin kapasiteettia lisätään (Se on kauhojen täyttöprosentti, jonka jälkeen uudelleenhajotus tapahtuu). Javassa se on oletuksena 0,75 f, mikä tarkoittaa, että uudelleentarkistus tapahtuu, kun 75 % kapasiteetista on täytetty.
3. Kynnys – Se on kuormituskertoimen ja alkukapasiteetin tulos. Javassa se on oletusarvoisesti (16 * 0,75 = 12). Toisin sanoen uudelleenhajotus tapahtuu sen jälkeen, kun HashMapiin on lisätty 12 avainarvoparia.
4. Rehashing – Se on prosessi, jossa HashMapin kapasiteetti kaksinkertaistetaan sen jälkeen, kun se saavuttaa kynnysarvonsa. Javassa HashMap jatkaa uudelleentiivistämistä (oletuksena) seuraavassa järjestyksessä – 2^4, 2^5, 2^6, 2^7, …. pian.
Jos alkuperäinen kapasiteetti pidetään korkeampana, uudelleentarkistusta ei koskaan tehdä. Mutta sen pitäminen korkeampana lisää iteroinnin aikaista monimutkaisuutta. Joten se tulisi valita erittäin fiksusti suorituskyvyn lisäämiseksi. Arvojen odotettu määrä tulee ottaa huomioon alkukapasiteettia määritettäessä. Yleisin suositeltu kuormituskerroin arvo on 0,75, mikä tarjoaa hyvän eron aika- ja tilakustannusten välillä. Kuormituskertoimen arvo vaihtelee välillä 0 ja 1.
Huomautus: Java 8:sta eteenpäin Java on alkanut käyttää Self Balancing BST:tä linkitetyn luettelon sijaan ketjutusta varten. Itsetasapainottavan bst:n etuna on, että saamme pahimmassa tapauksessa (kun jokainen näppäin kohdistuu samaan paikkaan) hakuaika on O(Log n).
Synkronoitu HashMap
Kuten kerrotaan, HashMap ei ole synkronoitu, eli useat säikeet voivat käyttää sitä samanaikaisesti. Jos useat säikeet käyttävät tätä luokkaa samanaikaisesti ja ainakin yksi säie manipuloi sitä rakenteellisesti, se on synkronoitava ulkoisesti. Se tehdään synkronoimalla jokin objekti, joka kapseloi kartan. Jos tällaista objektia ei ole, se voidaan kääriä Collections.synchronizedMap() -sovelluksen ympärille, jotta HashMap synkronoidaan ja vältetään vahingossa tapahtuva synkronointi. Kuten seuraavassa esimerkissä:
rekursio javassa
Map m = Collections.synchronizedMap(new HashMap(...));>
Nyt kartta m on synkronoitu. Tämän luokan iteraattorit ovat nopeita, jos rakennemuutoksia tehdään iteraattorin luomisen jälkeen millään tavalla paitsi iteraattorin poistomenetelmällä. Iteraattorin epäonnistuessa se heittää ConcurrentModificationExceptionin.
HashMapin sovellukset:
HashMap on pääasiassa hashoinnin toteutus. Se on hyödyllinen, kun tarvitsemme tehokasta haku-, lisäys- ja poistotoimintojen toteuttamista. Katso hajautussovellukset yksityiskohtia varten.
Menetelmät HashMapassociatessa
- K – Kartan avainten tyyppi.
- SISÄÄN – Karttaan kartoitettujen arvojen tyyppi.
| Menetelmä | Kuvaus |
|---|---|
| asia selvä() | Poistaa kaikki kartoitukset tästä kartasta. |
| klooni() | Palauttaa matalan kopion tästä HashMap-esiintymästä: itse avaimia ja arvoja ei kloonata. |
| compute(K-näppäin, BiFunction ? Super V,? laajentaa V> remapping Function) | Yrittää laskea vastaavuuden määritetylle avaimelle ja sen nykyiselle yhdistetylle arvolle (tai nolla, jos nykyistä kartoitusta ei ole). |
| computeIfAbsent(K-näppäin, funktio super K,? laajentaa V> mappingFunction) | Jos määritettyä avainta ei ole jo liitetty arvoon (tai se on kuvattu nollaan), yrittää laskea sen arvon käyttämällä annettua kuvausfunktiota ja syöttää sen tähän karttaan, ellei se ole nolla. |
| computeIfPresent(K-näppäin, BiFunction ? Super V,? laajentaa V> remapping Function) | Jos määritetyn avaimen arvo on läsnä ja ei ole nolla, yrittää laskea uuden kuvauksen avaimella ja sen nykyisellä kuvatulla arvolla. |
| sisältääKey(Objektiavain) | Palauttaa tosi, jos tämä kartta sisältää määritetyn avaimen määrityksen. |
| sisältääValue(objektin arvo) | Palauttaa tosi, jos tämä kartta yhdistää yhden tai useamman avaimen määritettyyn arvoon. |
| entrySet() | Palauttaa sarjanäkymän tämän kartan sisältämistä kartoituksista. |
| get (Objektiavain) | Palauttaa arvon, johon määritetty avain on kartoitettu, tai nollan, jos tämä kartta ei sisällä määritystä avaimelle. |
| on tyhjä() | Palauttaa tosi, jos tämä kartta ei sisällä avainarvomäärityksiä. |
| keySet() | Palauttaa tämän kartan sisältämien avainten sarjanäkymän. |
| merge(K-avain, V-arvo, BiFunction ? Super V,? laajentaa V> remapping Function) | Jos määritettyä avainta ei ole jo liitetty arvoon tai se on liitetty tyhjään, liitä se annettuun ei-nolla-arvoon. |
| put(K-avain, V-arvo) | Yhdistää määritetyn arvon määritettyyn avaimeen tässä kartassa. |
| laita kaikki (kartta m) | Kopioi kaikki määritetyn kartan kartoitukset tähän karttaan. |
| poista (objektiavain) | Poistaa määritetyn avaimen kartoituksen tästä kartasta, jos sellainen on. |
| koko() | Palauttaa tämän kartan avainarvokartoitusten määrän. |
| arvot() | Palauttaa kokoelmanäkymän tämän kartan sisältämistä arvoista. |
Luokasta java.util.AbstractMap periytyneet menetelmät
| MENETELMÄ | KUVAUS |
|---|---|
| on yhtä suuri () | Vertaa määritettyä objektia tähän karttaan tasa-arvon vuoksi. |
| hash koodin() | Palauttaa tämän kartan hash-koodin arvon. |
| toString() | Palauttaa tämän kartan merkkijonoesityksen. |
Käyttöliittymästä java.util.Map periytyneet menetelmät
| MENETELMÄ | KUVAUS |
|---|---|
| on yhtä suuri () | Vertaa määritettyä objektia tähän karttaan tasa-arvon vuoksi. |
| forEach (kaksikuluttajan toiminta) | Suorittaa annetun toiminnon jokaiselle tämän kartan merkinnälle, kunnes kaikki merkinnät on käsitelty tai toiminto tekee poikkeuksen. |
| getOrDefault(Objektiavain, V oletusarvo) | Palauttaa arvon, johon määritetty avain on yhdistetty, tai oletusarvon, jos tämä kartta ei sisällä avaimen määritystä. |
| hash koodin() | Palauttaa tämän kartan hash-koodin arvon. |
| putIfAbsent(K-avain, V-arvo) | Jos määritettyä avainta ei ole jo liitetty arvoon (tai se on kuvattu nollaan), liittää sen annettuun arvoon ja palauttaa nollan, muussa tapauksessa palauttaa nykyisen arvon. |
| poista (objektiavain, objektin arvo) | Poistaa määritetyn avaimen merkinnän vain, jos se on tällä hetkellä yhdistetty määritettyyn arvoon. |
| korvaa (K-avain, V-arvo) | Korvaa määritetyn avaimen merkinnän vain, jos se on tällä hetkellä yhdistetty johonkin arvoon. |
| korvaa (K avain, V vanha arvo, V uusi arvo) | Korvaa määritetyn avaimen merkinnän vain, jos se on tällä hetkellä yhdistetty määritettyyn arvoon. |
| korvaa kaikki (BiFunction-toiminto) | Korvaa jokaisen merkinnän arvon tuloksella, joka kutsuu kyseisessä merkinnässä annetun funktion, kunnes kaikki merkinnät on käsitelty tai funktio tekee poikkeuksen. |
Java HashMapin edut
- Nopea haku: HashMaps tarjoaa jatkuvan pääsyn elementteihin, mikä tarkoittaa, että elementtien haku ja lisääminen on erittäin nopeaa.
- Tehokas säilytystila : HashMaps käyttää hajautusfunktiota avainten yhdistämiseen taulukon indekseihin. Tämä mahdollistaa arvojen nopean haun avainten perusteella ja tehokkaan tietojen tallentamisen.
- Joustavuus : HashMaps sallii nolla-avaimet ja -arvot ja voi tallentaa minkä tahansa tietotyypin avain-arvo-pareja.
- Helppokäyttöinen : HashMapsilla on yksinkertainen käyttöliittymä ja ne voidaan helposti toteuttaa Javassa.
- Soveltuu suurille tietojoukoille : HashMaps pystyy käsittelemään suuria tietojoukkoja hidastamatta.
Java HashMapin haitat
- Tilaamaton : HashMaps-karttoja ei järjestetä, mikä tarkoittaa, että järjestys, jossa elementit lisätään karttaan, ei säily.
- Ei lankaturvallinen : HashMaps eivät ole säikeen turvallisia, mikä tarkoittaa, että jos useat säikeet käyttävät samaa hashmappia samanaikaisesti, se voi johtaa tietojen epäjohdonmukaisuuksiin.
- Suorituskyky voi heikentyä : Joissakin tapauksissa, jos hajautustoimintoa ei ole toteutettu oikein tai jos latauskerroin on liian korkea, HashMapin suorituskyky voi heikentyä.
- Monimutkaisempi kuin taulukot tai luettelot : HashMaps voi olla monimutkaisempi ymmärtää ja käyttää kuin yksinkertaiset taulukot tai luettelot, erityisesti aloittelijoille.
- Suurempi muistin käyttö : Koska HashMaps käyttää taustalla olevaa taulukkoa, ne voivat käyttää enemmän muistia kuin muut tietorakenteet, kuten taulukot tai luettelot. Tämä voi olla haitta, jos muistin käyttö on huolenaihe.
Myös Lue
- Hashmap vs Treemap
- Hashmap vs HashTable
- Viimeisimmät artikkelit Java HashMapista
Usein kysytyt kysymykset Java HashMapissa
1. Mikä on HashMap Javassa?
Java HashMap on luokka kokoelmakehyksestä, joka voi tallentaa avainarvopareja sen sisään.
2. Miksi käyttää HashMapia Javassa?
Javan HashMapia käytetään avainarvoparien tallentamiseen, joissa jokainen avain on ainutlaatuinen.
3. Mitä hyötyä HashMapista on?
HashMapia käytetään, koska se tarjoaa ominaisuuksia, kuten:
- Nopea haku
- Tehokas säilytystila
- Joustava käyttää
- Helppokäyttöinen
- Soveltuu suurille tietojoukoille