W Javie HashMap jest częścią kolekcji Java od wersji Java 1.2. Ta klasa znajduje się w java.util pakiet. Zapewnia podstawową implementację interfejsu Map w Javie. HashMap w Javie przechowuje dane w parach (Klucz, Wartość), a dostęp do nich można uzyskać za pomocą indeksu innego typu (np. Integer). Jeden obiekt służy jako klucz (indeks) do innego obiektu (wartości). Jeśli spróbujesz wstawić zduplikowany klucz w HashMap, zastąpi on element odpowiedniego klucza.
Co to jest HashMap?
Mapa skrótów Java jest podobne do Tabela Hash , ale jest niezsynchronizowany. Pozwala również przechowywać klucze zerowe, ale powinien istnieć tylko jeden obiekt klucza zerowego i może istnieć dowolna liczba wartości zerowych. Klasa ta nie daje żadnej gwarancji co do kolejności mapy. Aby skorzystać z tej klasy i jej metod, należy dokonać importu java.util.HashMap pakiet lub jego nadklasa.
Spis treści
- Co to jest HashMap?
- Przykłady Java HashMap
- Deklaracja HashMap
- Hierarchia Java HashMap
- Tworzenie HashMap w Javie
- Konstruktorzy Java HashMap
- Wykonywanie różnych operacji na HashMap
- Złożoność HashMap w Javie
- Wewnętrzna struktura HashMap
- Zalety i wady Java HashMap
Przykłady Java HashMap
Poniżej znajduje się implementacja przykładu Java HashMap:
Jawa
// Java program to illustrate HashMap class> // of java.util package> // Importing HashMap class> import> java.util.HashMap;> // Main class> public> class> GFG {> >// Main driver method> >public> static> void> main(String[] args)> >{> >// Create an empty hash map by declaring object> >// of string and integer type> >HashMap map =>new> HashMap();> >// Adding elements to the Map> >// using standard put() method> >map.put(>'vishal'>,>10>);> >map.put(>'sachin'>,>30>);> >map.put(>'vaibhav'>,>20>);> >// Print size and content of the Map> >System.out.println(>'Size of map is:- '> >+ map.size());> >// Printing elements in object of Map> >System.out.println(map);> >// Checking if a key is present and if> >// present, print value by passing> >// random element> >if> (map.containsKey(>'vishal'>)) {> >// Mapping> >Integer a = map.get(>'vishal'>);> >// Printing value for the corresponding key> >System.out.println(>'value for key'> >+>' 'vishal' is:- '> + a);> >}> >}> }> |
>
>Wyjście
Size of map is:- 3 {vaibhav=20, vishal=10, sachin=30} value for key 'vishal' is:- 10> HashMapa Deklaracja
public class HashMap extends AbstractMap implements Map, Cloneable, Serializable>
Parametry:
Przyjmuje dwa parametry, a mianowicie:
- Typ kluczy obsługiwanych przez tę mapę
- Typ mapowanych wartości
Uwaga: K eys i value nie mogą być pierwotnym typem danych. Klucz w Hashmap jest ważny, jeśli jest implementowany hashCode() i równości(). , powinien być również niezmienny (niezmienny obiekt niestandardowy), aby kod skrótu i równość pozostały stałe. Wartością w hashmapie może być dowolna klasa opakowania, niestandardowe obiekty, tablice, dowolny typ referencyjny, a nawet null .
Na przykład : Hashmap może mieć tablicę jako wartość, ale nie jako klucz.
HashMap w implementacjach Java Możliwość serializacji , Możliwość klonowania , Mapa interfejsy.Java HashMap rozszerza się StreszczenieMapa klasa. Bezpośrednie podklasy to Połączona mapa Hash I Przyczyny stanu drukarki .
odwrócenie ciągu w Javie
Hierarchia Java HashMap
Charakterystyka Java HashMap
HashMap to struktura danych używana do przechowywania i pobierania wartości na podstawie kluczy. Niektóre z kluczowych cech mapy mieszającej obejmują:
- Szybki czas dostępu : HashMaps zapewniają stały dostęp do elementów w czasie, co oznacza, że pobieranie i wstawianie elementów jest bardzo szybkie, zwykle złożoność czasową O(1).
- Używa funkcji mieszającej : HashMaps używa funkcji skrótu do mapowania kluczy na indeksy w tablicy. Pozwala to na szybkie wyszukiwanie wartości na podstawie kluczy.
- Przechowuje pary klucz-wartość: Każdy element w HashMap składa się z pary klucz-wartość. Klucz służy do wyszukiwania powiązanej wartości.
- Obsługuje klucze i wartości zerowe : HashMaps pozwala na wartości null i klucze. Oznacza to, że do przechowywania wartości można użyć klucza zerowego, a wartość pustą można powiązać z kluczem.
- Nie zamówiony: HashMapy nie są uporządkowane, co oznacza, że kolejność dodawania elementów do mapy nie jest zachowana. Jednak LinkedHashMap jest odmianą HashMap, która zachowuje kolejność wstawiania.
- Zezwala na duplikaty : HashMaps pozwala na duplikaty wartości, ale nie na duplikaty kluczy. Jeśli dodany zostanie zduplikowany klucz, poprzednia wartość powiązana z kluczem zostanie nadpisana.
- Niebezpieczny wątek : HashMapy nie są bezpieczne dla wątków, co oznacza, że jeśli wiele wątków jednocześnie uzyskuje dostęp do tej samej mapy mieszającej, może to prowadzić do niespójności danych. Jeśli wymagane jest bezpieczeństwo wątku, można użyć ConcurrentHashMap.
- Pojemność i współczynnik obciążenia : HashMaps mają pojemność, czyli liczbę elementów, które mogą pomieścić, oraz współczynnik obciążenia, który jest miarą tego, jak pełna może być mapa mieszająca, zanim zostanie zmieniona jej wielkość.
Tworzenie HashMap w Javie
Pozwól nam zrozumieć, jak możemy stworzyć HashMap w Javie na przykładzie wymienionym poniżej:
Jawa
// Java Program to Create> // HashMap in Java> import> java.util.HashMap;> // Driver Class> public> class> ExampleHashMap {> >// main function> >public> static> void> main(String[] args) {> > >// Create a HashMap> >HashMap hashMap =>new> HashMap();> > >// Add elements to the HashMap> >hashMap.put(>'John'>,>25>);> >hashMap.put(>'Jane'>,>30>);> >hashMap.put(>'Jim'>,>35>);> > >// Access elements in the HashMap> >System.out.println(hashMap.get(>'John'>));> >// Output: 25> > >// Remove an element from the HashMap> >hashMap.remove(>'Jim'>);> > >// Check if an element is present in the HashMap> >System.out.println(hashMap.containsKey(>'Jim'>));> >// Output: false> > >// Get the size of the HashMap> >System.out.println(hashMap.size());> >// Output: 2> >}> }> |
>
>Wyjście
25 false 2>
Konstruktorzy Java HashMap
HashMap udostępnia 4 konstruktory, a modyfikator dostępu każdego z nich jest publiczny i są one wymienione w następujący sposób:
- HashMap()
- HashMap(int początkowa pojemność)
- HashMap(int początkowa pojemność, współczynnik obciążenia zmiennoprzecinkowego)
- HashMap (mapa mapy)
Teraz omówimy po kolei powyższe konstruktory wraz z ich implementacją za pomocą czystych programów Java.
1. HashMap()
Jest to domyślny konstruktor, który tworzy instancję HashMap o początkowej pojemności 16 i współczynniku obciążenia 0,75.
Składnia:
HashMap hm = new HashMap();>
Przykład
Jawa
// Java program to Demonstrate the HashMap() constructor> // Importing basic required classes> import> java.io.*;> import> java.util.*;> // Main class> // To add elements to HashMap> class> GFG {> >// Main driver method> >public> static> void> main(String args[])> >{> >// No need to mention the> >// Generic type twice> >HashMap hm1 =>new> HashMap();> >// Initialization of a HashMap using Generics> >HashMap hm2> >=>new> HashMap();> >// Adding elements using put method> >// Custom input elements> >hm1.put(>1>,>'one'>);> >hm1.put(>2>,>'two'>);> >hm1.put(>3>,>'three'>);> >hm2.put(>4>,>'four'>);> >hm2.put(>5>,>'five'>);> >hm2.put(>6>,>'six'>);> >// Print and display mapping of HashMap 1> >System.out.println(>'Mappings of HashMap hm1 are : '> >+ hm1);> >// Print and display mapping of HashMap 2> >System.out.println(>'Mapping of HashMap hm2 are : '> >+ hm2);> >}> }> |
>
>Wyjście
Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {4=four, 5=five, 6=six}> 2. HashMap(int początkowa pojemność)
Tworzy instancję HashMap z plikiem określona nośność początkowa i współczynnik obciążenia wynoszący 0,75.
Składnia:
HashMap hm = new HashMap(int initialCapacity);>
Przykład
Jawa
// Java program to Demonstrate> // HashMap(int initialCapacity) Constructor> // Importing basic classes> import> java.io.*;> import> java.util.*;> // Main class> // To add elements to HashMap> class> AddElementsToHashMap {> >// Main driver method> >public> static> void> main(String args[])> >{> >// No need to mention the> >// Generic type twice> >HashMap hm1 =>new> HashMap(>10>);> >// Initialization of a HashMap using Generics> >HashMap hm2> >=>new> HashMap(>2>);> >// Adding elements to object of HashMap> >// using put method> >// HashMap 1> >hm1.put(>1>,>'one'>);> >hm1.put(>2>,>'two'>);> >hm1.put(>3>,>'three'>);> >// HashMap 2> >hm2.put(>4>,>'four'>);> >hm2.put(>5>,>'five'>);> >hm2.put(>6>,>'six'>);> >// Printing elements of HashMap 1> >System.out.println(>'Mappings of HashMap hm1 are : '> >+ hm1);> >// Printing elements of HashMap 2> >System.out.println(>'Mapping of HashMap hm2 are : '> >+ hm2);> >}> }> |
>
>Wyjście
Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {4=four, 5=five, 6=six}> 3. HashMap(int początkowa pojemność, współczynnik obciążenia zmiennoprzecinkowego)
Tworzy instancję HashMap z określoną początkową pojemnością i określonym współczynnikiem obciążenia.
Składnia:
HashMap hm = new HashMap(int initialCapacity, float loadFactor);>
Przykład
kolejka w Javie
Jawa
// Java program to Demonstrate> // HashMap(int initialCapacity,float loadFactor) Constructor> // Importing basic classes> import> java.io.*;> import> java.util.*;> // Main class> // To add elements to HashMap> class> GFG {> >// Main driver method> >public> static> void> main(String args[])> >{> >// No need to mention the generic type twice> >HashMap hm1> >=>new> HashMap(>5>,>0>.75f);> >// Initialization of a HashMap using Generics> >HashMap hm2> >=>new> HashMap(>3>,>0>.5f);> >// Add Elements using put() method> >// Custom input elements> >hm1.put(>1>,>'one'>);> >hm1.put(>2>,>'two'>);> >hm1.put(>3>,>'three'>);> >hm2.put(>4>,>'four'>);> >hm2.put(>5>,>'five'>);> >hm2.put(>6>,>'six'>);> >// Print and display elements in object of hashMap 1> >System.out.println(>'Mappings of HashMap hm1 are : '> >+ hm1);> >// Print and display elements in object of hashMap 2> >System.out.println(>'Mapping of HashMap hm2 are : '> >+ hm2);> >}> }> |
>
>Wyjście
Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {4=four, 5=five, 6=six}> 4. HashMap (mapa mapy)
Tworzy instancję HashMap z tymi samymi mapowaniami, co określona mapa.
HashMap hm = nowa HashMap(mapa mapy);
Jawa
// Java program to demonstrate the> // HashMap(Map map) Constructor> import> java.io.*;> import> java.util.*;> class> AddElementsToHashMap {> >public> static> void> main(String args[])> >{> >// No need to mention the> >// Generic type twice> >Map hm1 =>new> HashMap();> >// Add Elements using put method> >hm1.put(>1>,>'one'>);> >hm1.put(>2>,>'two'>);> >hm1.put(>3>,>'three'>);> >// Initialization of a HashMap> >// using Generics> >HashMap hm2> >=>new> HashMap(hm1);> >System.out.println(>'Mappings of HashMap hm1 are : '> >+ hm1);> > >System.out.println(>'Mapping of HashMap hm2 are : '> >+ hm2);> >}> }> |
>
>Wyjście
Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {1=one, 2=two, 3=three}> Wykonywanie różnych operacji na HashMap
1. Dodawanie elementów w HashMap w Javie
W celu dodania elementu do mapy możemy skorzystać z metody umieścić() metoda. Jednak kolejność wstawiania nie jest zachowywana w Hashmapie. Wewnętrznie dla każdego elementu generowany jest oddzielny skrót, a elementy są indeksowane na podstawie tego skrótu, aby zwiększyć wydajność.
Jawa
// Java program to add elements> // to the HashMap> import> java.io.*;> import> java.util.*;> class> AddElementsToHashMap {> >public> static> void> main(String args[])> >{> >// No need to mention the> >// Generic type twice> >HashMap hm1 =>new> HashMap();> >// Initialization of a HashMap> >// using Generics> >HashMap hm2> >=>new> HashMap();> >// Add Elements using put method> >hm1.put(>1>,>'Geeks'>);> >hm1.put(>2>,>'For'>);> >hm1.put(>3>,>'Geeks'>);> >hm2.put(>1>,>'Geeks'>);> >hm2.put(>2>,>'For'>);> >hm2.put(>3>,>'Geeks'>);> >System.out.println(>'Mappings of HashMap hm1 are : '> >+ hm1);> >System.out.println(>'Mapping of HashMap hm2 are : '> >+ hm2);> >}> }> |
>
>Wyjście
Mappings of HashMap hm1 are : {1=Geeks, 2=For, 3=Geeks} Mapping of HashMap hm2 are : {1=Geeks, 2=For, 3=Geeks}> 2. Zmiana elementów w HashMap w Javie
Jeśli po dodaniu elementów chcemy zmienić element, można to zrobić poprzez ponowne dodanie elementu za pomocą umieścić() metoda. Ponieważ elementy na mapie są indeksowane za pomocą kluczy, wartość klucza można zmienić, po prostu wstawiając zaktualizowaną wartość klucza, dla którego chcemy zmienić.
centos kontra redhat
Jawa
// Java program to change> // elements of HashMap> import> java.io.*;> import> java.util.*;> class> ChangeElementsOfHashMap {> >public> static> void> main(String args[])> >{> >// Initialization of a HashMap> >HashMap hm> >=>new> HashMap();> >// Change Value using put method> >hm.put(>1>,>'Geeks'>);> >hm.put(>2>,>'Geeks'>);> >hm.put(>3>,>'Geeks'>);> >System.out.println(>'Initial Map '> + hm);> >hm.put(>2>,>'For'>);> >System.out.println(>'Updated Map '> + hm);> >}> }> |
>
>Wyjście
Initial Map {1=Geeks, 2=Geeks, 3=Geeks} Updated Map {1=Geeks, 2=For, 3=Geeks}> 3. Usuwanie elementu z Java HashMap
W celu usunięcia elementu z Mapy możemy skorzystać z opcji usunąć() metoda. Ta metoda pobiera wartość klucza i usuwa mapowanie klucza z tej mapy, jeśli jest on obecny na mapie.
Jawa
// Java program to remove> // elements from HashMap> import> java.io.*;> import> java.util.*;> class> RemoveElementsOfHashMap{> >public> static> void> main(String args[])> >{> >// Initialization of a HashMap> >Map hm> >=>new> HashMap();> >// Add elements using put method> >hm.put(>1>,>'Geeks'>);> >hm.put(>2>,>'For'>);> >hm.put(>3>,>'Geeks'>);> >hm.put(>4>,>'For'>);> >// Initial HashMap> >System.out.println(>'Mappings of HashMap are : '> >+ hm);> >// remove element with a key> >// using remove method> >hm.remove(>4>);> >// Final HashMap> >System.out.println(>'Mappings after removal are : '> >+ hm);> >}> }> |
>
>Wyjście
Mappings of HashMap are : {1=Geeks, 2=For, 3=Geeks, 4=For} Mappings after removal are : {1=Geeks, 2=For, 3=Geeks}> 4. Przechodzenie przez Java HashMap
Możemy użyć interfejsu Iteratora do poruszania się po dowolnej strukturze środowiska zbierania. Ponieważ Iteratory pracują z jednym typem danych, używamy Entry do przekształcenia dwóch oddzielnych typów w zgodny format. Następnie metodą next() wypisujemy wpisy HashMap.
Jawa
// Java program to traversal a> // Java.util.HashMap> import> java.util.HashMap;> import> java.util.Map;> public> class> TraversalTheHashMap {> >public> static> void> main(String[] args)> >{> >// initialize a HashMap> >HashMap map =>new> HashMap();> >// Add elements using put method> >map.put(>'vishal'>,>10>);> >map.put(>'sachin'>,>30>);> >map.put(>'vaibhav'>,>20>);> >// Iterate the map using> >// for-each loop> >for> (Map.Entry e : map.entrySet())> >System.out.println(>'Key: '> + e.getKey()> >+>' Value: '> + e.getValue());> >}> }> |
>
>Wyjście
Key: vaibhav Value: 20 Key: vishal Value: 10 Key: sachin Value: 30>
Złożoność HashMap w Javie
HashMap zapewnia stałą złożoność czasową dla podstawowych operacji, get i put, jeśli funkcja mieszająca jest poprawnie napisana i prawidłowo rozdziela elementy pomiędzy segmentami. Iteracja w HashMap zależy od pojemności HashMap i liczby par klucz-wartość. Zasadniczo jest to wprost proporcjonalne do pojemności + rozmiaru. Pojemność to liczba segmentów w HashMap. Dlatego początkowo nie jest dobrym pomysłem trzymanie dużej liczby segmentów w HashMap.
| Metody | Złożoność czasu | Złożoność przestrzeni |
|---|---|---|
| Dodawanie elementów w HashMap | O(1) | NA) |
| Usuwanie elementu z HashMap | O(1) | NA) |
| Wyodrębnianie elementu z Javy | O(1) | NA) |
Ważne funkcje HashMap
Aby uzyskać dostęp do wartości, należy znać jej klucz. HashMap jest znany jako HashMap, ponieważ wykorzystuje technikę zwaną hashowaniem. Haszowanie to technika konwersji dużego ciągu znaków na mały ciąg reprezentujący ten sam ciąg. Krótsza wartość pomaga w indeksowaniu i szybszym wyszukiwaniu. Zestaw skrótów używa również HashMap wewnętrznie.
Kilka ważnych cech HashMap to:
- HashMap jest częścią pakietu java.util.
- HashMap rozszerza klasę abstrakcyjną AbstractMap, która zapewnia również niekompletną implementację interfejsu Map.
- Implementuje również Możliwość klonowania I Możliwość serializacji interfejsy. K i V w powyższej definicji reprezentują odpowiednio klucz i wartość.
- HashMap nie pozwala na duplikowanie kluczy, ale pozwala na duplikaty wartości. Oznacza to, że pojedynczy klucz nie może zawierać więcej niż 1 wartości, ale więcej niż 1 klucz może zawierać pojedynczą wartość.
- HashMap pozwala również na klucz zerowy, ale tylko raz i wiele wartości zerowych.
- Klasa ta nie gwarantuje kolejności mapy; w szczególności nie gwarantuje, że kolejność będzie niezmienna w czasie. Jest mniej więcej podobny do HashTable, ale jest niezsynchronizowany.
Wewnętrzna struktura HashMap
Wewnętrznie HashMap zawiera tablicę Node, a węzeł jest reprezentowany jako klasa zawierająca 4 pola:
- int skrót
- Klawisz K
- Wartość V
- Węzeł następny
Można zauważyć, że węzeł zawiera odniesienie do własnego obiektu. Jest to więc lista połączona.
Mapa skrótów:
Węzeł:
lista posortowana Java
Wydajność HashMapa
Wydajność HashMap zależy od 2 parametrów o następujących nazwach:
- Pojemność początkowa
- Współczynnik obciążenia
1. Pojemność początkowa – Jest to pojemność HashMap w momencie jej utworzenia (jest to liczba segmentów, które HashMap może pomieścić po utworzeniu instancji HashMap). W Javie początkowo wynosi 2^4=16, co oznacza, że może pomieścić 16 par klucz-wartość.
2. Współczynnik obciążenia – Jest to procentowa wartość pojemności, po przekroczeniu której ma zostać zwiększona pojemność Hashmap (Jest to procentowe zapełnienie zasobników, po którym następuje Rehashing). W Javie domyślnie jest to 0,75f, co oznacza, że ponowne mieszanie odbywa się po zapełnieniu 75% pojemności.
3. Próg – Jest to iloczyn współczynnika obciążenia i pojemności początkowej. W Javie domyślnie jest to (16 * 0,75 = 12). Oznacza to, że ponowne mieszanie odbywa się po wstawieniu 12 par klucz-wartość do HashMap.
4. Ponowne rozmyślanie – Jest to proces podwajania pojemności HashMap po osiągnięciu progu. W Javie HashMap kontynuuje ponowne mieszanie (domyślnie) w następującej kolejności – 2^4, 2^5, 2^6, 2^7,…. Wkrótce.
Jeśli początkowa pojemność będzie wyższa, ponowne mieszanie nigdy nie zostanie wykonane. Jednak utrzymywanie go na wyższym poziomie zwiększa złożoność czasową iteracji. Należy go więc wybrać bardzo mądrze, aby zwiększyć wydajność. Przy ustalaniu pojemności początkowej należy wziąć pod uwagę oczekiwaną liczbę wartości. Najbardziej ogólnie preferowaną wartością współczynnika obciążenia jest 0,75, co zapewnia dobry stosunek kosztów czasu i miejsca. Wartość współczynnika obciążenia waha się od 0 do 1.
Notatka: Począwszy od wersji Java 8, Java zaczęła używać Self Balancing BST zamiast połączonej listy do łączenia łańcuchowego. Zaletą samobalansującego bst jest to, że w najgorszym przypadku (kiedy każdy klucz jest mapowany na to samo miejsce) czas wyszukiwania wynosi O(Log n).
Zsynchronizowana HashMap
Jak powiedziano, HashMap jest niezsynchronizowany, tj. Wiele wątków może uzyskać do niego dostęp jednocześnie. Jeśli wiele wątków uzyskuje dostęp do tej klasy jednocześnie i co najmniej jeden wątek manipuluje nią strukturalnie, konieczne jest zsynchronizowanie jej zewnętrznie. Odbywa się to poprzez synchronizację jakiegoś obiektu, który hermetyzuje mapę. Jeśli taki obiekt nie istnieje, można go owinąć wokół Collections.synchronizedMap() , aby zsynchronizować HashMap i uniknąć przypadkowego niezsynchronizowanego dostępu. Jak w poniższym przykładzie:
Map m = Collections.synchronizedMap(new HashMap(...));>
Teraz mapa m jest zsynchronizowana. Iteratory tej klasy są odporne na awarie, jeśli po utworzeniu iteratora zostanie wykonana jakakolwiek modyfikacja struktury, w jakikolwiek sposób, z wyjątkiem metody usuwania iteratora. W przypadku awarii iteratora zostanie zgłoszony wyjątek ConcurrentModificationException.
Zastosowania HashMapa:
HashMap to głównie implementacja hashowania. Przydaje się, gdy potrzebujemy sprawnej realizacji operacji wyszukiwania, wstawiania i usuwania. Proszę odnieść się do zastosowania hashowania dla szczegółów.
Metody w HashMapassociate
- K – Rodzaj klawiszy na mapie.
- W – Rodzaj wartości odwzorowanych na mapie.
| metoda | Opis |
|---|---|
| jasne() | Usuwa wszystkie mapowania z tej mapy. |
| klon() | Zwraca płytką kopię tej instancji HashMap: same klucze i wartości nie są klonowane. |
| compute (klawisz K, BiFunction ? super V,? rozszerza funkcję V> remapping) | Próbuje obliczyć mapowanie dla określonego klucza i jego aktualnie mapowanej wartości (lub null, jeśli nie ma bieżącego mapowania). |
| computeIfAbsent (klawisz K, funkcja super K.? rozszerza funkcję V> mapping) | Jeśli określony klucz nie jest już powiązany z wartością (lub jest zmapowany na wartość null), próbuje obliczyć jego wartość za pomocą danej funkcji mapującej i wprowadza ją do tego odwzorowania, chyba że ma wartość null. |
| computeIfPresent(klawisz K, BiFunction ? super V,? rozszerza funkcję V> remapping) | Jeśli wartość określonego klucza jest obecna i nie jest null, próbuje obliczyć nowe mapowanie, biorąc pod uwagę klucz i jego aktualnie odwzorowaną wartość. |
| zawieraKey (klucz obiektu) | Zwraca wartość true, jeśli ta mapa zawiera mapowanie dla określonego klucza. |
| zawieraWartość (wartość obiektu) | Zwraca wartość true, jeśli ta mapa odwzorowuje jeden lub więcej kluczy na określoną wartość. |
| zestaw wpisów() | Zwraca widok zestawu mapowań zawartych na tej mapie. |
| pobierz (klucz obiektu) | Zwraca wartość, na którą jest mapowany określony klucz, lub null, jeśli ta mapa nie zawiera mapowania dla klucza. |
| jest pusty() | Zwraca wartość true, jeśli ta mapa nie zawiera mapowań klucz-wartość. |
| zestaw kluczy() | Zwraca widok zestawu kluczy zawartych na tej mapie. |
| merge (klawisz K, wartość V, funkcja BiFunction ? super V,? rozszerza funkcję V> remapping) | Jeśli określony klucz nie jest już powiązany z wartością lub jest powiązany z wartością null, skojarz go z podaną wartością inną niż null. |
| put (klawisz K, wartość V) | Kojarzy określoną wartość z określonym kluczem na tej mapie. |
| putAll(Mapa m) | Kopiuje wszystkie odwzorowania z określonej mapy na tę mapę. |
| usuń (klucz obiektu) | Usuwa mapowanie dla określonego klucza z tej mapy, jeśli jest obecne. |
| rozmiar() | Zwraca liczbę mapowań klucz-wartość na tej mapie. |
| wartości() | Zwraca widok kolekcji wartości zawartych na tej mapie. |
Metody dziedziczone z klasy java.util.AbstractMap
| METODA | OPIS |
|---|---|
| równa się() | Porównuje określony obiekt z tą mapą pod kątem równości. |
| hashCode() | Zwraca wartość kodu skrótu dla tej mapy. |
| doString() | Zwraca ciąg reprezentujący tę mapę. |
Metody dziedziczone z interfejsu java.util.Map
| METODA | OPIS |
|---|---|
| równa się() | Porównuje określony obiekt z tą mapą pod kątem równości. |
| forEach (akcja BiConsumer) | Wykonuje daną akcję dla każdego wpisu na tej mapie, dopóki wszystkie wpisy nie zostaną przetworzone lub akcja nie zgłosi wyjątku. |
| getOrDefault (klucz obiektu, wartość domyślna V) | Zwraca wartość, na którą jest mapowany określony klucz, lub wartość domyślną, jeśli ta mapa nie zawiera mapowania klucza. |
| hashCode() | Zwraca wartość kodu skrótu dla tej mapy. |
| putIfAbsent(klawisz K, wartość V) | Jeśli określony klucz nie jest już powiązany z wartością (lub jest odwzorowany na wartość null), kojarzy go z podaną wartością i zwraca wartość null, w przeciwnym razie zwraca bieżącą wartość. |
| usuń (klucz obiektu, wartość obiektu) | Usuwa wpis dla określonego klucza tylko wtedy, gdy jest on aktualnie odwzorowany na określoną wartość. |
| zamień (klawisz K, wartość V) | Zastępuje wpis dla określonego klucza tylko wtedy, gdy jest on aktualnie odwzorowany na jakąś wartość. |
| zamień (klawisz K, V stara wartość, V nowa wartość) | Zastępuje wpis dla określonego klucza tylko wtedy, gdy jest aktualnie zamapowany na określoną wartość. |
| zamień wszystko (funkcja BiFunction) | Zastępuje wartość każdego wpisu wynikiem wywołania danej funkcji na tym wpisie, dopóki wszystkie wpisy nie zostaną przetworzone lub funkcja nie zgłosi wyjątku. |
Zalety Java HashMap
- Szybkie pobieranie: HashMaps zapewniają stały dostęp do elementów w czasie, co oznacza, że pobieranie i wstawianie elementów jest bardzo szybkie.
- Efektywne przechowywanie : HashMaps używa funkcji mieszającej do mapowania kluczy na indeksy w tablicy. Pozwala to na szybkie wyszukiwanie wartości na podstawie kluczy i efektywne przechowywanie danych.
- Elastyczność : HashMaps dopuszczają klucze i wartości zerowe oraz mogą przechowywać pary klucz-wartość dowolnego typu danych.
- Łatwy w użyciu : HashMaps mają prosty interfejs i można je łatwo zaimplementować w Javie.
- Nadaje się do dużych zbiorów danych : HashMaps może obsługiwać duże zbiory danych bez spowalniania.
Wady Java HashMap
- Niezamówiony : HashMaps nie są uporządkowane, co oznacza, że kolejność dodawania elementów do mapy nie jest zachowana.
- Nie jest bezpieczny dla wątków : HashMapy nie są bezpieczne dla wątków, co oznacza, że jeśli wiele wątków jednocześnie uzyskuje dostęp do tej samej mapy mieszającej, może to prowadzić do niespójności danych.
- Wydajność może ulec pogorszeniu : W niektórych przypadkach, jeśli funkcja mieszająca nie jest poprawnie zaimplementowana lub jeśli współczynnik obciążenia jest zbyt wysoki, wydajność HashMap może się pogorszyć.
- Bardziej złożone niż tablice i listy : HashMaps może być bardziej skomplikowany w zrozumieniu i użyciu niż proste tablice lub listy, szczególnie dla początkujących.
- Większe zużycie pamięci : Ponieważ HashMaps używają podstawowej tablicy, mogą zużywać więcej pamięci niż inne struktury danych, takie jak tablice lub listy. Może to być wadą, jeśli problemem jest użycie pamięci.
Przeczytaj także
- Hashmapa kontra mapa drzewa
- Hashmap kontra HashTable
- Najnowsze artykuły na temat Java HashMap
Często zadawane pytania dotyczące Java HashMap
1. Co to jest HashMap w Javie?
HashMap w Javie to klasa ze środowiska kolekcji, która może przechowywać w sobie pary klucz-wartość.
2. Dlaczego warto używać HashMap w Javie?
HashMap w Javie służy do przechowywania par klucz-wartość, gdzie każdy klucz jest unikalny.
3. Jakie są zalety HashMap?
HashMap jest używany, ponieważ zapewnia funkcje takie jak:
- Szybkie pobieranie
- Efektywne przechowywanie
- Elastyczny w użyciu
- Łatwy w użyciu
- Nadaje się do dużych zbiorów danych