# Kas ir Java HashMap un kā to lietot

Java HashMap klase ļauj saglabāt datus atslēgas-vērtības pāros. Tas ne tikai atvieglo saraksta atgūšanu un pārvaldību, bet arī nodrošina daudzas piekļuves iespējas. Šeit apskatīsim svarīgākās metodes.

## Kas ir HashMaps Java valodā?

Ir dažādi veidi, kā uzglabāt un iegūt datus. Kāds uzglabāšanas veids ir vispiemērotākais, ir atkarīgs no tā, kā jūs plānojat izmantot datus. Daudzos gadījumos Java HashMap klase, iespējams, ir labākais risinājums. Atšķirībā no citām metodēm, šī klase uzglabā datus kā **atslēgas-vērtības pārus**. Tas nozīmē, ka katrai atslēgai ir piešķirta tieši viena vērtība. Ja vēlaties iegūt vērtību, varat izmantot atbilstošo atslēgu, lai iegūtu vēlamo rezultātu. Atslēgas un vērtības var sastāvēt no pilnīgi dažādiem datu tipiem, tostarp virknēm, skaitļiem vai citiem objektiem.

Java HashMap klase piedāvā vairākas priekšrocības. Pirmā no tām ir iespēja veikt ātru meklēšanu programmēšanas valodā. Atslēgas-vērtības pieeja nodrošina arī to, ka vienai atslēgai netiek piešķirtas vairākas vērtības, **novēršot dublēšanos**. Tomēr jūs varat pievienot vienu un to pašu objektu vairākas reizes, izmantojot dažādas atslēgas. Šāda veida uzglabāšanas un meklēšanas funkcionalitāte pozitīvi ietekmē veiktspēju salīdzinājumā ar stingriem sarakstiem, kas ir ievērojami mazāk elastīgi. Tas ir arī viens no galvenajiem priekšrocībām atslēgas-vērtības uzglabāšanas vietām, kas izmanto to pašu principu. Turpmākajās sadaļās mēs parādīsim, kā izveidot un izmantot Java HashMaps.

## Kā izveidot un lietot HashMaps Java valodā

Lai izveidotu jaunu HashMap Java, vispirms ir jāimportē klase. Lai to izdarītu, izmantojiet Java komandu `import`. Kods izskatās šādi:

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

Divi datu tipi, kas ir atdalīti ar komatu (šajā gadījumā `String, String`), ir atslēga un vērtība.

### Jauna HashMap izveide

Lai labāk izskaidrotu, kā darbojas Java HashMaps, esam izveidojuši vienkāršu piemēru. Mūsu piemērā mums ir klientu saraksts, kuru uzņēmums vēlas saglabāt un kuram vēlas piekļūt jebkurā brīdī. Sarakstā ir katra klienta vārds un unikāls klienta numurs. Lai gan klienta numurs (mūsu piemērā tas ir atslēga) vienmēr ir unikāls, ir iespējams, ka vairākiem klientiem ir viens un tas pats vārds. Tomēr katram no šiem klientiem ir savs unikāls numurs. Šis numurs tiek reģistrēts kā vesels skaitlis, bet vārdi kā virknes. Šeit ir parādīts, kā to iestatīt Java HashMap:

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

### Elementu pievienošana

Tagad mums ir Java HashMap, bet tas joprojām ir tukšs. Lai pievienotu jaunas atslēgas-vērtības pāri, mēs izmantosim `put()` metodi. Tā darbojas šādi:

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

Mēs izmantojam komandu `System.out.println`, lai parādītu mūsu klientu sarakstu. Rezultāts izskatās šādi:

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

### Elementu izgūšana

Tagad esam izveidojuši klientu sarakstu, kurā var būt daudz ierakstu. Mēs arī vēlamies, lai būtu iespējams piekļūt katram klienta ierakstam atsevišķi. Lai to izdarītu, mēs nododam atslēgu **get()** metodei. Šeit ir piemērs, kā tas darbojas:

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

Jāparādās tikai vārdam „Jerry Mowry”.

### Ierakstu dzēšana

Ja vēlaties atbrīvoties no ieraksta, izmantojiet `remove()` metodi. Šeit ir piemērs, kā izmantot šo 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");
	customerList.remove(1077);
	System.out.println(customerList);
	}
}
```

Rezultāts tagad izskatās šādi:

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

Vēl viena iespēja ir dzēst visu sarakstu. Lai to izdarītu, izmantojiet `clear()` 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");
	customerList.clear();
	System.out.println(customerList);
	}
}
```

Tagad vienīgais rezultāts, ko iegūstam, ir šāds:

```java
{ }
```

## Kā noteikt ierakstu skaitu

Lai gan mūsu Java HashMap ir diezgan vienkāršs, šo klasi var izmantot arī lielāku, sarežģītāku projektu pārvaldīšanai. Lielāka projekta gadījumā varat noteikt precīzu ierakstu skaitu. Galu galā tas būtu jūsu viss klientu bāzes apjoms. To var izdarīt, izmantojot `size()`. Darbības veids:

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

Mūsu piemērā tiek izvadīts skaitlis 3.

### Kā parādīt tikai atslēgas vai vērtības

Jūs varat arī iegūt sarakstu, kurā ir tikai atslēgas vai vērtības, izmantojot for-each cilpu. Lai atgūtu atslēgas, izmantojiet `keySet()` metodi, bet vērtības – `values()` metodi. Turpmākajā koda piemērā mēs izmantosim `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);
		}
	}
}
```

Rezultāts ir:

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

### Pārbaudot, vai HashMap satur konkrētu vērtību vai atslēgu

Papildus piekļuvei konkrētam ierakstam, jūs varat arī pārbaudīt, vai ieraksts jau pastāv Java HashMap. To var izdarīt, izmantojot metodi `containsKey()` (atslēgām) un metodi `containsValue()` (vērtībām). Ja elements ir iekļauts, izvade būs “true”. Ja elements nav HashMap, izvade būs “false”. Šeit ir redzams, kā darbojas abas metodes:

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

Tā kā atslēga „15312” ir iekļauta, bet vērtība „Stuart Miller” nav, izvade izskatās šādi.

```java
true
false
```


This is a markdown version of: [https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/java-hashmap/](https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/java-hashmap/) for AI/LLM consumption.