Vi presenterar HashMap-kollektionen

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 Setsamlingen, men den lagrar en uppsättning "par" av element snarare än en uppsättning element. Varje par i a Mapbestå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:

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. HashMapklass

Klassen HashMapär den mest populära typen av Mapsamling. Å 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 HashMapmed 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 HashMapsamlingen.

Klassen HashMaphar metoder som denna:

void put(KeyType key, ValueType value)

ValueType get(KeyType key)

boolean containsKey(KeyType key)

boolean containsValue(ValueType value)

ValueType remove(KeyType key)

void clear()

int size()

Set<KeyType> keySet()

Collection<ValueType> values()

Set<Map.Entry<KeyType, ValueType>> entrySet()

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 HashMaplike till en array eller en lista vars index är ord ( String) istället för siffror.

3. Delmängder av a HashMap: uppsättningen nycklar

Låt oss säga att vi bara vill visa alla poster i en HashMappå 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

HashMapposter 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:

HashMap<String, Integer> map = new HashMap<String, Integer>();
map.put("Elon", 21);
map.put("Jeff", 22);
map.put("Bill", 48);
map.put("Warren", null);

for (String key: map.keySet())
{
   Integer value = map.get(key);
   System.out.println(key + " --> " + value);
}

Metoden keySet()returnerar en uppsättning nycklar. Du kan använda den här uppsättningen på två sätt:

for (String key: map.keySet())
{
   Integer value = map.get(key);
   System.out.println(key + " --> " + value);
}

Set<String> keys = map.keySet();

for (String key: keys)
{
   Integer value = map.get(key);
   System.out.println(key + " --> " + value);
}

4. Slinga över nyckel-värde-par

Det finns också ett mer komplicerat sätt: du kan omvandla a Maptill en uppsättning nyckel-värdepar och sedan loopa över elementen i uppsättningen, som vi redan har lärt oss.

Samlingen HashMaphar 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 Setklassen 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 entriesoch istället anropa entrySet()metoden direkt inuti forslingan:

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 varoperatorn 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 ArrayListochHashMap

A HashMappåminner starkt om en ArrayListsom tillåter strängar (eller andra typer) att användas som index (nycklarna).

Om du använder Integerför nycklarna i en HashMap, så blir den ännu mer lik en ArrayList. Låt oss jämföra:

ArrayList<String> list = new ArrayList<String>();

list.add("Greetings");
list.add("Hello");

String s = list.get(0);
list.set(0, s + "!");

for (String item: list)
{
   System.out.println(item);
}

HashMap<Integer, String> map = new HashMap<Integer, String>();

map.put(0, "Greetings");
map.put(1, "Hello");

String s = map.get(0);
map.put(0, s + "!");

for (String item: map.values())
{
   System.out.println(item);
}