1. En uppsättning nyckel-värde-par.
I Java är en annan intressant samling (i stort sett) Map
. Ibland kallas denna datastruktur också för en ordbok.
Den liknar Set
samlingen, men den lagrar en uppsättning "par" av element snarare än en uppsättning element. Varje par i a Map
består av två element: en "nyckel" och ett "värde".
Låt oss säga att du vill att ditt program ska lagra anställdas namn och deras löner, eller dina medarbetares namn och deras ålder. Då skulle du behöva ett sådant här bord:
namn | Ålder |
---|---|
Elon | 21 |
Jeff | 22 |
Räkningen | 48 |
Warren | ? |
Varje rad innehåller ett par värden. Vi kommer att referera till namnet som parets nyckel och åldern som parets värde .
Hela uppsättningen av dessa par är vår karta ( ) Map
.
Ett pars nyckel kan vara vad som helst utom null
. Nycklar måste vara unika: en karta kan inte innehålla två identiska nycklar.
2. HashMap
klass
Klassen HashMap
är den mest populära typen av Map
samling. Å ena sidan är det väldigt likt HashSet och har alla sina metoder. Å andra sidan är det som en lista ( ArrayList
) som kan använda ord (eller något annat) som sina index.
Du kan skapa ett HashMap
med ett uttalande så här:
HashMap<KeyType, ValueType> name = new HashMap<KeyType, ValueType>();
Var KeyType
är typen av nycklar i de lagrade paren, och ValueType
är typen av värden i paren lagrade i HashMap
samlingen.
Klassen HashMap
har metoder som denna:
Metod | Beskrivning |
---|---|
|
Lägger till ( key , value ) paret i samlingen |
|
Returnerar värdet som är kopplat till en nyckel. |
|
Kontrollerar om det finns en nyckel i samlingen |
|
Kontrollerar om det finns ett värde i samlingen |
|
Tar bort ett element från samlingen |
|
Rensar samlingen och tar bort alla element |
|
Returnerar antalet nyckel-värdepar i samlingen |
|
Returnerar uppsättningen nycklar i samlingen |
|
Returnerar en uppsättning som innehåller elementen i samlingen |
|
Returnerar en uppsättning ( Set ) av alla par ( Map.Entry ) i samlingen. |
Lägga till element till enHashMap
Element läggs till i en karta som par med put()
metoden. Nyckeln skickas som det första argumentet och värdet skickas som det andra.
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 lägger till ett nyckel-värdepar, om nyckeln redan finns i samlingen, ersätts det gamla värdet med det nya värdet.
Detta beteende gör en HashMap
like till en array eller en lista vars index är ord ( String
) istället för siffror.
Nästan alla typer kan vara KeyType eller ValueType. Det finns några små ytterligare krav för KeyType, och du kommer att lära dig om dem när du studerar samlingar mer i detalj i Java Collections-uppdraget.
3. Delmängder av a HashMap
: uppsättningen nycklar
Låt oss säga att vi bara vill visa alla poster i en HashMap
på skärmen. Hur gör vi detta? För att göra detta måste vi veta hur vi går igenom alla poster i HashMap
. Detta kan göras på flera sätt.
Det enklaste sättet är att loopa över tangenterna
HashMap
poster numreras inte sekventiellt, så en slinga med en räknare fungerar inte här. Men vi kan få en uppsättning nycklar med keySet()
metoden, och du vet redan hur man itererar över en uppsättning:
Koda | Beskrivning |
---|---|
|
Slinga över tangenterna på map Hämta värdet som är associerat med nyckeln |
Metoden keySet()
returnerar en uppsättning nycklar. Du kan använda den här uppsättningen på två sätt:
Kompakt notation | Lång notation |
---|---|
|
|
4. Slinga över nyckel-värde-par
Det finns också ett mer komplicerat sätt: du kan omvandla a Map
till en uppsättning nyckel-värdepar och sedan loopa över elementen i uppsättningen, som vi redan har lärt oss.
Samlingen HashMap
har en hjälparklass som lagrar ett nyckel-värde-par. Det ser ungefär ut så här:
class Entry<KeyType, ValueType>
{
private KeyType key;
private ValueType value;
public KeyType getKey()
{
return this.key;
}
public ValueType getValue()
{
return this.value;
}
}
Resultatet av att anropa entrySet()
metoden på ett objekt blir en :HashMap<KeyType, ValueType>
Set<Entry<KeyType, ValueType>>
Set<Entry<KeyType, ValueType>> name = map.entrySet();
Här har vi den generiska Set
klassen med en typparameter, som i sin tur är en generisk typ ( Entry
) med två typparametrar.
Det är väldigt lätt för en nybörjare att bli förvirrad över detta. Men när du väl har listat ut det kan du skriva kod 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);
}
Som sagt, den här koden kan förenklas lite:
Först kan du hoppa över att skapa en separat variabel för entries
och istället anropa entrySet()
metoden direkt inuti for
slingan:
for(Map.Entry<String, Integer> pair: map.entrySet())
{
String key = pair.getKey();
Integer value = pair.getValue();
System.out.println(key + " --> " + value);
}
För det andra kan du använda den nyligen introducerade var
operatorn för att automatiskt härleda typen av nyckel-värdepar :
for(var pair: map.entrySet())
{
String key = pair.getKey();
Integer value = pair.getValue();
System.out.println(key + " --> " + value);
}
Inte illa, va?
5. Jämförelse av ArrayList
ochHashMap
A HashMap
påminner starkt om en ArrayList
som tillåter strängar (eller andra typer) att användas som index (nycklarna).
Om du använder Integer
för nycklarna i en HashMap
, så blir den ännu mer lik en ArrayList
. Låt oss jämföra:
Koda med ArrayList<String> | Koda med HashMap<Integer, String> |
---|---|
|
|
GO TO FULL VERSION