Gentag gennem HashMap i Java
HashMap indeholder data i (nøgle, værdi) par, der kan tilgås ved hjælp af en anden indekstype. Kortgrænsefladen er implementeret af HashMap-klassen, som giver os mulighed for at gemme nøgler. Siden Java 1.2 har hashMap været en del af Java-samlingsrammerne. Internt anvender den en relativt hurtig hash-teknik.
Hvad er et HashMap i Java?
HashMap er en nøgle-værdi par opbevaringsbeholder. Hver tast svarer til en enkelt værdi.
En HashMaps nøgler skal være unikke. I andre programmeringssprog er HashMap et associativt array eller en ordbog. HashMaps bruger mere hukommelse, fordi hver værdi har en tilsvarende nøgle. Den tid det tager at slette og indsætte data er konstant. Du kan gemme nulværdier i HashMaps.
I HashMap repræsenterer en Map.entry et nøgle-værdi-par. HashMaps entrySet-metode returnerer en fast visning af kortets kortlægninger. Med keySet-metoden kan du få en liste over nøgler.
Gentag gennem HashMap i Java-eksempler
Syntaksen er som følger:
public class HashMap<K, V> extends AbstractMap<K, V> implements Map<K,V>, Clonnable, Serial
I dette eksempel lærer vi, hvordan man itererer over nøglerne, værdierne og nøgle/værdi-tilknytninger af et Java HashMap. For at følge med i dette eksempel bør du være bekendt med følgende Java-programmeringskoncepter:
- HashMap i Java
- for-hver sløjfe i Java
- Iterator-grænseflade i Java
Forskellige gennemkørselsmetoder
Vi kan iterere over nøgle- og værdiparrene, der er anført nedenfor og detaljeret som følger:
Metoder:
- Brug af en iterator
- Looping med forbedret (for hver sløjfe)
- Brug af metoden forEach()
- Generering gennem et HashMap med en for-løkke
Lad os undersøge, hvad hver af disse metoder gør, før vi bruger dem til at iterere gennem et kort:
- entrySet() – producerer en kortsamlingsvisning, hvis elementer er tegnet fra kortet. I entrySet() returneres nøglen af entry.getKey(), og værdien returneres af entry.getValue().
- keySet() – returnerer en liste over alle nøgler i dette kort.
- værdier() – returnerer en liste over alle værdierne i dette kort.
Lad os se på, hvordan disse strategier fungerer i praksis.
Brug af en iterator
Iterator er en java.util-pakkegrænseflade, der bruges til at iterere på tværs af en samling. Som et resultat er der ikke meget at sige om iteratorer, så vi vil foreslå nogle Iterator-grænseflademetoder til at krydse HashMap.
- hm.entrySet() bruges til at hente alle kortets nøgleværdi-par. Internt består et sæt af poster og butikker.
- hm.entrySet().iterator() returnerer en iterator, der fungerer som en markør og går videre fra sættets første til den sidste post.
- hmIterator.hasNext() returnerer en boolean, hvis der er et næste element i sættet.
- hmIterator.next() -Det næste element (Map.Entry) fra sættet returneres via hmIterator.next().
- mapElement.getKey() er ansvarlig for at returnere nøglen til det relaterede kort.
- mapElement.getValue() er ansvarlig for at returnere værdien af det relaterede kort.
Eksempel:Program til at gå gennem HashMap i Java
Eksempel 1:Brug af Iterator
// Importing required classes
import java.util.*;
// Main class
class Codeunderscored {
// Main driver method
public static void main(String[] args)
{
// Creating an Hashmap of string-integer pairs
// It contains student name and their marks
HashMap<String, Integer> hm
= new HashMap<String, Integer>();
// Adding mappings to above HashMap
// using put() method
hm.put("Codeunderscored", 54);
hm.put("A computer portal", 80);
hm.put("For code", 82);
// Printing all elements of HashMap
System.out.println("Created hashmap is" + hm);
// Getting an iterator
Iterator hmIterator = hm.entrySet().iterator();
// Display message only
System.out.println(
"HashMap after adding bonus marks:");
// Iterating through Hashmap and
// adding some bonus marks for every student
while (hmIterator.hasNext()) {
Map.Entry mapElement
= (Map.Entry)hmIterator.next();
int marks = ((int)mapElement.getValue() + 10);
// Printing mark corresponding to string entries
System.out.println(mapElement.getKey() + " : "+ marks);
}
}
} Eksempel 2:Klasse til iteration af HashMaps ved hjælp af en Iterator
// importing java libraries.
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
public class Iterate {
public static void main(String[] arguments) {
// creating hash_map.
Map<Integer, String> hash_map = new HashMap<Integer, String>();
// inserting value.
hash_map.put(1, "Code");
hash_map.put(2, "Underscored");
// setting up iterator.
Iterator<Entry<Integer, String>> it = hash_map.entrySet().iterator();
// iterating every set of entry in the HashMap.
while (it.hasNext()) {
Map.Entry<Integer, String> set = (Map.Entry<Integer, String>) it.next();
System.out.println(set.getKey() + " = " + set.getValue());
}
}
} Eksempel 3:Iterer gennem HashMap ved hjælp af Iterator ()
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
class Main {
public static void main(String[] args) {
// create a HashMap
HashMap<String, String> companies = new HashMap<>();
companies.put("Google", "Tech");
companies.put("Microsoft", "Tech");
companies.put("Air BNB", "Tourism");
System.out.println("HashMap: " + companies);
// create an object of Iterator
Iterator<Entry<String, String>> iterate1 = companies.entrySet().iterator();
// iterate through key/value mappings
System.out.print("Entries: ");
while(iterate1.hasNext()) {
System.out.print(iterate1.next());
System.out.print(", ");
}
// iterate through keys
Iterator<String> iterate2 = companies.keySet().iterator();
System.out.print("\nKeys: ");
while(iterate2.hasNext()) {
System.out.print(iterate2.next());
System.out.print(", ");
}
// iterate through values
Iterator<String> iterate3 = companies.values().iterator();
System.out.print("\nValues: ");
while(iterate3.hasNext()) {
System.out.print(iterate3.next());
System.out.print(", ");
}
}
} I eksemplet ovenfor gentager vi hash-kortets nøgler, værdier og nøgle/værdi-tilknytninger. For at iterere på tværs af hashmap'et brugte vi Iterator () metoden.
Her,
hasNext() returnerer sand, hvis hashmapsens næste element eksisterer.
next() – returnerer hashmapsens næste post.
Brug af hver sløjfe
Example 1: Program for Traversing through a HashMap in Java
// Using for-each Loop
// Importing required classes
import java.util.*;
// Main class
class Codeunderscored {
// Main method
public static void main(String[] args)
{
// The HashMap accepts a string and integer
// These pair Mappings are for subject name and average marks
HashMap<String, Integer> hm
= new HashMap<String, Integer>();
// Adding mappings to HashMap
// using put() method
hm.put("Python", 68);
hm.put("Programming in Java", 48);
hm.put("Object Oriented Programming", 50);
// display every element of Map above
System.out.println(" HashMap Created is:" + hm);
// show messages
System.out.println(
"The state of HashMap after the addition of the bonus marks:");
// HashMap Looping
// Using for-each loop
for (Map.Entry mapElement : hm.entrySet()) {
String key = (String)mapElement.getKey();
// Addition of bonus marks to all subjects
int value = ((int)mapElement.getValue() + 8);
// Printing the marks above that correspond to
// subject names
System.out.println(key + " : " + value);
}
}
} ForEach()-metoden
HashMaps forEach() metode blev først implementeret i Java 8. Den bruges til at iterere på tværs af hashmap. Samtidig reducerer det antallet af kodelinjer, som vist nedenfor:
Eksempel 1:Program til at krydse gennem et HashMap i Java
// Using forEach() Method
// Importing required classes
import java.util.*;
// Main class
class GFG {
// Main driver method
public static void main(String[] args)
{
// Creating an empty HashMap of string-integer
// pairs
HashMap<String, Integer> hm
= new HashMap<String, Integer>();
// Adding mappings to HashMap
// using put() method
hm.put("Python", 68);
hm.put("Programming in Java", 48);
hm.put("Object Oriented Programming", 50);
// Printing all elements of above HashMap
System.out.println("Created hashmap is" + hm);
// Display message only
System.out.println(
"HashMap after adding bonus marks:");
// Looping through HashMap and adding bonus marks
// using HashMap.forEach()
hm.forEach((k, v)
-> System.out.println(k + " : "
+ (v + 10)));
}
} Eksempel 2:Klassen bruger en forHver til at iterere gennem et HashMap
// importing libraries.
import java.util.HashMap;
import java.util.Map;
// class for iterating HashMap.
public class Iterate{
public static void main(String[] arguments) {
// creating hash_map.
Map<Integer, String> hash_map = new HashMap<Integer, String>();
// inserting sets in the hash_map.
hash_map.put(1, "Code");
hash_map.put(2, "Underscored");
// iterating it using forEach.
hash_map.forEach((key,value) -> System.out.println(key + " = " + value));
}
} Eksempel 3:Iterer gennem HashMap ved hjælp af forEach-løkken
import java.util.HashMap;
import java.util.Map.Entry;
class Main {
public static void main(String[] args) {
// Creating a HashMap
HashMap<String, String> companies = new HashMap<>();
companies.put("Google", "Tech");
companies.put("Microsoft", "Tech");
companies.put("Air BNB", "Tourism");
System.out.println("HashMap: " + companies);
// iterating through key/value mappings
System.out.print("Entries: ");
for(Entry<String, String> entry: companies.entrySet()) {
System.out.print(entry);
System.out.print(", ");
}
// iterating through keys
System.out.print("\nKeys: ");
for(String key: companies.keySet()) {
System.out.print(key);
System.out.print(", ");
}
// iterating through values
System.out.print("\nValues: ");
for(String value: companies.values()) {
System.out.print(value);
System.out.print(", ");
}
}
} Vi genererede et hashmap navngivet virksomheder i det foregående eksempel. Yderligere brugte vi forEach-løkken til at iterere gennem emnerne i hashkortet i dette tilfælde. Det er værd at bemærke, at vi gentager nøglerne, værdierne og nøgle/værdi-tilknytninger separat.
- companies.entrySet() – returnerer en liste over alle poster i en sætvisning.
- companies.keySet() returnerer et sæt visning af alle kritiske virksomheder.
- værdier() – returnerer en liste over alle værdierne i en sæt visning.
I dette eksempel brugte vi klassen Map.Entry. Den indlejrede klasse returnerer en visning af kortet.
Iteration gennem et HashMap med en for-løkke
hash_map bruges i koden nedenfor.
Funktionen entrySet() returnerer et sæt visning af de tilknyttede komponenter. Det er nu muligt at iterere nøgleværdi-par ved hjælp af operationerne getValue() og getKey().
Eksempel:klasse til iteration af HashMap i Java ved hjælp af en for-løkke
// importing library.
import java.util.HashMap;
import java.util.Map;
public class Iterate {
public static void main(String[] arguments) {
// creating HashMap.
Map<Integer, String> hash_map = new HashMap<Integer, String>();
// inserting sets.
hash_map.put(1, "code");
hash_map.put(2, "underscored");
// iterating using for loop.
for (Map.Entry<Integer, String> set : hash_map.entrySet()) {
System.out.println(set.getKey() + " = " + set.getValue());
}
}
} Brug af Stream API og Lambdas
Stream API og lambdas har været tilgængelige i Java siden version 8. Dernæst vil vi se på at bruge disse strategier til at gentage et kort.
Brug af forEach()- og Lambda-udtryk
Dette, som så mange andre ting i Java 8, viser sig at være langt mindre kompliceret end alternativerne. Vi bruger kun metoden forEach() indtil videre:
public void usingLambdaToIterate(Map<String, Integer> map) {
map.forEach((k, v) -> System.out.println((k + ":" + v)));
} Vi behøver ikke at konvertere et kort til et sæt poster i dette scenarie. Faktisk kan vi starte her for at lære mere om lambda-udtryk. Selvfølgelig kan vi gentage kortet, begyndende med tasterne:
public void usingLambdaAndKeys(Map<String, Integer> map) {
map.keySet().foreach(k -> System.out.println((k + ":" + map.get(k))));
} På samme måde kan vi bruge values()-metoden på samme måde:
public void useLambdaToIterateValues(Map<String, Integer> map) {
map.values().forEach(v -> System.out.println(("value: " + v)));
} Brug af Stream API
En af Java 8s mest bemærkelsesværdige funktioner er Stream API. Du kan også bruge denne funktion til at gå gennem et kort. En strøm er en samling af elementer fra en kilde, der kan aggregeres på sekventielle og parallelle måder. Derudover kan du bruge en samling, IO-operation eller array til at kilde data til en strøm.
Når du laver ekstra Stream-behandling, skal Stream API'en bruges; ellers er det bare en grundlæggende forEach() som nævnt ovenfor. Overvej følgende eksempel for at demonstrere, hvordan Stream API'en fungerer:
public void UseStreamAPIteration(Map<String, Integer> map) {
map.entrySet().stream()
// ... some other Stream processings
.forEach(e -> System.out.println(e.getKey() + ":" + e.getValue()));
} Metoderne keySet() og values() i Stream API'et ligner eksemplet ovenfor.
Eksempel:Brug af Stream API til HashMap Iteration
package com.codeunderscored;
import java.util.HashMap;
public class CodeHashMapStreamApi {
public static void main(String[] args) {
HashMap<String, Integer> hMap = new HashMap<>();
hMap.put("fruits", 5);
hMap.put("vegetables", 2);
hMap.put("laptops", 7);
hMap.entrySet().stream().forEach(e -> {
System.out.format("key: %s, value: %d%n", e.getKey(), e.getValue());
});
}
}
Eksemplet itererer over et HashMap, når du bruger stream API. EntrySet-funktionen returnerer indgangssættet, og streammetoden returnerer strømmen fra indgangssættet. Senere bruger vi forEach til at iterere på tværs af strømmen.
Iteration over et ArrayList-indeholdt HashMap
Lister er også anvendelige som værdier i et HashMap. I denne situation har vi brug for en ekstra løkke.
package com.codeunderscored;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class HashMapList {
public static void main(String[] args) {
Map<String, List<String>> m = new HashMap<>();
m.put("colours", Arrays.asList("red", "green", "blue"));
m.put("sizes", Arrays.asList("small", "medium", "big"));
for (Map.Entry<String, List<String>> me : m.entrySet()) {
String key = me.getKey();
List<String> values = me.getValue();
System.out.println("Key: " + key);
System.out.print("Values: ");
for (String e: values) {
System.out.printf("%s ", e);
}
System.out.println();
}
}
} Vi itererer gennem et HashMap med ArrayLists som værdier i dette eksempel. Til sløjfer bruger vi to.
Map<String, List<String>> m = new HashMap<>();
m.put("colours", Arrays.asList("red", "green", "blue"));
m.put("sizes", Arrays.asList("small", "medium", "big")); Som værdier definerer vi et HashMap ved hjælp af ArrayLists.
for (Map.Entry<String, List<String>> me : m.entrySet()) { Vi gennemgår indgangssættet med forbedret for loop. En nøglestreng og en listeværdi er tildelt hver post.
String key = me.getKey();
GetKey-metoden bruges til at hente nøglen.
List<String> values = me.getValue();
Med getValue får vi listen.
for (String e: values) {
System.out.printf("%s ", e);
} Vi itererer over listen over værdier i den indre for-løkke.
Konklusion
I denne artikel har vi set på de mange måder at iterere gennem kortets elementer i Java. Simpelthen sagt kan vi bruge entrySet(), keySet() eller values() til at udtrække indholdet af et kort (). Fordi disse alle er sæt, er iterationsprincipperne de samme for dem alle. Derudover har vi også set på Lambda-udtryk og Stream API, som kun er tilgængelige i Java 8 og nyere.
