# Mis on Java HashMap ja kuidas seda kasutada?

Java HashMap-klass võimaldab salvestada andmeid võti-väärtuse paaridena. See mitte ainult ei lihtsusta nimekirja otsimist ja haldamist, vaid pakub ka mitmeid juurdepääsuvõimalusi. Siin vaatame läbi kõige olulisemad meetodid.

## Mis on HashMaps Java-s?

Andmete salvestamiseks ja otsimiseks on mitmeid viise. Milline salvestusviis sobib kõige paremini, sõltub sellest, kuidas te andmeid kasutada kavatsete. Paljudel juhtudel on Java HashMap-klass ilmselt parim lahendus. Erinevalt teistest meetoditest salvestab see klass andmed **võti-väärtuse paaridena**. See tähendab, et igale võtmele on määratud täpselt üks väärtus. Kui soovite väärtust otsida, saate vastava võtme abil leida soovitud tulemuse. Võtmed ja väärtused võivad koosneda täiesti erinevatest andmetüüpidest, sealhulgas stringidest, numbritest või muudest objektidest.

Java HashMap-klass pakub mitmeid eeliseid. Esiteks võimaldab see teha kiiret otsingut programmeerimiskeeles. Võti-väärtuse lähenemine tagab ka, et ühele võtmele ei määrataks mitut väärtust, **vältides dubleerimist**. Siiski on võimalik lisada sama objekt mitu korda, kasutades erinevaid võtmeid. Selline salvestus- ja otsingufunktsionaalsus mõjub positiivselt jõudlusele võrreldes jäikade nimekirjadega, mis on oluliselt vähem paindlikud. See on ka üks peamisi eeliseid võti-väärtus-salvestuspaikades, mis kasutavad sama põhimõtet. Järgmistes jaotistes näitame, kuidas luua ja kasutada Java HashMaps’i.

## Kuidas luua ja kasutada HashMaps’i Java’s

Uue HashMap’i loomiseks Java’s peate esmalt importima klassi. Selleks kasutage Java käsku `import`. Kood näeb välja järgmine:

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

Kaks andmetüüpi, mis on eraldatud komaga (antud juhul `String, String`), on võti ja väärtus.

### Uue HashMap’i loomine

Java HashMapide toimimise paremaks selgitamiseks oleme välja töötanud lihtsa näite. Meie näites on meil nimekiri klientidest, mida ettevõte soovib salvestada ja millele ta soovib igal ajal juurdepääsu. Nimekiri sisaldab iga kliendi nime ja unikaalset kliendinumbrit. Kuigi kliendinumber (meie näites võti) on alati unikaalne, on võimalik, et mitmel kliendil on sama nimi. Igal neist klientidest on aga oma unikaalne number. See number salvestatakse täisarvuna ja nimed salvestatakse stringidena. Siin on näide, kuidas seda Java HashMapis seadistada:

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

### Elementide lisamine

Nüüd on meil Java HashMap, kuid see on veel tühi. Uute võti-väärtuse paaride lisamiseks kasutame meetodit `put()`. See toimib järgmiselt:

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

Kasutame käsku `System.out.println`, et kuvada oma klientide nimekiri. Väljund peaks välja nägema järgmine:

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

### Elementide otsimine

Nüüd oleme loonud klientide nimekirja, mis võib sisaldada mitmeid kirjeid. Samuti soovime, et iga kliendi kirje oleks eraldi kättesaadav. Selleks edastame võtme meetodile **get()**. Siin on näide, kuidas see toimib:

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

Ainult nimi „Jerry Mowry” peaks ilmuma.

### Kande kustutamine

Kui soovite kirje kustutada, kasutage meetodit `remove()`. Siin on näide selle meetodi kasutamise kohta:

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

Väljund näeb nüüd välja järgmine:

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

Teine võimalus on kustutada kogu nimekiri. Selleks kasutage meetodit `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üüd on ainus väljund, mida saame, järgmine:

```java
{ }
```

## Kuidas määrata sissekannete arv

Kuigi meie Java HashMap on üsna lihtne, võite seda klassi kasutada ka suuremate ja keerulisemate projektide haldamiseks. Suurema projekti puhul võite soovida kindlaks teha oma kirjeid täpse arvu. Lõppude lõpuks on see kogu teie klientuur. Selleks võite kasutada `size()`. Siin on, kuidas seda teha:

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

Meie näites väljastatakse number 3.

### Kuidas kuvada ainult võtmeid või väärtusi

For-each-tsükli abil saate ka nimekirja, mis sisaldab ainult võtmeid või väärtusi. Võtmete hankimiseks kasutage meetodit `keySet()` ja väärtuste hankimiseks meetodit `values()`. Järgmises koodinäites kasutame `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);
		}
	}
}
```

Väljund on:

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

### Kontrollimine, kas HashMap sisaldab kindlat väärtust või võtit

Lisaks konkreetse kande juurdepääsule saate ka kontrollida, kas Java HashMapis on juba olemas vastav kanne. Selleks kasutage meetodit `containsKey()` (võtmete jaoks) ja meetodit `containsValue()` (väärtuste jaoks). Kui element on olemas, on väljundiks „true”. Kui elementi HashMapis ei ole, on väljundiks „false”. Mõlemad meetodid toimivad järgmiselt:

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

Kuna võti „15312” on olemas, aga väärtus „Stuart Miller” puudub, on väljund järgmine.

```java
true
false
```


This is a markdown version of: [https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/java-hashmap/](https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/java-hashmap/) for AI/LLM consumption.