HashMap i Java med eksempler
Siden Java 1.2 har HashMap
HashMap kan sammenlignes med HashTable, men uden synkronisering. Det giver også mulighed for opbevaring af null-nøgler. Der bør dog kun være ét null-nøgleobjekt og et ubegrænset antal null-værdier. Denne klasse garanterer ikke rækkefølgen af kortet. Importer java.util. HashMap-pakken eller dens superklasse for at bruge denne klasse og dens metoder.
// program for illustrating the HashMap class of java.util package in Java
// First, import the HashMap class
import java.util.HashMap;
// Main class
public class Codeunderscored {
// Declaration of the Main method
public static void main(String[] args)
{
// Creation of a hash map that is empty by declaring the object
// of string and integer type
HashMap<String, Integer> hashMap = new HashMap<>();
//elements' addition to the Map using the standard method put()
hashMap.put("kane", 10);
hashMap.put("rock", 30);
hashMap.put("undertaker", 20);
// Printing the size & content of the Hash Map
System.out.println("Size of Hash Map is:- "+ hashMap.size());
// Printing the items in object of Map
System.out.println(hashMap);
// Checking for the presence of a key and, if so, printing the value using a random element
if (hashMap.containsKey("kane")) {
// Mapping
Integer aVar = hashMap.get("kane");
// Printing the value's corresponding key
System.out.println("value for key"+ " \"kane\" is:- " + aVar);
}
}
}
Syntaksen er som følger:
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable Den accepterer to parametre, som er som følger:
- Den type nøgler, som dette kort holder styr på
- De tilknyttede værdiers type
HashMap implementerer serialiserbare, kloningsbare og Map
- HashMap-konstruktører er som følger:
- HashMap har fire konstruktører, som hver har en offentlig adgangsmodifikator og er anført nedenfor:
- HashMap()
- HashMap (int initialCapacity)
- HashMap (int initialCapacity, float loadFactor)
- HashMap (kortkort)
Vi vil gennemgå hver af konstruktørerne og hvordan man bygger dem ved hjælp af rene Java-programmer.
Den første konstruktør:HashMap()
Det er standardkonstruktøren, og den genererer en HashMap-instans med en kapacitet på 16 og en belastningsfaktor på 0,75.
Syntaksen er som følger:
HashMap<K, V> hashMap = new HashMap<K, V>();
Eksempel:Program til at demonstrere, hvordan man bruger HashMap()-konstruktøren i Java
// Importing the necessary classes required
import java.io.*;
import java.util.*;
// The Primary class for adding elements to the HashMap
class Codeunderscored {
// Main static method in java
public static void main(String args[])
{
// There is absolutely no reason for mentioning the Generic type twice
HashMap<Integer, String> hashMapOne = new HashMap<>();
// Initializing the HashMap using Generics
HashMap<Integer, String> hashMapTwo = new HashMap<Integer, String>();
// Adding elements using put method
// Custom input elements
hashMapOne.put(3, "three");
hashMapOne.put(4, "four");
hashMapOne.put(5, "five");
hashMapTwo.put(7, "seven");
hashMapTwo.put(8, "eight");
hashMapTwo.put(9, "Nine");
// Print and show the mapping of HashMap 1
System.out.println("The Mappings of the HashMap hashMapOne are : "+ hashMapOne);
// Print and show the mapping of HashMap 2
System.out.println("The Mapping of the HashMap hashMapTwo are : "+ hashMapTwo);
}
} Udgangen er som følger:
The Mappings of HashMap hashMapOne are : {3=three, 4=four, 5=five}
The Mapping of HashMap hashMapTwo are : {7=seven, 8=eight, 9=nine} Anden konstruktør:HashMap(int initialCapacity)
Det genererer et HashMap-objekt med en belastningsfaktor på 0,75 og en specificeret startkapacitet. Syntaksen er som følger:
HashMap<K, V> hashMap = new HashMap<K, V>(int initialCapacity);
Eksempel:Program til demonstration af HashMap(int initialCapacity) Constructor i Java
// Importing the necessary needed classes
import java.io.*;
import java.util.*;
// The primary class to add HashMap items
class pushElementsToHashMap {
// Main driver method
public static void main(String args[])
{
//It's needless repeating the Generic type.
HashMap<Integer, String> hashMapOne = new HashMap<>(10);
// Initialization of a HashMap using Generics
HashMap<Integer, String> hashMapTwo
= new HashMap<Integer, String>(2);
// Adding elements to object of HashMap
// using put method
// HashMap One
hashMapOne.put(4, "four");
hashMapOne.put(5, "five");
hashMapOne.put(6, "six");
// HashMap Two
hashMapTwo.put(7, "seven");
hashMapTwo.put(8, "eight");
hashMapTwo.put(9, "nine");
// Print HashMap One elements
System.out.println("The Mappings of the HashMap hashMapOne are : "
+ hashMapOne);
// Print HashMap Two elements
System.out.println("The Mapping of the HashMap hashMapTwo are : "
+ hashMapTwo);
}
}
Det resulterende output er som følger:
The Mappings of the HashMap hashMapOne are: {4=four, 5=five, 6=six}
The Mapping of the HashMap hashMapTwo are: {7=seven, 8=eight, 9=nine} Den tredje konstruktør:HashMap(int initialCapacity, float loadFactor)
Det genererer en HashMap-instans med den oprindelige kapacitet og belastningsfaktor leveret. Syntaksen er som følger:
HashMap<K, V> hashMap= new HashMap<K, V>(int initialCapacity, int loadFactor);
Eksempel:Program til demonstration af HashMap(int initialCapacity,float loadFactor) Constructor i Java
// Importing the standard needed classes
import java.io.*;
import java.util.*;
// The primary class for adding elements to the HashMap
class Codeunderscored {
// Declaration of the Main driver method
public static void main(String args[])
{
// It is needless to mention the generic type a second time
HashMap<Integer, String> hashMapOne
= new HashMap<>(5, 0.75f);
// Initialization of a HashMap using Generics
HashMap<Integer, String> hashMapTwo
= new HashMap<Integer, String>(3, 0.5f);
// using the put() method to add customized input elements
// HashMap One
hashMapOne.put(4, "four");
hashMapOne.put(5, "five");
hashMapOne.put(6, "six");
// HashMap Two
hashMapTwo.put(7, "seven");
hashMapTwo.put(8, "eight");
hashMapTwo.put(9, "nine");
// Printing and showing elements in the hashMap one object
System.out.println("The Mappings of the HashMap hashMapOne are : "
+ hashMapOne);
// Printing and showing elements in the hashMap two object
System.out.println("The Mapping of HashMap the hashMapTwo are : "
+ hashMapTwo);
}
}
Det resulterende output er som følger:
The Mappings of the HashMap hashMapOne are: {4=four, 5=five, 6=six}
The Mapping of the HashMap hashMapTwo are: {7=seven, 8=eight, 9=nine} HashMap(Kortkort)
Denne metode producerer et HashMap-objekt med de samme tilknytninger som det givne kort. Syntaksen er som følger:
HashMap<K, V> hashMap = new HashMap<K, V>(Map map);
Eksempel:Program til demonstration af HashMap(Map map) Constructor i Java
import java.io.*;
import java.util.*;
class pushElementsToHashMap {
public static void main(String args[])
{
// It is needless mentioning the Generic type twice
Map<Integer, String> hashMapOne = new HashMap<>();
// Add Elements using put method
hashMapOne.put(1, "one");
hashMapOne.put(5, "five");
hashMapOne.put(10, "ten");
// Initializing the HashMap using Generics
HashMap<Integer, String> hashMapTwo
= new HashMap<Integer, String>(hashMapOne);
System.out.println("The Mappings of the HashMap hashMapOne are : "
+ hashMapOne);
System.out.println("The Mapping of the HashMap hashMapTwo are : "
+ hashMapTwo);
}
} Output
The Mappings of the HashMap hashMapOne are : {1=one, 5=five, 10=ten}
The Mapping of the HashMap hashMapTwo are : {1=one, 5=five, 10=ten} Brug af HashMap til at udføre forskellige operationer
Tilføjelse af elementer
Put()-metoden kan tilføje et element til kortet. Hashmap'et, på den anden side, holder ikke styr på indsættelsesrækkefølgen.
Internt genereres en forskellig hash for hvert element, og elementerne indekseres baseret på denne hash for at forbedre effektiviteten.
Eksempel:Program til at tilføje elementer til en given HashMap i Java
import java.io.*;
import java.util.*;
class pushElementsToHashMap {
public static void main(String args[])
{
// It is needless mentioning the Generic type twice
HashMap<Integer, String> hashMapOne = new HashMap<>();
// Initialization of a HashMap
// using Generics
HashMap<Integer, String> hashMapTwo
= new HashMap<Integer, String>();
// Add Elements using put method
hashMapOne.put(1, "Code");
hashMapOne.put(2, "Underscored");
hashMapOne.put(3, "Dotcom");
hashMapTwo.put(1, "Code");
hashMapTwo.put(2, "Underscored");
hashMapTwo.put(3, "Dotcom");
System.out.println(" The Mappings of the HashMap hashMapOne are : "
+ hashMapOne);
System.out.println("The Mapping of HashMap the hashMapTwo are : "
+ hashMapTwo);
}
}
Det resulterende output er som følger:
The Mappings of the HashMap hm1 are: {1=Code, 2=Underscored, 3=Dotcom}
The Mapping of HashMap the hm2 are: {1=Code, 2=Underscored, 3=Dotcom}
Ændring af elementer
Bare hvis vi ønsker at ændre et element, efter at det er blevet tilføjet, kan vi gøre det ved at bruge put()-metoden for at tilføje det igen. Fordi nøglerne bruges til at indeksere elementerne på kortet, kan nøglens værdi ændres ved blot at tilføje den opdaterede værdi for den nøgle, vi ønsker at ændre.
Eksempel:Program til at ændre elementerne i HashMap i Java
import java.io.*;
import java.util.*;
class ChangeElementsOfHashMap {
public static void main(String args[])
{
// Initializing the HashMap
HashMap<Integer, String> hashMapOne
= new HashMap<Integer, String>();
// Changing the specified value using the put method
hashMapOne.put(1, "Code");
hashMapOne.put(2, "Underscored");
hashMapOne.put(3, "Dotcom");
System.out.println("Initial Map " + hashMapOne);
hashMapOne.put(2, "Coding");
System.out.println("Updated Map " + hashMapOne);
}
} Fjernelse af et element
Remove()-funktionen kan slette et element fra kortet. Hvis en nøgle er til stede på kortet, tager denne funktion nøgleværdien og fjerner tilknytningen for den pågældende nøgle.
Eksempel:Program til at fjerne elementerne fra HashMap i Java
import java.io.*;
import java.util.*;
class RemovingHashMapElements{
public static void main(String args[])
{
// Initializing the HashMap
Map<Integer, String> hashMapOne
= new HashMap<Integer, String>();
// Add elements using put method
hashMapOne.put(1, "Code");
hashMapOne.put(2, "Underscored");
hashMapOne.put(3, "Dotcom");
hashMapOne.put(4, "Coding");
// Initializing the HashMap
System.out.println("The Mappings of the HashMap are : "
+ hashMapOne);
// removing the element with a key using the given remove method
hashMapOne.remove(4);
// Finalizing the HashMap
System.out.println("The respective Mappings after removal are : "
+ hashMapOne);
}
} The Mappings of the HashMap are: {1=Code, 2=Underscored, 3=Dotcom, 4=Coding}
The Mappings after removal are: {1=Code, 2=Underscored, 3=Dotcom} HashMap-gennemgang
Iterator-grænsefladen kan bruges til at udforske enhver Collection Framework-struktur. Bruger vi Entry at løse de to forskellige typer i et passende format, fordi iteratorer kun arbejder med én datatype. Elementerne i HashMap udskrives derefter ved hjælp af metoden next().
// Example: Program for traversing a Java.util.HashMap
import java.util.HashMap;
import java.util.Map;
public class HashMapTraversal {
public static void main(String[] args)
{
// initialize a HashMap
HashMap<String, Integer> hashMapOne = new HashMap<>();
// Add elements using put method
hashMapOne.put("ken", 31);
hashMapOne.put("white", 50);
hashMapOne.put("brown", 90);
// Iterate through the hash map using a for-each loop
for (Map.Entry<String, Integer> entry : hashMapOne.entrySet())
System.out.println("The key is: " + entry.getKey()
+ " The value is: " + entry.getValue());
}
} HashMaps vigtige funktioner
Der kræves en nøgle for at få adgang til en værdi. HashMap er opkaldt efter Hashing-teknikken, som den anvender. Hashing er en metode til at omdanne en lang streng til en kort streng, der repræsenterer den samme streng. En kortere værdi hjælper med indeksering og søgehastighed. Internt bruger HashSet HashMap.
HashMap har et par bemærkelsesværdige funktioner:
- Java.util-pakken inkluderer HashMap.
- HashMap er en abstrakt klasse, der udvider AbstractMap og giver en delvis implementering af kortgrænsefladen.
- Klonbare og serialiserbare grænseflader er også implementeret.
- K og V står for nøgle og værdi i den foregående formulering.
- Duplikerede nøgler er ikke tilladt i HashMap, selvom dublerede værdier er tilladt.
- En enkelt nøgle kan ikke indeholde mere end én værdi, mens flere nøgler kan indeholde en enkelt værdi.
- HashMap understøtter også null-nøgler, men kun én gang med adskillige null-værdier.
- Denne klasse giver ingen påstande om kortets arrangement, herunder at det vil forblive stabilt over tid.
- Det kan sammenlignes med HashTable, men uden synkronisering.
HashMaps interne struktur
HashMap inkluderer internt et array af noder, som hver er repræsenteret af en klasse med fire felter:
- int hash
- K-tast
- V-værdi
- Næste node
Noden indeholder en reference til sit objekt, som det kan ses. Som følge heraf er det en linket liste.
HashMaps ydeevne
HashMaps ydeevne bestemmes af to parametre, som er som følger:
- Oprindelig kapacitet
- Belastningsfaktor
Oprindelig kapacitet
Dette var HashMap's kapacitet, da det blev oprettet (Antallet af buckets et HashMap kan rumme, når HashMap'et er instantieret). Den starter som 2^4=16 i Java, hvilket betyder, at den kan indeholde 16 nøgleværdipar.
Belastningsfaktor
Dette er den procentdel af kapacitet, der vil blive hævet, efter at Hashmap-kapaciteten øges (den procentvise fyldning af buckets efter rehashing finder sted). Standardværdien i Java er 0,75f, hvilket betyder, at rehashing sker, når 75 procent af kapaciteten er fyldt.
Tærskel
Produktet af belastningsfaktoren og den indledende kapacitet er tærsklen. Det er (16 * 0,75 =12) i Java som standard. Efter indtastning af 12 nøgle-værdi-par i HashMap, sker rehashing.
Rehashing
Rehashing fordobler HashMaps kapacitet, når den har nået sin tærskel. HashMap i Java fortsætter med at genhash i følgende rækkefølge (som standard):2^4, 2^5, 2^6, 2^7 osv.
Genhaskning vil aldrig blive udført, hvis startkapaciteten holdes høj. Men at øge den øger den tidsmæssige kompleksitet af iteration. For at forbedre ydeevnen bør den vælges omhyggeligt. For at bestemme startkapaciteten skal du overveje det forventede antal værdier. Det mest populære belastningsfaktortal er 0,75, hvilket giver en rimelig balance mellem tid og pladsomkostninger. Værdien af belastningsfaktoren varierer mellem 0 og 1.
Til din information, startende med Java 8, i stedet for at bruge en sammenkædet liste til kæde, bruger Java nu Self Balancing BST. Fordelen ved selvbalancerende BST er, at vi opnår den worst-case søgetid (hvor hver nøgle er knyttet til den samme plads) O(Log n).
HashMap med synkronisering
HashMap er usynkroniseret, hvilket betyder, at mange tråde kan få adgang til det samtidigt. Ekstern synkronisering er påkrævet, hvis flere tråde besøger denne klasse samtidigt, og mindst én af dem manipulerer dens struktur. Det opnås ved at synkronisere et kortindkapslende objekt. Det kan pakkes rundt om samlinger, hvis der ikke findes et sådant objekt. For at gøre HashMap synkroniseret og undgå utilsigtet adgang, brug synchronizedMap(). Overvej følgende scenarie:
Map m = Collections.synchronizedMap(new HashMap(...));
Kort m er nu blevet synkroniseret. Hvis der foretages en strukturel ændring efter oprettelsen af iteratoren, undtagen gennem iteratorens fjernelsesmetode, er iteratorer af denne klasse fejlhurtige. Det vil kaste ConcurrentModificationException, hvis iteratoren fejler.
HashMaps tidskompleksitet
Hvis hash-funktionen er korrekt opbygget, og indholdet er fordelt jævnt over hele spandene, giver HashMap konstant tidskompleksitet til simple operationer som f.eks. at hente og sætte.
Iteration over HashMap er begrænset af HashMaps kapacitet og mængden af nøgleværdi-par. I det væsentlige er det proportionalt med kapaciteten + størrelsen. I HashMap refererer kapacitet til antallet af spande. Som følge heraf er det ikke en god idé at have mange buckets i HashMap i starten.
HashMaps applikationer
HashMap er primært en hashing-implementering. Det er praktisk, når vi hurtigt skal implementere søge-, indsæt- og slettehandlinger.
HashMaps metoder
K – henviser til den slags taster på kortet.
V – henviser til den slags værdier, der er kortlagt i det givne kort.
Ryd()
Dette korts tilknytninger fjernes fuldstændigt ved hjælp af denne metode.
Klon()
Denne HashMap-instans returneres som en overfladisk kopi; nøglerne og værdierne duplikeres ikke.
compute(K keyVal, codeFunction rMappingFunction)
Beregner en tilknytning mellem den angivne nøgle og dens aktuelle tilknyttede værdi (eller null, hvis der ikke er nogen aktuel tilknytning).
computeIfPresent(K keyVal, codeFunction rMappingFunction)
Hvis den angivne nøgles værdier er til stede og ikke er nul, forsøger man at generere en ny mapping givet nøglen og dens eksisterende tilknyttede værdi.
containsKey(Objektnøgle)
Hvis dette kort har en tilknytning til den medfølgende nøgle, returnerer den sand.
containsValue(Objektværdi)
Hvis dette kort ved en tilfældighed knytter sig til en eller flere nøgler til den angivne værdi, returnerer det sandt.
entrySet()
Denne metode er ansvarlig for at returnere en Set-visning af tilknytningerne på dette kort.
get(Objektnøgle)
Returnerer den værdi, som den leverede nøgle er knyttet til, eller null, hvis der ikke findes nogen tilknytning til nøglen i dette kort.
computeIfAbsent(K keyVal, Function mappingFunction)
Forsøg på at beregne værdien af den leverede nøgle ved hjælp af den givne kortlægningsfunktion og indtaster den i dette kort, hvis den ikke allerede er forbundet med en værdi (eller er kortlagt til null).
IsEmpty()
Hvis dette kort ikke har nogen nøgleværdi-tilknytninger, returnerer det sandt.
keySet()
Denne metode er ansvarlig for at returnere en Set-visning af nøglerne på dette kort.
merge(K keyVal, V valueVal, BiFunction remappingFunction)
Knytter den angivne nøgle til den givne ikke-null-værdi, hvis den ikke allerede er knyttet til en værdi eller er null.
put(K-tast, V-værdi)
Dette kort knytter den leverede værdi til den angivne nøgle.
putAll(Map m)
Alle kortlægninger fra det angivne kort kopieres til dette kort.
fjern(Objektnøgle)
Hvis der findes en tilknytning til den medfølgende nøgle i dette kort, fjernes den.
Størrelse()
Den er ansvarlig for at returnere antallet af nøgleværdi-tilknytninger i dette kort.
Værdier()
Denne metode returnerer en samlingsvisning af værdierne i dette kort.
Metoder, der er blevet nedarvet fra klassen java.util.AbstractMap
lig med()
Kontrollerer lighed mellem det angivne objekt og dette kort.
hashCode()
Metoden er ansvarlig for at returnere hash-kodeværdien for dette kort.
toString()
Metoden toString() er ansvarlig for at returnere dette korts strengrepræsentation.
Metoder, der er blevet nedarvet fra java.util.Map-grænsefladen
lig med()
Kontrollerer lighed mellem det angivne objekt og dette kort.
forEach(BiConsumer handling)
Udfører den medfølgende handling for hver post i dette kort, indtil handlingen giver en undtagelse. Eller alle poster er blevet behandlet.
getOrDefault(Objektnøgle, V defaultValue)
Returnerer den værdi, som den leverede nøgle er knyttet til, eller defaultValue, hvis der ikke findes nogen tilknytning til nøglen i dette kort.
hashCode()
Det returnerer hash-kodeværdien for dette kort.
putIfAbsent(K-nøgle, V-værdi)
Hvis den angivne nøgle ikke allerede har en værdi (eller er knyttet til null), er den knyttet til den givne værdi og returnerer null; ellers returnerer den den aktuelle værdi.
fjern(Objektnøgle, Objektværdi)
Indtastningen fjernes, hvis den medfølgende nøgle i øjeblikket er knyttet til den angivne værdi.
erstat (K-tast, V-værdi)
Den erstattes kun, hvis den angivne nøgle i øjeblikket er knyttet til en værdi.
erstat (K-tast, V oldValue, V newValue)
Hvis den angivne nøgle i øjeblikket er knyttet til den angivne værdi, erstattes den.
replaceAll(codeFunction-funktionen)
Erstat værdien af hver post med resultatet af at køre den medfølgende funktion på denne post, indtil alle poster er blevet behandlet. Eller funktionen giver en fejl.
Eksempel:HashMap i Java
import java.util.*;
public class CodeHashMap{
public static void main(String args[]){
HashMap<Integer,String> hashMap=new HashMap<Integer,String>();//Creating HashMap
hashMap.put(1,"Apple"); //Add items in hashMap
hashMap.put(2,"Amazon");
hashMap.put(3,"Google");
hashMap.put(4,"Yahoo");
hashMap.put(5,"Twitter");
hashMap.put(6,"Uber");
hashMap.put(7,"DELL");
System.out.println("Iterating through the Hashmap");
for(Map.Entry m : hashMap.entrySet()){
System.out.println(m.getKey()+" "+m.getValue());
}
}
}
Vi gemmer heltal som nøglen og streng som værdien i dette eksempel. Således er typen HashMap
For at få en forekomst af Map.Entry skal vi bruge kortgrænsefladens entrySet()-metode.
Eksempel:HashMap har ingen duplikerede nøgler
HashMap tillader ikke, at duplikerede nøgler gemmes. Hvis du forsøger at gemme en dubletnøgle med en anden værdi, vil værdien blive erstattet.
import java.util.*;
public class HashMapExample2{
public static void main(String args[]){
HashMap<Integer,String> map=new HashMap<Integer,String>();//Creating HashMap
hashMap.put(1,"Apple"); //Add items in hashMap
hashMap.put(2,"Amazon");
hashMap.put(3,"Google");
hashMap.put(4,"Yahoo");
hashMap.put(5,"Twitter");
hashMap.put(6,"Uber");
hashMap.put(7,"DELL");
hashMap.put(1,"IBM"); //trying to create a duplicate key
System.out.println("Iterating through the Hashmap");
for(Map.Entry m : hashMap.entrySet()){
System.out.println(m.getKey()+" "+m.getValue());
}
}
}
Eksempel:Tilføjelse af komponenter til et Java HashMap
Forskellige tilgange til at tilføje elementer til et HashMap i Java er vist her.
import java.util.*;
class CodeHashMap{
public static void main(String args[]){
HashMap<Integer,String> hashMap=new HashMap<Integer,String>();
System.out.println("The initial item's list : "+hashMap);
hashMap.put(230,"Ken");
hashMap.put(240,"Mike");
hashMap.put(250,"White");
System.out.println("Results after invoking the put() method ");
for(Map.Entry m:hashMap .entrySet()){
System.out.println(m.getKey()+" "+m.getValue());
}
hashMap.putIfAbsent(260, "Joy");
System.out.println("Results proceeding invoking putIfAbsent() method ");
for(Map.Entry m:hashMap .entrySet()){
System.out.println(m.getKey()+" "+m.getValue());
}
HashMap<Integer,String> hashMapTwo=new HashMap<Integer,String>();
hashMapTwo.put(270,"Brown");
hashMapTwo.putAll(hashMap);
System.out.println(" Results following invoking putAll() method ");
for(Map.Entry m:hashMapTwo .entrySet()){
System.out.println(m.getKey()+" "+m.getValue());
}
}
} Eksempel:Fjernelse af poster fra et Java HashMap
Forskellige metoder til at fjerne genstande er vist her.
import java.util.*;
public class CodeHashMap {
public static void main(String args[]) {
HashMap<Integer,String> hashMap=new HashMap<Integer,String>();
hashMap.put(230,"Ken");
hashMap.put(240,"Mike");
hashMap.put(250,"White");
hashMap.put(260, "Brown");
System.out.println(" The original list of elements is as follows: "+hashMap);
//key-based removal
hashMap.remove(230);
System.out.println(" The resultant updated list of elements: "+hashMap);
//value-based removal
hashMap.remove(240);
System.out.println("The new updated list of elements: "+hashMap);
//key-value pair based removal
hashMap.remove(260, "Brown");
System.out.println("The resulting updated list of elements: "+hashMap);
}
} Eksempel:Erstat() elementer i et Java HashMap
Forskellige tilgange til at erstatte genstande er som følger:
import java.util.*;
class CodeHashMap{
public static void main(String args[]){
HashMap<Integer,String> hashMap=new HashMap<Integer,String>();
hashMap.put(230,"Ken");
hashMap.put(240,"Mike");
hashMap.put(250,"White");
hashMap.put(260, "Brown");
System.out.println(" The original element's list is:");
for(Map.Entry m:hashMap.entrySet())
{
System.out.println(m.getKey()+" "+m.getValue());
}
System.out.println("The new updated list of elements:");
hashMap.replace(240, "Joy");
for(Map.Entry m:hashMap .entrySet())
{
System.out.println(m.getKey()+" "+m.getValue());
}
System.out.println("The resultant refreshed list of elements:");
hm.replace(230, "Rock", "Undertaker");
for(Map.Entry m:hashMap.entrySet())
{
System.out.println(m.getKey()+" "+m.getValue());
}
System.out.println("The new resultant list of elements:");
hashMap.replaceAll((k,v) -> "Bright");
for(Map.Entry m:hashMap .entrySet())
{
System.out.println(m.getKey()+" "+m.getValue());
}
}
} Eksempel:Forskellen mellem HashSet og HashMap
HashSet indeholder kun værdier, hvorimod HashMap kun indeholder poster (nøgle og værdi).
import java.util.*;
class Laptop {
int id;
String name,owner,manufacturer;
int count;
public Laptop(int id, String name, String owner, String manufacturer, int count) {
this.id = id;
this.name = name;
this.owner = owner;
this.manufacturer = manufacturer;
this. count = count;
}
}
public class CodeHashMap {
public static void main(String[] args) {
//Creating map of Laptops
Map<Integer,Laptop> hashMap=new HashMap<Integer,Laptop>();
//Creating Laptops
Laptop laptopOne=new Laptop(1,"Lenovo","Tyson","Lenovo",2);
Laptop laptopTwo=new Laptop(2,"HP","James","HP",1);
Laptop laptopThree=new Laptop(3,"DELL","Green","DELL",3);
//Adding Laptops to a hash map
hashMap.put(1,laptopOne);
hashMap.put(2,laptopTwo);
hashMap.put(3,laptopThree);
//how to traverse the map
for(Map.Entry<Integer, Laptop> entry:map.entrySet()){
int key=entry.getKey();
Laptop laptop=entry.getValue();
System.out.println(key+" Details:");
System.out.println(laptop .id+" "+laptop.name+" "+laptop.owner+" "+laptop.manufacturer+" "+laptop.count);
}
}
} Konklusion
Kortgrænsefladen i Java er implementeret af HashMap-klassen, som giver os mulighed for at gemme nøgleværdi-par med unikke nøgler. Forsøg på at indsætte en dubletnøgle får den tilsvarende nøgles element til at blive overskrevet. Nøgleindekset gør opdatering, fjernelse og andre handlinger nemmere.
HashMap-klassen findes i pakken java.util. I Java ligner HashMap Hashtable. Det er dog ikke synkroniseret. Det giver os også mulighed for at gemme null-elementer, selvom der kun skal bruges én null-nøgle. HashMap
