1. Et sett med nøkkelverdi-par.
I Java er en annen interessant samling (grovt sett) Map
. Noen ganger kalles denne datastrukturen også en ordbok.
Den ligner på Set
samlingen, men den lagrer et sett med "par" av elementer i stedet for et sett med elementer. Hvert par i a Map
består av to elementer: en "nøkkel" og en "verdi".
La oss si at du vil at programmet skal lagre ansattes navn og deres lønn, eller navnene på kollegaene dine og deres alder. Da trenger du et bord som dette:
Navn | Alder |
---|---|
Elon | 21 |
Jeff | 22 |
Regning | 48 |
Warren | ? |
Hver rad inneholder et par verdier. Vi vil referere til navnet som parets nøkkel , og alderen som parets verdi .
Hele settet med disse parene er kartet vårt ( Map
).
Et pars nøkkel kan være alt unntatt null
. Nøkler må være unike: ett kart kan ikke inneholde to identiske nøkler.
2. HashMap
klasse
Klassen HashMap
er den mest populære typen Map
samling. På den ene siden ligner den veldig på HashSet og har alle sine metoder. På den annen side er det som en liste ( ArrayList
) som kan bruke ord (eller noe annet) som sine indekser.
Du kan lage en HashMap
ved å bruke en uttalelse som denne:
HashMap<KeyType, ValueType> name = new HashMap<KeyType, ValueType>();
Hvor KeyType
er typen av nøklene i de lagrede parene, og ValueType
er typen av verdiene i parene som er lagret i HashMap
samlingen.
Klassen HashMap
har metoder som dette:
Metode | Beskrivelse |
---|---|
|
Legger til ( key , value )-paret til samlingen |
|
Returnerer verdien knyttet til en nøkkel. |
|
Sjekker om det finnes en nøkkel i samlingen |
|
Sjekker om det finnes en verdi i samlingen |
|
Fjerner et element fra samlingen |
|
Tømmer samlingen, fjerner alle elementene |
|
Returnerer antall nøkkelverdi-par i samlingen |
|
Returnerer settet med nøkler i samlingen |
|
Returnerer et sett som inneholder elementene i samlingen |
|
Returnerer et sett ( Set ) av alle parene ( Map.Entry ) i samlingen. |
Legge til elementer i enHashMap
Elementer legges til et kart som par ved hjelp av put()
metoden. Nøkkelen sendes som det første argumentet, og verdien sendes som det andre.
HashMap<String, Integer> map = new HashMap<String, Integer>();
map.put("Elon", 21);
map.put("Jeff", 22);
map.put("Bill", 48);
map.put("Warren", null);
Når du legger til et nøkkel-verdi-par, hvis nøkkelen allerede finnes i samlingen, erstattes den gamle verdien med den nye verdien.
Denne oppførselen gjør en HashMap
like til en matrise eller en liste hvis indekser er ord ( String
) i stedet for tall.
Nesten alle typer kan være KeyType eller ValueType. Det er noen små tilleggskrav til KeyType, og du vil lære om dem når du studerer samlinger i større detalj i Java Collections-oppdraget.
3. Undersett av a HashMap
: settet med nøkler
La oss si at vi bare vil vise alle oppføringene i en HashMap
på skjermen. Hvordan gjør vi dette? For å gjøre dette må vi vite hvordan vi skal gå gjennom alle oppføringene i HashMap
. Dette kan gjøres på flere måter.
Den enkleste måten er å løkke over tastene
HashMap
oppføringer er ikke nummerert sekvensielt, så en løkke med en teller vil ikke fungere her. Men vi kan få et sett med nøkler ved å bruke keySet()
metoden, og du vet allerede hvordan du itererer over et sett:
Kode | Beskrivelse |
---|---|
|
Sløyfe over tastene til map Hent verdien knyttet til nøkkelen |
Metoden keySet()
returnerer et sett med nøkler. Du kan bruke dette settet på to måter:
Kompakt notasjon | Lang notasjon |
---|---|
|
|
4. Sløyfe over nøkkelverdi-par
Det er også en mer komplisert måte: du kan transformere a Map
til et sett med nøkkelverdi-par , og deretter løkke over elementene i settet, som vi allerede har lært.
Samlingen HashMap
har en hjelpeklasse som lagrer et nøkkelverdi-par. Det ser omtrent slik ut:
class Entry<KeyType, ValueType>
{
private KeyType key;
private ValueType value;
public KeyType getKey()
{
return this.key;
}
public ValueType getValue()
{
return this.value;
}
}
Resultatet av å kalle entrySet()
metoden på et objekt vil være en :HashMap<KeyType, ValueType>
Set<Entry<KeyType, ValueType>>
Set<Entry<KeyType, ValueType>> name = map.entrySet();
Her har vi den generiske Set
klassen med en typeparameter, som igjen er en generisk type ( Entry
) med to typeparametere.
Det er veldig lett for en nybegynner å bli forvirret over dette. Men når du finner ut av det, kan du skrive kode som:
HashMap<String, Integer> map = new HashMap<String, Integer>();
map.put("Elon", 21);
map.put("Jeff", 22);
map.put("Bill", 48);
map.put("Warren", null);
Set<Map.Entry<String, Integer>> entries = map.entrySet();
for(Map.Entry<String, Integer> pair: entries)
{
String key = pair.getKey();
Integer value = pair.getValue();
System.out.println(key + " --> " + value);
}
Når det er sagt, kan denne koden forenkles litt:
Først kan du hoppe over å lage en egen variabel for entries
og i stedet kalle entrySet()
metoden direkte inne i for
loopen:
for(Map.Entry<String, Integer> pair: map.entrySet())
{
String key = pair.getKey();
Integer value = pair.getValue();
System.out.println(key + " --> " + value);
}
For det andre kan du bruke den nylig introduserte var
operatoren til automatisk å utlede typen nøkkelverdi-par :
for(var pair: map.entrySet())
{
String key = pair.getKey();
Integer value = pair.getValue();
System.out.println(key + " --> " + value);
}
Ikke verst, ikke sant?
5. Sammenligning av ArrayList
ogHashMap
A HashMap
ligner sterkt på en ArrayList
som lar strenger (eller andre typer) brukes som indekser (nøklene).
Hvis du bruker Integer
for tastene i en HashMap
, så blir den enda mer lik en ArrayList
. La oss sammenligne:
Kode med ArrayList<String> | Kode med HashMap<Integer, String> |
---|---|
|
|