# Kaj je Java HashMap in kako ga uporabljati

Razred HashMap v Javi omogoča shranjevanje podatkov v parih ključ-vrednost. To ne le olajša iskanje in upravljanje seznama, ampak vam ponuja tudi številne možnosti dostopa. Tukaj bomo pregledali najpomembnejše metode.

## Kaj so HashMaps v Javi?

Obstajajo različni načini shranjevanja in pridobivanja podatkov. Kateri način shranjevanja je najboljši, je odvisno od tega, kako nameravate podatke uporabljati. V mnogih primerih je razred Java HashMap verjetno najboljša rešitev. Za razliko od drugih metod ta razred shranjuje podatke kot **pare ključ-vrednost**. To pomeni, da je vsakemu ključu dodeljena natanko ena vrednost. Če želite pridobiti vrednost, lahko uporabite ustrezen ključ, da dobite želeni rezultat. Ključi in vrednosti so lahko popolnoma različnih podatkovnih tipov, vključno z nizi, številkami ali drugimi objekti.

Razred Java HashMap ponuja več prednosti. Prva je, da lahko v programskem jeziku izvedete hitro iskanje. Pristop ključ-vrednost tudi zagotavlja, da enemu ključu ni dodeljenih več vrednosti, **kar preprečuje podvajanje**. Vendar lahko isti objekt dodate večkrat z različnimi ključi. Ta vrsta shranjevanja in iskanja ima pozitiven učinek na zmogljivost v primerjavi s togimi seznami, ki so bistveno manj prilagodljivi. To je tudi ena od glavnih prednosti shranjevanja ključ-vrednost, ki uporablja isto načelo. V naslednjih poglavjih vam bomo pokazali, kako ustvariti in uporabljati Java HashMaps.

## Kako ustvariti in uporabljati HashMaps v Javi

Da bi ustvarili nov HashMap v Javi, morate najprej uvoziti razred. Za to uporabite ukaz Java `import`. Koda je naslednja:

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

Dva tipa podatkov, ki sta ločena z vejico (v tem primeru `String, String`), sta ključ in vrednost.

### Ustvarjanje novega HashMapa

Da bi bolje razložili, kako delujejo Java HashMaps, smo pripravili preprost primer. V našem primeru imamo seznam strank, ki jih želi podjetje shraniti in imeti dostop do njih kadarkoli. Seznam vključuje ime vsakega stranke in edinstveno številko stranke. Čeprav je številka stranke (ključ v našem primeru) vedno edinstvena, je mogoče, da več strank ima isto ime. Vendar ima vsaka od teh strank svojo edinstveno številko. Ta številka je zapisana kot celoštevilčni podatkovni tip, imena pa kot nizi. Tako to nastavite v Java HashMap:

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

### Dodajanje elementov

Sedaj imamo Java HashMap, vendar je še vedno prazen. Za dodajanje novih parov ključ-vrednost bomo uporabili metodo `put()`. Tako deluje:

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

Za prikaz seznama strank uporabimo ukaz `System.out.println`. Izpis naj bi bil takšen:

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

### Pridobivanje elementov

Sedaj smo ustvarili seznam strank, ki lahko vsebuje številne vnose. Želimo tudi, da lahko dostopamo do vsakega vnosa stranke posebej. Da bi to naredili, prenesemo ključ metodi **get()**. Tukaj je primer, kako to deluje:

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

Pojaviti se mora samo ime »Jerry Mowry«.

### Brisanje vnosov

Če želite odstraniti vnos, uporabite metodo `remove()`. Tukaj je primer, kako uporabiti to metodo:

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

Izhod je sedaj takšen:

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

Druga možnost je izbrisati celoten seznam. Za to uporabite metodo `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);
	}
}
```

Sedaj je edini izhod, ki ga dobimo, naslednji:

```java
{ }
```

## Kako določiti število vnosov

Čeprav je naš Java HashMap precej preprost, lahko to razred uporabite tudi za upravljanje večjih, bolj zapletenih projektov. Pri večjem projektu boste morda želeli določiti natančno število vnosov, ki jih imate. Konec koncev bi to bila vaša celotna baza strank. Za to lahko uporabite `size()`. Tako:

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

V našem primeru je izpisana številka 3.

### Kako prikazati samo ključe ali vrednosti

Z uporabo zanke for-each lahko pridobite tudi seznam, ki vsebuje samo ključe ali vrednosti. Za pridobivanje ključev uporabite metodo `keySet()`, za vrednosti pa metodo `values()`. V naslednjem primeru kode bomo uporabili `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);
		}
	}
}
```

Izhod je:

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

### Preverjanje, ali HashMap vsebuje določeno vrednost ali ključ

Poleg dostopa do določenega vnosa lahko v Java HashMap preverite tudi, ali vnos že obstaja. To lahko storite z metodo `containsKey()` (za ključe) in metodo `containsValue()` (za vrednosti). Če je element vključen, bo izhod »true«. Če element ni v HashMap, bo izhod »false«. Tako delujeta obe metodi:

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

Ker je ključ „15312“ vključen, vrednost „Stuart Miller“ pa ni, je izhod takšen.

```java
true
false
```


This is a markdown version of: [https://www.ionos.com/sl-si/digitalguide/spletne-strani/razvoj-spletnih-strani/java-hashmap/](https://www.ionos.com/sl-si/digitalguide/spletne-strani/razvoj-spletnih-strani/java-hashmap/) for AI/LLM consumption.