# Hva er en Java HashMap og hvordan bruker man den?

HashMap-klassen i Java lar deg lagre data i nøkkel-verdipar. Dette gjør det ikke bare enklere å hente frem og administrere en liste, men gir deg også en rekke tilgangsmuligheter. Her går vi gjennom de viktigste metodene.

## Hva er HashMaps i Java?

Det finnes ulike måter å lagre og hente data på. Hvilken type lagring som fungerer best, avhenger av hvordan du har tenkt å bruke dataene. I mange tilfeller er Java HashMap-klassen sannsynligvis den beste løsningen. I motsetning til andre metoder lagrer denne klassen data som **nøkkel-verdipar**. Dette betyr at hver nøkkel tildeles nøyaktig én verdi. Hvis du vil hente en verdi, kan du bruke den tilhørende nøkkelen for å få det resultatet du er ute etter. Nøkler og verdier kan bestå av helt forskjellige datatyper, inkludert strenger, tall eller andre objekter.

Java HashMap-klassen har flere fordeler. Den første er at du kan utføre en rask søk i programmeringsspråket. Nøkkel-verdi-tilnærmingen sikrer også at flere verdier ikke tilordnes én nøkkel, noe som **forhindrer dupliseringer**. Du kan imidlertid legge til det samme objektet flere ganger ved å bruke forskjellige nøkler. Denne typen lagrings- og søkefunksjonalitet har en positiv effekt på ytelsen sammenlignet med rigide lister, som er betydelig mindre fleksible. Dette er også en av de største fordelene med nøkkel-verdilagre, som bruker samme prinsipp. I de følgende avsnittene viser vi deg hvordan du oppretter og bruker Java HashMaps.

## Hvordan lage og bruke HashMaps i Java

For å opprette en ny HashMap i Java må du først importere klassen. For å gjøre dette bruker du Java-kommandoen `import`. Koden ser slik ut:

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

De to datatypene, som er atskilt med komma (i dette tilfellet `String, String`), er nøkkelen og verdien.

### Opprette en ny HashMap

For å bedre forklare hvordan Java HashMaps fungerer, har vi laget et enkelt eksempel. I vårt eksempel har vi en liste over kunder som et selskap ønsker å lagre og ha tilgang til når som helst. Listen inneholder navnet på hver kunde og et unikt kundenummer. Selv om kundenummeret (nøkkelen i eksemplet vårt) alltid er unikt, er det mulig at flere kunder har samme navn. Hver av disse kundene har imidlertid sitt eget unike nummer. Dette nummeret registreres som en heltallstype, og navnene som strenger. Slik konfigurerer du 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<>();
	}
}
```

### Legge til elementer

Nå har vi Java HashMap, men den er fortsatt tom. For å legge til nye nøkkel-verdipar, skal vi bruke metoden `put()`. Slik 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 bruker kommandoen `System.out.println` for å vise kundelisten vår. Utdataene skal se slik ut:

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

### Hente elementer

Nå har vi opprettet en kundeliste som kan inneholde mange oppføringer. Vi ønsker også å kunne få tilgang til hver kundeoppføring individuelt. For å gjøre dette, sender vi nøkkelen 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));
	}
}
```

Bare navnet «Jerry Mowry» skal vises.

### Slette oppføringer

Hvis du vil fjerne en oppføring, bruker du metoden `remove()`. Her er et eksempel på hvordan du bruker denne metoden:

```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);
	}
}
```

Utgangen ser nå slik ut:

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

Et annet alternativ er å slette hele listen. For å gjøre dette, bruk metoden `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);
	}
}
```

Nå er det eneste resultatet vi får dette:

```java
{ }
```

## Hvordan bestemme antall oppføringer

Selv om vår Java HashMap er ganske enkel, kan du også bruke denne klassen til å administrere større og mer komplekse prosjekter. Med et større prosjekt vil du kanskje ønske å finne ut det eksakte antallet oppføringer du har. Dette vil tross alt være hele kundebasen din. Du kan bruke `size()` til å gjøre dette. Slik gjør du 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.size());
	}
}
```

I vårt eksempel blir tallet 3 vist.

### Hvordan vise bare nøkler eller verdier

Du kan også hente en liste som bare inneholder nøklene eller verdiene ved å bruke en for-each-løkke. For å hente nøkler bruker du metoden `keySet()`, og for verdier bruker du metoden `values()`. I følgende kodeeksempel bruker 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);
		}
	}
}
```

Resultatet er:

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

### Sjekke om en HashMap inneholder en bestemt verdi eller nøkkel

I tillegg til å få tilgang til en bestemt oppføring, kan du også sjekke om en oppføring allerede finnes i en Java HashMap. Du kan gjøre dette ved å bruke metoden `containsKey()` (for nøkler) og metoden `containsValue()` (for verdier). Hvis elementet er inkludert, vil utdataene være «true». Hvis elementet ikke er i HashMap, vil utdataene være «false». Slik fungerer begge metodene:

```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");
	}
}
```

Siden nøkkelen «15312» er inkludert, men verdien «Stuart Miller» ikke er det, ser utdataene slik ut.

```java
true
false
```


This is a markdown version of: [https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-hashmap/](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-hashmap/) for AI/LLM consumption.