java map interface tutorial with implementation examples
Ten kompleksowy samouczek dotyczący map w języku Java obejmuje sposoby tworzenia, inicjowania i powtarzania map. Dowiesz się również o metodach mapowania i przykładach implementacji:
Poznasz podstawy interfejsu mapy, metody obsługiwane przez interfejs mapy i inne specyficzne pojęcia związane z interfejsem mapy.
Kolekcja map w Javie to zbiór mapujący klucz do wartości. Jest to zbiór kluczy i wartości. Każdy wpis na mapie składa się z klucza z odpowiadającą mu wartością. Klucze są unikalne na mapach. Mapy mogą być używane zazwyczaj, gdy musimy zmodyfikować kolekcję na podstawie wartości klucza.
=> Sprawdź WSZYSTKIE samouczki Java tutaj.
Czego się nauczysz:
- Mapy w Javie
- Metody mapowania
- Implementacja mapy Java
- Wniosek
Mapy w Javie
Mapa w Javie jest częścią interfejsu java.util.map. Interfejs mapy nie jest częścią interfejsu kolekcji i jest to powód, dla którego mapy różnią się od innych kolekcji.
Ogólna hierarchia interfejsu mapy jest pokazana poniżej.
Jak pokazano powyżej, istnieją dwa interfejsy do implementacji mapy, tj. Interfejs mapy i interfejs sortowanej mapy. Istnieją trzy klasy, a mianowicie HashMap, TreeMap i LinkedHashMap.
Te typy map opisano poniżej:
| Klasa | Opis | |
|---|---|---|
| usunąć | V usuń (klucz obiektu) | Usuń wpis mapy dla danego klucza |
| LinkedHashMap | Rozszerza z klasy HashMap. Ta mapa utrzymuje kolejność reklamową | |
| HashMap | Zaimplementuj interfejs mapy. Żadne zamówienie nie jest utrzymywane przez HashMap. | |
| TreeMap | Implementuje interfejs mapy i sortowanej mapy. TreeMap utrzymuje kolejność rosnącą. |
Punkty do zapamiętania dotyczące map.
- W mapach każdy klucz może odwzorować co najwyżej jedną wartość. Ponadto w mapach nie może być zduplikowanych kluczy.
- Implementacje map, takie jak HashMap i LinkedHashMap, zezwalają na klucz i wartości null. Jednak TreeMap nie pozwala na to.
- Mapa nie może być przemierzana tak, jak jest. Dlatego w przypadku przechodzenia należy go przekonwertować na set za pomocą metody keyset () lub entrySet ().
Utwórz mapę w Javie
Aby stworzyć mapę w Javie, najpierw musimy uwzględnić interfejs w naszym programie. Możemy użyć jednego z poniższych poleceń w programie, aby zaimportować funkcjonalność mapy.
import java.util.*; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.TreeMap; Musimy utworzyć instancję konkretnej implementacji mapy, ponieważ jest to interfejs.
Poniższe instrukcje tworzą mapę w języku Java.
Map hash_map = new HashMap(); Map tree_map = new TreeMap(); Powyższe instrukcje utworzą mapy z domyślnymi specyfikacjami.
Możemy również tworzyć mapy ogólne, określając typy zarówno klucza, jak i wartości.
Map myMap = new HashMap(); Powyższa definicja będzie zawierała klucze typu string i obiekty jako wartości.
Zainicjuj mapę w Javie
Można go zainicjować za pomocą następujących metod:
# 1) Korzystanie z kolekcji
Klasa Java Collections zawiera metody fabryczne, których można używać do inicjowania kolekcji, w tym map.
Niektóre metody używane do inicjalizacji mapy są następujące:
(1) Kolekcje.EmptyMap ()
Kolekcje.EmptyMap () zwraca mapę możliwą do serializacji i niezmienną, która jest pusta. Na przykład, następujący wiersz kodu,
Map myMap = Collections.EMPTY_MAP; Spowoduje to utworzenie pustej mapy. Powyższa metoda może generować „ostrzeżenie o niezaznaczonym przypisaniu”, dlatego możemy również użyć poniższej postaci bezpiecznej dla typu.
Map myMap = Collections.emptyMap (); (2) Collections.unModifiableMap ()
Metoda unModifiableMap () przyjmuje inną mapę jako argument i tworzy niemodyfikowalny widok oryginalnej mapy.
Map myMap = Collections.EMPTY_MAP; Map map_unmodifiable = Collections.unmodifiableMap (myMap); (3) Collections.singletonMap ()
Klasa Collections udostępnia również metodę fabryki „singletonMap ()”, która tworzy niezmienną mapę singletonową mającą tylko jeden wpis.
Map singleton_map = Collections.singletonMap('CHN', 'Beijing'); # 2) Korzystanie z języka Java 8
Możemy uzyskać strumień danych z metod strumieniowego API Java 8 i konstruować mapy za pomocą Kolektorów.
Oto niektóre metody tworzenia map:
(1) Collectors.toMap ()
Zbieramy strumień, a następnie używamy metody Collectors.toMap () do konstruowania mapy.
Map map = Stream.of(new String()(){{'USA', 'Washington'}, {'United Kingdom', 'London'} }).collect(Collectors.toMap(p -> p(0), p -> p(1))); Powyższa instrukcja tworzy mapę ze strumienia Java 8.
(2) Collectors.collectingAndThen ()
W tym celu dostosowujemy metodę toMap (), która umożliwia kolektorowi tworzenie niezmiennej mapy przy użyciu metody collectAndThen ().
Map immutableMap = Stream.of(new String()(){ {'USA', 'Washington'}, {'United Kingdom', 'London”} }).collect(Collectors.collectingAndThen(Collectors.toMap(p -> p (0), p -> p(1)), Collections::unmodifiableMap)); # 3) Użycie metody put interfejsu mapy
Metoda put () interfejsu mapy może służyć do przypisywania wartości początkowych mapom.
# 4) Korzystanie z inicjalizacji podwójnego nawiasu klamrowego
Technika „inicjalizacja podwójnego nawiasu klamrowego” tworzy klasę wewnętrzną. Ta klasa jest anonimowa i zawiera inicjator wystąpienia. Nie jest to preferowana technika i należy jej unikać, ponieważ może to spowodować wycieki pamięci lub problemy z serializacją.
Poniższy program przedstawia różne metody inicjalizacji mapy omówione powyżej.
import java.util.*; import java.util.stream.*; import java.util.stream.Collectors; public class Main { public static void main(String args()) { //using Collections //create an empty map Map emptymap = Collections.EMPTY_MAP; //create unmodifiable map using Collections Map unmodifiableMap = Collections.unmodifiableMap(emptymap); System.out.println('unmodifiableMap map values:' + unmodifiableMap); //singleton map Map singleton_map = Collections.singletonMap(10, ' TEN'); System.out.println('
singleton_map Map values:' + singleton_map); //using Java 8 //1. toMap method of collectors class Map map_cities = Stream.of(new String()(){ {'MH', 'Mumbai'}, {'CH', 'Chennai'}, {'DL', 'New Delhi'} }).collect(Collectors.toMap(p -> p(0), p -> p(1))); System.out.println('
map_cities values: ' + map_cities); //2. collectingAndThen method Map capitals_Map = Stream.of(new String()(){ {'MAH', 'Mumbai'}, {'GOA', 'Panaji'}, {'KAR', 'Bangaluru'} }).collect(Collectors.collectingAndThen (Collectors.toMap(p -> p(0), p -> p(1)), Collections::unmodifiableMap)); System.out.println('
capitals_Map values: ' + capitals_Map); //double brace initialization Map country_map = new HashMap(); country_map.put('USA', 'Washington'); country_map.put('UK', 'London'); country_map.put('IND', 'Delhi'); country_map.put('GER', 'Berlin'); System.out.println('
Map values:' + country_map); } }Wynik:
niemodyfikowalne wartości mapy: {}
singleton_map Wartości mapy: {10 = TEN}
wartości map_cities: {CH = Chennai, DL = New Delhi, MH = Mumbai}
capitals_Map values: {MAH = Mumbai, GOA = Panaji, KAR = Bangaluru}
Wartości na mapie: {USA = Waszyngton, GER = Berlin, UK = Londyn, IND = Delhi}
Iteruj po mapie w Javie i wydrukuj mapę
Po mapie możemy poruszać się w taki sam sposób, w jaki przemierzamy inne kolekcje. Oprócz przechodzenia przez wpisy mapy, możemy również przechodzić tylko przez klucze lub tylko wartości na mapie. Zwróć uwagę, że aby przemierzyć mapę, należy ją najpierw przekonwertować na zestaw.
Następujące metody są używane do przechodzenia przez wpisy mapy.
Korzystanie z iteratora wprowadzania
W tej metodzie otrzymujemy iterator wpisu ze zbioru wpisów. Następnie za pomocą metod getKey i getValue pobieramy parę klucz-wartość dla każdego wpisu mapy.
Poniższy program przedstawia użycie iteratora wpisu.
import java.util.*; import java.util.stream.*; import java.util.stream.Collectors; public class Main { public static void main(String args()) { //use toMap method of collectors class to populate the map Map map_cities = Stream.of(new String()(){ {'MH', 'Mumbai'}, {'CH', 'Chennai'}, {'DL', 'New Delhi'} }).collect(Collectors.toMap(p -> p(0), p -> p(1))); //transform map to set Set entries = map_cities.entrySet(); //declare an iterator Iterator iterator = entries.iterator(); System.out.println('The map entries are:'); System.out.println(' KEY VALUE'); //iterate and print key and value pairs. while(iterator.hasNext()) { Map.Entry entry = iterator.next(); System.out.println(' ' + entry.getKey() + ' ' +entry.getValue()); } } } Wynik:
Wpisy na mapie to:
KLUCZOWA WARTOŚĆ
CH Chennai
DL New Delhi
MH Mumbai
W powyższym programie otrzymujemy iterator wpisu z mapy za pomocą metody entrySet. Następnie przechodzimy przez mapę za pomocą metody hasNext () iteratora wprowadzania i drukujemy parę klucz-wartość.
Korzystanie z wejścia dla każdej pętli
Tutaj przechodzimy przez entrySet za pomocą pętli for-each, a implementacja jest pokazana poniżej.
import java.util.*; import java.util.stream.*; import java.util.stream.Collectors; public class Main { public static void main(String args()) { //use toMap method of collectors class to populate the map Map map_cities = Stream.of(new String()(){ {'MH', 'Mumbai'}, {'CH', 'Chennai'}, {'DL', 'New Delhi'} }).collect(Collectors.toMap(p -> p(0), p -> p(1))); System.out.println('The map entries are:'); System.out.println(' KEY VALUE'); //iterate using for each over entry set and print key and value pairs. for(Map.Entry entry : map_cities.entrySet()){ System.out.println(' ' + entry.getKey() + ' ' +entry.getValue()); } } } Wynik:
Wpisy na mapie to:
KLUCZOWA WARTOŚĆ
CH Chennai
DL New Delhi
MH Mumbai
Metody mapowania
Interfejs map w Javie obsługuje różne operacje podobne do tych obsługiwanych przez inne kolekcje. W tej sekcji omówimy różne metody udostępniane przez Map API w Javie. Ponieważ zakres tego samouczka jest ograniczony do ogólnego wprowadzenia interfejsu mapy, nie będziemy opisywać tych metod.
Omówimy szczegółowo te metody podczas omawiania klas interfejsu mapy.
Poniższa tabela zawiera listę wszystkich metod udostępnianych przez interfejs API map.
| Nazwa metody | Prototyp metody | Opis |
|---|---|---|
| otrzymać | V get (klucz obiektu) | Zwraca obiekt lub wartość dla danego klucza |
| położyć | V put (klucz obiektu, wartość obiektu) | Wstaw klucz-wartość na mapie |
| połóż wszystko | void putAll (Mapa mapy) | Wstaw na mapie podane wpisy mapy. Innymi słowy, kopiuje lub klonuje mapę. |
| zestaw kluczy | Ustaw keySet () | Zwraca ustawiony widok mapy. |
| entrySet | Zestaw | Zwraca ustawienie widoku dla danej mapy |
| wartości | Wartości kolekcji () | Zwraca widok kolekcji wartości na mapie. |
| rozmiar | rozmiar int () | Zwraca liczbę wpisów na mapie |
| jasny | void clear () | Czyści mapę |
| jest pusty | boolean isEmpty () | Sprawdza, czy mapa jest pusta i zwraca wartość true, jeśli tak. |
| zawieraValue | boolean zawieraValue (wartość obiektu) | Zwraca prawdę, jeśli mapa zawiera wartość równą podanej wartości |
| zawieraKlucz | boolean containsKey (klucz obiektu) | Zwraca wartość true, jeśli dany klucz istnieje w mapie |
| równa się | boolean równa się (Object o) | Porównuje określony obiekt o z mapą |
| hashCode | int hashCode () | zwraca kod skrótu dla Map |
| dla każdego | void forEach (akcja BiConsumer) | Wykonuje daną akcję dla każdego wpisu na mapie |
| getOrDefault | V getOrDefault (klucz obiektu, V defaultValue) | Zwraca określoną wartość dla danego klucza lub jego wartość domyślną, jeśli klucza nie ma |
| usunąć | usunięcie logiczne (klucz obiektu, wartość obiektu) | Usuwa określone klucze i wartości |
| zastąpić | Zastąp V (klawisz K, wartość V) | Zastępuje dany klucz określoną wartością |
| zastąpić | boolean replace (klawisz K, V oldValue, V newValue) | Zastępuje starą wartość nową wartością dla danego klucza |
| Zamień wszystko | void replaceAll (funkcja BiFunction) | Wywołuje daną funkcję, aby zastąpić wszystkie wpisy mapy |
| putIfAbsent | V putIfAbsent (klawisz K, wartość V) | Wstawia podany klucz, wartość tylko wtedy, gdy nie jest już obecny |
| obliczać | V obliczenie (klawisz K, funkcja ponownego odwzorowania funkcji BiFunction) | Oblicza mapowanie dla określonego klucza i wartości, biorąc pod uwagę funkcję mapowania. |
| computeIfAbsent | V computeIfAbsent (klawisz K, funkcja mapowania funkcji) | Oblicz wartość dla danego klucza za pomocą funkcji mapowania, jeśli jeszcze nie istnieje. |
| computeIfPresent | V computeIfPresent (klawisz K, funkcja remappingu BiFunction) | Oblicza nowe mapowanie dla danego klucza z daną funkcją ponownego mapowania, jeśli wartość klucza jest już obecna |
| iść | Scalanie V (klawisz K, wartość V, funkcja remapowania BiFunction) | Kojarzy dany klucz z wartością, jeśli nie jest jeszcze skojarzony lub jest skojarzony z wartością null. |
Wszystkie powyższe metody są obsługiwane przez interfejs mapy. Zwróć uwagę, że metody, które są zacienione, to nowe metody, które zostały uwzględnione w Javie 8.
Implementacja mapy Java
Poniższy program implementuje przykład mapy w języku Java. Tutaj używamy większości metod omówionych powyżej.
Przykład ilustruje różne operacje pobierania, wysyłania i ustawiania.
import java.util.Collection; import java.util.HashMap; import java.util.Map; import java.util.Map.Entry; import java.util.Set; public class Main { public static void main(String() args) { //create a map Map country_map = new HashMap(); //assign values to the map country_map.put('IND', 'India'); country_map.put('SL', 'Srilanka'); country_map.put('CHN', 'China'); country_map.put('KOR', 'Korea'); country_map.put(null, 'Z'); // null key country_map.put('XX', null); // null value String value = country_map.get('CHN'); // get System.out.println('Key = CHN, Value : ' + value); value = country_map.getOrDefault('XX', 'Default Value'); //getOrDefault System.out.println('
Key = XX, Value : ' + value); boolean keyExists = country_map.containsKey(null); //containsKey boolean valueExists = country_map.containsValue('Z'); //containsValue System.out.println('
null keyExists : ' + keyExists + ', null valueExists= ' + valueExists); Set entrySet = country_map.entrySet(); //entrySet System.out.println('
entry set for the country_map: ' + entrySet); System.out.println('
Size of country_map : ' + country_map.size()); //size Map data_map = new HashMap(); data_map.putAll(country_map); //putAll System.out.println('
data_map mapped to country_map : ' + data_map); String nullKeyValue = data_map.remove(null); //remove System.out.println('
null key value for data_map : ' + nullKeyValue); System.out.println('
data_map after removing null key = ' + data_map); Set keySet = country_map.keySet(); //keySet System.out.println('
data map keys : ' + keySet); Collection values = country_map.values(); //values System.out.println('
data map values : ' + values); country_map.clear(); //clear System.out.println('
data map after clear operation, is empty :' + country_map.isEmpty()); } } Wynik:
Klucz = CHN, wartość: Chiny
Klucz = XX, Wartość: null
null keyExists: true, null valueExists = true
zestaw pozycji dla mapy_kraju: (null = Z, XX = null, CHN = Chiny, SL = Srilanka, IND = Indie, KOR = Korea)
Rozmiar mapy kraju: 6
data_map zmapowana na country_map: {null = Z, XX = null, CHN = Chiny, SL = Srilanka, IND = Indie, KOR = Kore
do}
null wartość klucza dla data_map: Z
data_map po usunięciu null key = {XX = null, CHN = China, SL = Srilanka, IND = India, KOR = Korea}
klucze mapy danych: (null, XX, CHN, SL, IND, KOR)
wartości map danych: (Z, null, Chiny, Sri Lanka, Indie, Korea)
mapa danych po wyczyszczeniu operacji jest pusta: prawda
Sortowanie mapy w Javie
Ponieważ mapa składa się z par klucz-wartość, możemy sortować mapę według kluczy lub wartości.
W tej sekcji posortujemy mapę według kluczy i wartości.
Sortuj według klucza
Aby posortować mapę według kluczy, możemy użyć mapy drzewa. Mapa drzewa automatycznie sortuje klucze. Poniższy program Java konwertuje mapę na mapę drzewa i wyświetla posortowane klucze.
import java.util.HashMap; import java.util.Map; import java.util.TreeMap; public class Main { public static void main(String() args) { //declare and initialize a map Map country_map = new HashMap(); country_map.put('I', 'India'); country_map.put('C', 'China'); country_map.put('A', 'America'); country_map.put('D', 'Denmark'); country_map.put('X', 'Hongkong'); //print original map System.out.println('Original Unsorted Map: '); display_map(country_map); System.out.println('
Map sorted by Key: '); //convert map to treemap and display it in which keys are auto sorted Map treecountry = new TreeMap(country_map); display_map(treecountry); } public static void display_map(Map map) { //obtain entry iterator and display key value pairs of map for (Map.Entry entry : map.entrySet()) { System.out.println(' ' + entry.getKey() + ' ' + entry.getValue()); } } }Wynik:
Oryginalna nieposortowana mapa:
Ameryka
C Chiny
D Dania
X Hongkong
I Indie
Mapa posortowana według klucza:
Ameryka
C Chiny
D Dania
I Indie
X Hongkong
Powyższy program tworzy mapę składającą się z jednego kodu alfabetu jako kluczy i nazw krajów jako wartości. Najpierw wyświetlamy oryginalną mapę, która nie jest posortowana. Następnie konwertujemy mapę na mapę drzewa, która automatycznie sortuje klucze. Na koniec wyświetlamy posortowaną mapę drzewa na klawiszach.
Sortuj według wartości
Aby posortować mapę na podstawie wartości, najpierw konwertujemy ją na listę. Następnie sortujemy tę listę za pomocą metody Collections.sort (), która używa komparatora do porównania wartości i uporządkowania ich w określonej kolejności.
Po posortowaniu listy połączone wpisy listy są ponownie kopiowane na mapę, która daje nam posortowaną mapę.
Poniższy program w języku Java demonstruje sortowanie mapy na podstawie wartości. Program używa LinkedHashMap, który jest przekazywany do funkcji sortowania. W funkcji sortowania jest konwertowany na połączoną listę i sortowany. Po posortowaniu jest konwertowany z powrotem do LinkedHashMap.
nowe funkcje w Javie 8 z przykładami
import java.util.*; public class Main { public static void main(String() args) { //define and initialize a map LinkedHashMap capitals_map = new LinkedHashMap(); capitals_map.put('NEP', 'Kathmandu'); capitals_map.put('IND', 'New Delhi'); capitals_map.put('USA', 'Washington'); capitals_map.put('UK', 'London'); capitals_map.put('AUS', 'Canberra'); //print original map System.out.println('Original unsorted map: '); System.out.println(capitals_map); //call sortMap method Map sorted_Map = sortMap(capitals_map); //print the sorted map System.out.println('
Map sorted on value : '); System.out.println(' Key Value '); for (Map.Entry entry : sorted_Map.entrySet()) { System.out.println(' ' + entry.getKey()+ ' ' + entry.getValue()); } } public static LinkedHashMap sortMap(LinkedHashMap linked_map) { //create a linkedlist from LinkedHashMap List capital_List = new LinkedList(linked_map.entrySet()); //sort the LinkedList Collections.sort(capital_List, (o1, o2) -> o1.getValue().compareTo(o2.getValue())); //Create LinkedHashMap from linkedlist and return it LinkedHashMap finalMap = new LinkedHashMap(); for (Map.Entry entry : capital_List) { finalMap.put(entry.getKey(), entry.getValue()); } return finalMap; } } Wynik:
Oryginalna mapa nieposortowana:
{NEP = Kathmandu, IND = New Delhi, USA = Waszyngton, Wielka Brytania = Londyn, AUS = Canberra
Mapa posortowana według wartości:
Kluczowa wartość
Z Canberry
NEP Kathmandu
UK Londyn
IND New Delhi
USA Waszyngton
Współbieżna mapa w Javie
ConcurrentMap to interfejs, który dziedziczy po interfejsie java.util.map. Interfejs concurrentMap został po raz pierwszy wprowadzony w JDK 1.5 i zapewnia mapę obsługującą współbieżny dostęp.
Interfejs concurrentMap jest częścią pakietu java.util.concurrent.
Poniższy program Java demonstruje concurrentMap w języku Java.
import java.util.concurrent.*; class Main { public static void main(String() args) { //create and initialize concurrentHashMap ConcurrentHashMap m = new ConcurrentHashMap(); m.put(100, 'Red'); m.put(101, 'Green'); m.put(102, 'Blue'); System.out.println('
Initial Concurrent Map : ' + m); //add a key using putIfAbsent method; key=103 is absent so its added m.putIfAbsent(103, 'Purple'); System.out.println('
After adding absent key 103 : ' + m); m.remove(101, 'Green'); // remove key = 101 System.out.println('
Concurrent Map after removing 101:' + m); m.putIfAbsent(101, 'Brown'); // again add key = 101 since its absent System.out.println('
Add absent key 101:' + m); m.replace(101, 'Brown', 'Green'); // replace value for key = 101 with 'Green' System.out.println('
Replace value at key 101:' + m); } } import java.util.concurrent.*; class Main { public static void main(String() args) { //create and initialize concurrentHashMap ConcurrentHashMap m = new ConcurrentHashMap(); m.put(100, 'Red'); m.put(101, 'Green'); m.put(102, 'Blue'); System.out.println('
Initial Concurrent Map : ' + m); //add a key using putIfAbsent method; key=103 is absent so its added m.putIfAbsent(103, 'Purple'); System.out.println('
After adding absent key 103 : ' + m); m.remove(101, 'Green'); // remove key = 101 System.out.println('
Concurrent Map after removing 101:' + m); m.putIfAbsent(101, 'Brown'); // again add key = 101 since its absent System.out.println('
Add absent key 101:' + m); m.replace(101, 'Brown', 'Green'); // replace value for key = 101 with 'Green' System.out.println('
Replace value at key 101:' + m); } }Wynik:
Początkowa mapa współbieżna: {100 = czerwony, 101 = zielony, 102 = niebieski}
Po dodaniu nieobecnego klawisza 103: {100 = czerwony, 101 = zielony, 102 = niebieski, 103 = fioletowy}
Mapa współbieżna po usunięciu 101: {100 = czerwony, 102 = niebieski, 103 = fioletowy}
Dodaj nieobecny klawisz 101: {100 = czerwony, 101 = brązowy, 102 = niebieski, 103 = fioletowy}
Zastąp wartość w kluczu 101: {100 = czerwony, 101 = zielony, 102 = niebieski, 103 = fioletowy}
Zsynchronizowana mapa w Javie
Mapa zsynchronizowana to mapa, która jest bezpieczna dla wątków i jest obsługiwana przez daną mapę. W Javie zsynchronizowana mapa jest uzyskiwana przy użyciu metody synchronizedMap () klasy java.util.Collections. Ta metoda zwraca zsynchronizowaną mapę dla danej mapy.
Ta zwrócona mapa zsynchronizowana jest używana do uzyskiwania dostępu do mapy zapasowej w celu uzyskania dostępu szeregowego.
Ogólna deklaracja metody synchronizedMap () to:
public static Map synchronizedMap(Map m) gdzie m => jest mapą bazową.
Jak już wspomniano, ta metoda zwraca zsynchronizowany widok mapy m.
Poniższy program Java jest przykładem zsynchronizowanej mapy.
import java.util.*; public class Main { public static void main(String() args) { //declare and initialize a map Map int_map = new HashMap(); int_map.put(1, 10); int_map.put(2, 20); int_map.put(3, 30); int_map.put(4, 40); int_map.put(5, 50); //print the map System.out.println('Original (backed) Map: ' + int_map); //obtain synchronized map Map sync_map = Collections.synchronizedMap(int_map); //remove an element from the map int_map.remove(3, 30); //print the altered map System.out.println('
Synchronized map after remove(3, 30):' + sync_map); } } Wynik:
Oryginalna mapa (z podkładem): {1 = 10, 2 = 20, 3 = 30, 4 = 40, 5 = 50}
Zsynchronizowana mapa po usunięciu (3, 30): {1 = 10, 2 = 20, 4 = 40, 5 = 50}
Mapa statyczna w Javie
Mapa statyczna w Javie to mapa zadeklarowana jako statyczna, tak jak zmienna statyczna. Deklarując mapę jako statyczną, staje się dostępną zmienną klasy bez użycia obiektu.
Istnieją dwa podejścia do tworzenia i inicjowania mapy statycznej w Javie.
# 1) Używanie zmiennej statycznej
Tutaj tworzymy statyczną zmienną mapy i tworzymy jej instancję wraz z deklaracją.
Takie podejście zostało przedstawione w następującym programie Java.
import java.util.*; class Main { //declare a static map variable and initialize it with declaration private static final Map myMap = new HashMap(){ { put(1, 'India'); put(2, 'Portugal'); put(3, 'Germany'); } }; public static void main(String() args) { //print the map System.out.println('Static map using static map variable:'); System.out.println(myMap); } }Wynik:
Mapa statyczna wykorzystująca zmienną mapy statycznej:
{1 = Indie, 2 = Portugalia, 3 = Niemcy}
# 2) Korzystanie z bloku statycznego
W tym celu tworzymy statyczną zmienną mapy. Następnie tworzymy blok statyczny i wewnątrz tego bloku statycznego inicjalizujemy zmienną mapy.
Pokazuje to poniższy program.
import java.util.*; class Main { // Declare the static map private static Map map; // declare a static block and initialize static map static { map = new HashMap(); map.put(1, 'Red'); map.put(2, 'Green'); map.put(3, 'Blue'); } public static void main(String() args) { System.out.println('Static Map using static block:'); System.out.println(map); } } Wynik:
Mapa statyczna przy użyciu bloku statycznego:
{1 = czerwony, 2 = zielony, 3 = niebieski}
Konwersja listy na mapę
W tej sekcji omówimy metody konwersji listy na mapę.
Te dwie metody obejmują:
Metoda tradycyjna
W tradycyjnej metodzie każdy element listy jest kopiowany do mapowania przy użyciu pętli for-each.
Ta implementacja jest pokazana poniżej:
import java.util.*; public class Main { public static void main(String() args) { //declare and initialize a list List colorsList = new ArrayList(); colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('Brown'); colorsList.add('White'); System.out.println('The given list: ' + colorsList); //declare a map Map map = new HashMap(); //initial Id(key) int i=1; //assign each list element to the map for (String color : colorsList) { map.put(i, color); i++; } //print the map System.out.println('Map generated from List:' + map); } } Wynik:
Podana lista: (czerwony, zielony, niebieski, brązowy, biały)
Mapa wygenerowana na podstawie listy: {1 = czerwony, 2 = zielony, 3 = niebieski, 4 = brązowy, 5 = biały}
Lista do mapowania w Javie 8
Możemy również skorzystać z metody Collectors.mapOf () Javy 8, która zamieni podaną listę na mapę.
Pokazuje to poniższy program.
import java.util.ArrayList; import java.util.LinkedHashMap; import java.util.List; import java.util.stream.Collectors; // class for list class Subject { //sub_id => map key private Integer sub_id; // sub_name => map value private String sub_name; // Subject constructor public Subject(Integer sub_id, String sub_name) { // initialize sub_id and sub_name this.sub_id = sub_id; this.sub_name = sub_name; } // return sub_id public Integer getSub_Id() { return sub_id; } // return sub_name public String getSub_Name() { return sub_name; } } public class Main { public static void main(String() args) { // create a list and add values to the list List sub_list = new ArrayList(); sub_list.add(new Subject(1, 'Abacus')); sub_list.add(new Subject(2, 'Maths')); sub_list.add(new Subject(3, 'Physics')); sub_list.add(new Subject(3, 'Chemistry')); //use Java 8 Collectors.toMap() method to create a map and assign list elements to it LinkedHashMap sub_map = sub_list.stream() .collect( Collectors.toMap(Subject::getSub_Id, Subject::getSub_Name,(x, y) -> x + ', ' + y, LinkedHashMap::new)); //print the map System.out.println('Map obtained from list : ' + sub_map); } } Wynik:
Mapa uzyskana z listy: {1 = liczydło, 2 = matematyka, 3 = fizyka, chemia}
W tym programie mamy klasę Subject, która działa jak klasa listy. Klasa Temat ma dwa pola, tj. Sub_id i sub_name. Mamy metody do odczytu wartości pól z klasy. W funkcji głównej tworzymy obiekty tej klasy i konstruujemy listę.
Ta lista jest następnie konwertowana na mapę przy użyciu metody Collectors.MapOf, która pobiera elementy jeden po drugim. Bierze również sub_Id jako klucz do mapy. Na koniec generowana jest mapa, która ma sub_Id jako klucz i Sub_Name jako wartość.
Konwertuj mapę na ciąg w języku Java
Zbiór map można przekonwertować na ciąg przy użyciu dwóch podejść:
Korzystanie z StringBuilder
Tutaj tworzymy obiekt StringBuilder, a następnie kopiujemy pary klucz-wartość mapy do obiektu StringBuilder. Następnie konwertujemy obiekt StringBuilder na łańcuch.
Poniższy program pokazuje kod Java do konwersji mapy na ciąg.
import java.util.*; import java.util.stream.Collectors; public class Main { public static void main(String() args) { //create and initialize a map Map numberNames = new HashMap(); numberNames.put(10, 'Ten'); numberNames.put(20, 'Twenty'); numberNames.put(30, 'Thirty'); numberNames.put(40, 'Forty'); //print the given map System.out.println('The given map: ' + numberNames); //create a StringBuilder object to store string StringBuilder map_String = new StringBuilder('{'); //append key-value pair of map to StringBuilder object for (Integer key : numberNames.keySet()) { map_String.append(key + '=' + numberNames.get(key) + ', '); } map_String.delete(map_String.length()-2, map_String.length()).append('}'); //print the string from StringBuilder System.out.println('
The string representation of map:'); System.out.println(map_String.toString()); } }Wynik:
Podana mapa: {20 = dwadzieścia, 40 = czterdzieści, 10 = dziesięć, 30 = trzydzieści}
Ciąg reprezentujący mapę:
{20 = dwadzieścia, 40 = czterdzieści, 10 = dziesięć, 30 = trzydzieści}
Korzystanie ze strumieni Java 8
W tej metodzie tworzymy strumień z kluczy mapy, a następnie konwertujemy go na łańcuch.
Program podany poniżej pokazuje konwersję mapy na ciąg przy pomocy strumieni.
import java.util.*; import java.util.stream.Collectors; public class Main{ public static void main(String() args) { //create and initialize a map Map numberNames = new HashMap(); numberNames.put(10, 'Ten'); numberNames.put(20, 'Twenty'); numberNames.put(30, 'Thirty'); numberNames.put(40, 'Forty'); //print the given map System.out.println('The given map: ' + numberNames); String map_String = numberNames.keySet().stream() .map(key -> key + '=' + numberNames.get(key)) .collect(Collectors.joining(', ', '{', '}')); //print the string System.out.println('
The string representation of map:'); System.out.println(map_String); } }Wynik:
Podana mapa: {20 = dwadzieścia, 40 = czterdzieści, 10 = dziesięć, 30 = trzydzieści}
Ciąg reprezentujący mapę:
{20 = dwadzieścia, 40 = czterdzieści, 10 = dziesięć, 30 = trzydzieści}
Konwertuj mapę na listę w Javie
Mapa składa się z kluczy i wartości, a lista jest sekwencją pojedynczych elementów. Konwertując mapę na listę, zwykle konwertujemy klucze na listę kluczy, a wartości na listę wartości.
Poniższy program Java przedstawia tę konwersję.
import java.util.*; public class Main { public static void main(String() args) { //declare a map and initialize it Map color_map = new HashMap(); color_map.put(10, 'red'); color_map.put(20, 'green'); color_map.put(30, 'blue'); color_map.put(40, 'cyan'); color_map.put(50, 'magenta'); //print the list of keys using map.keySet() method System.out.println('List of keys from the given map:'); List key_list = new ArrayList(color_map.keySet()); System.out.println(key_list); //print the list of values using map.values() method System.out.println('
List of values from the given map:'); List val_list = new ArrayList(color_map.values()); System.out.println(val_list); } }Wynik:
Lista kluczy z podanej mapy:
(50, 20, 40, 10, 30)
Lista wartości z podanej mapy:
(magenta, zielony, cyjan, czerwony, niebieski)
Dictionary Vs. Mapa w Javie
Omówmy niektóre z głównych różnic między słownikiem a mapą w Javie.
| Słownik | Mapa |
|---|---|
| Słownik to klasa abstrakcyjna. | Mapa jest interfejsem. |
| Klasy i metody używane przez klasę słownika poprzedzają strukturę kolekcji. | Klasy i metody używane przez klasy map są częścią struktury kolekcji. |
| Jeśli klasa rozszerza słownik, nie może rozszerzać żadnej innej klasy, ponieważ Java obsługuje tylko pojedyncze dziedziczenie | Mapa jest interfejsem, więc klasa może dziedziczyć po mapie i innych interfejsach |
| Stara realizacja. Prawie przestarzałe w nowszych wersjach Java. | Interfejs mapy zastąpił implementację słownika. |
Często Zadawane Pytania
Pytanie 1) Dlaczego używamy interfejsu mapy w Javie?
c ++ rzut char na string
Odpowiedź: Mapa to interfejs w Javie, który jest implementowany przez klasy przechowujące dane jako pary klucz-wartość. Interfejs mapy zapewnia operacje / metody, które można wykonać na parach klucz-wartość, takich jak wstawianie, aktualizowanie, usuwanie itp.
Pytanie nr 2)Co oznacza MAP w Javie?
Odpowiedź: Mapa w Javie reprezentuje mapowanie klucza o określonej wartości. Mapa Java przechowuje te pary klucz-wartość w mapie. Możemy wyszukać i pobrać wartość związaną z kluczem po prostu używając klucza na mapie.
Mapa jest implementowana w Javie przy użyciu interfejsu, który nie jest częścią interfejsu Collection. Ale mapa to zbiór.
Pytanie nr 3)Co otrzymuje MAP?
Odpowiedź: Get () to metoda udostępniana przez interfejs mapy w języku Java, która służy do pobierania wartości skojarzonej z określonym kluczem dostarczonym jako argument metody get (). Jeśli wartość nie jest obecna, zwracana jest wartość null.
Pytanie 4)Czy mapa jest zbiorem?
Odpowiedź: Chociaż mapa jest ogólnie postrzegana jako zbiór, nie implementuje interfejsu Collection. Niektóre implementacje map, takie jak mapa drzewa, nie obsługują wartości null ani kluczy.
Pytanie nr 5)Jaka jest różnica między set i map?
Odpowiedź: Zestaw jest zbiorem tylko kluczy, podczas gdy mapa jest zbiorem par klucz-wartość. Chociaż zestaw nie zezwala na wartości null, niektóre implementacje map dopuszczają wartości null.
Zestaw nie pozwala na zduplikowane klucze. Mapa może zezwalać na zduplikowane wartości, ale klucze muszą być unikalne. Zestaw jest zwykle używany, gdy chcemy przechowywać kolekcję unikalnych elementów. Mapa może być używana, gdy potrzebujemy przechowywać dane w postaci par klucz-wartość.
Wniosek
W tym samouczku omówiliśmy podstawy interfejsu mapy. Widzieliśmy również różne metody i wszystkie inne szczegóły związane z interfejsem mapy w Javie. Dowiedzieliśmy się, że istnieją różne implementacje interfejsów map, w tym mapa drzewa, hashmap itp.
W naszych nadchodzących samouczkach omówimy bardziej szczegółowo tę implementację mapy.
=> Odwiedź tutaj, aby nauczyć się języka Java od podstaw.
rekomendowane lektury
- Co to jest HashMap w Javie?
- TreeMap w Javie - samouczek z przykładami TreeMap w języku Java
- LinkedHashMap w Javie - Przykład i implementacja LinkedHashMap
- Ustaw interfejs w języku Java: samouczek dotyczący zestawu Java z przykładami
- Samouczek JAVA dla początkujących: ponad 100 praktycznych samouczków wideo Java
- Samouczek dotyczący stosu Java: Implementacja klas stosu z przykładami
- Samouczek dotyczący refleksji w języku Java z przykładami
- Postrzępiona tablica w Javie - samouczek z przykładami