# Hvad er en Java HashMap, og hvordan bruges den?

HashMap-klassen i Java giver dig mulighed for at gemme data i nøgle-værdipar. Dette gør det ikke kun nemmere at hente og administrere en liste, men giver dig også adskillige adgangsoptioner. Vi gennemgår de vigtigste metoder her.

## Hvad er HashMaps i Java?

Der findes forskellige måder at gemme og hente data på. Hvilken type lagring der fungerer bedst, afhænger af, hvordan du har tænkt dig at bruge dataene. I mange tilfælde er Java HashMap-klassen sandsynligvis den bedste løsning. I modsætning til andre metoder gemmer denne klasse data som **nøgle-værdipar**. Det betyder, at hver nøgle tildeles nøjagtigt én værdi. Hvis du vil hente en værdi, kan du bruge den tilsvarende nøgle til at få det ønskede resultat. Nøgler og værdier kan bestå af helt forskellige datatyper, herunder strenge, tal eller andre objekter.

Java HashMap-klassen tilbyder flere fordele. Den første er, at du kan foretage en hurtig søgning inden for programmeringssproget. Nøgle-værdi-tilgangen sikrer også, at der ikke tildeles flere værdier til én nøgle, **hvilket forhindrer duplikationer**. Du kan dog tilføje det samme objekt flere gange ved hjælp af forskellige nøgler. Denne type lagrings- og søgefunktionalitet har en positiv effekt på ydeevnen sammenlignet med faste lister, som er betydeligt mindre fleksible. Dette er også en af de største fordele ved nøgle-værdi-lagre, som bruger det samme princip. I de følgende afsnit viser vi dig, hvordan du opretter og bruger Java HashMaps.

## Sådan oprettes og bruges HashMaps i Java

For at oprette en ny HashMap i Java skal du først importere klassen. For at gøre dette skal du bruge Java-kommandoen `import`. Koden ser således ud:

```java
import java.util.HashMap;
HashMap<String, String> nameOfTheHashMap = new HashMap<String, String> ();
```

De to datatyper, der er adskilt af et komma (i dette tilfælde `String, String`), er nøglen og værdien.

### Oprettelse af en ny HashMap

For bedre at forklare, hvordan Java HashMaps fungerer, har vi fundet på et simpelt eksempel. I vores eksempel har vi en liste over kunder, som en virksomhed ønsker at gemme og have adgang til når som helst. Listen indeholder hver kundes navn og et unikt kundenummer. Selvom kundenummeret (nøglen i vores eksempel) altid er unikt, er det muligt for flere kunder at have samme navn. Hver af disse kunder har dog deres eget unikke nummer. Dette nummer registreres som en heltalstype, og navnene som strenge. Sådan konfigureres dette i en Java HashMap:

```java
import java.util.HashMap;
public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> customerList = new HashMap<>();
	}
}
```

### Tilføjelse af elementer

Nu har vi Java HashMap, men den er stadig tom. For at tilføje nye nøgle-værdipar vil vi bruge metoden `put()`. Sådan fungerer det:

```java
public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> customerList = new HashMap<>();
	customerList.put (1077, "Jerry Mowry");
	customerList.put (15312, "Peter Smith");
	customerList.put (73329, "Maria Grosso");
	System.out.println(customerList);
	}
}
```

Vi bruger kommandoen `System.out.println` til at vise vores kundeliste. Resultatet skal se sådan ud:

```java
{1077=Jerry Mowry, 15312=Peter Smith, 73329=Maria Grosso}
```

### Hentning af elementer

Nu har vi oprettet en kundeliste, der kan indeholde adskillige poster. Vi ønsker også at kunne få adgang til hver enkelt kundepost individuelt. For at gøre dette overfører vi nøglen til **get()** -metoden. Her er et eksempel på, hvordan dette fungerer:

```java
public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> customerList = new HashMap<>();
	customerList.put (1077, "Jerry Mowry");
	customerList.put (15312, "Peter Smith");
	customerList.put (73329, "Maria Grosso");
	System.out.println(customerList.get(1077));
	}
}
```

Kun navnet ‘Jerry Mowry’ bør vises.

### Sletning af poster

Hvis du vil slette en post, skal du bruge metode `remove()`. Her er et eksempel på, hvordan du bruger denne metode:

```java
public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> customerList = new HashMap<>();
	customerList.put (1077, "Jerry Mowry");
	customerList.put (15312, "Peter Smith");
	customerList.put (73329, "Maria Grosso");
	customerList.remove(1077);
	System.out.println(customerList);
	}
}
```

Outputtet ser nu sådan ud:

```java
{15312=Peter Smith, 73329=Maria Grosso}
```

En anden mulighed er at slette hele listen. For at gøre dette skal du bruge metode `clear()`.

```java
public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> customerList = new HashMap<>();
	customerList.put (1077, "Jerry Mowry");
	customerList.put (15312, "Peter Smith");
	customerList.put (73329, "Maria Grosso");
	customerList.clear();
	System.out.println(customerList);
	}
}
```

Nu er det eneste output, vi får, dette:

```java
{ }
```

## Sådan bestemmes antallet af poster

Selvom vores Java HashMap er ret enkel, kan du også bruge denne klasse til at administrere større, mere komplekse projekter. Med et større projekt vil du måske gerne fastslå det nøjagtige antal poster, du har. Det vil jo trods alt være hele din kundebase. Du kan bruge `size()` til at gøre dette. Sådan gør du:

```java
public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> customerList = new HashMap<>();
	customerList.put (1077, "Jerry Mowry");
	customerList.put (15312, "Peter Smith");
	customerList.put (73329, "Maria Grosso");
	System.out.println(customerList.size());
	}
}
```

I vores eksempel udskrives tallet 3.

### Sådan vises kun nøgler eller værdier

Du kan også få en liste, der kun indeholder nøglerne eller værdierne, ved hjælp af en for-each-loop. For at hente nøgler skal du bruge metoden `keySet()`, og for værdier skal du bruge metoden `values()`. I det følgende kodeeksempel bruger vi `values()`:

```java
public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> customerList = new HashMap<>();
	customerList.put (1077, "Jerry Mowry");
	customerList.put (15312, "Peter Smith");
	customerList.put (73329, "Maria Grosso");
	for (String i : customerList.values()) {
		System.out.println(i);
		}
	}
}
```

Outputtet er:

```java
Jerry Mowry
Peter Smith
Maria Grosso
```

### Kontrol af, om en HashMap indeholder en bestemt værdi eller nøgle

Ud over at få adgang til en bestemt post kan du også kontrollere, om en post allerede findes i en Java HashMap. Du kan gøre dette ved hjælp af metoden `containsKey()` (for nøgler) og metoden `containsValue()` (for værdier). Hvis elementet er inkluderet, vil outputtet være ‘true’. Hvis elementet ikke er i HashMap, vil outputtet være ‘false’. Sådan fungerer begge metoder:

```java
public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> customerList = new HashMap<>();
	customerList.put (1077, "Jerry Mowry");
	customerList.put (15312, "Peter Smith");
	customerList.put (73329, "Maria Grosso");
	System.out.println(customerList.containsKey(15312));
	System.out.println(customerList.containsValue("Stuart Miller");
	}
}
```

Da nøglen ‘15312’ er inkluderet, men værdien ‘Stuart Miller’ ikke er det, ser resultatet sådan ud.

```java
true
false
```


This is a markdown version of: [https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/java-hashmap/](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/java-hashmap/) for AI/LLM consumption.