java map interface tutorial with implementation examples
Tento obsáhlý výukový program Java Map zahrnuje, jak vytvářet, inicializovat a procházet mapami. Dozvíte se také o mapových metodách a příkladech implementace:
Seznámíte se základy mapového rozhraní, metodami podporovanými mapovým rozhraním a dalšími konkrétními pojmy souvisejícími s mapovým rozhraním.
Sbírka map v Javě je kolekce mapující klíč k hodnotě. Je to kolekce skládající se z klíčů a hodnot. Každá položka na mapě se skládá z klíče s odpovídající hodnotou. Klíče jsou v mapách jedinečné. Mapy lze obvykle použít, když potřebujeme upravit kolekci na základě klíčové hodnoty.
=> Zkontrolujte VŠECHNY výukové programy Java zde.
Co se naučíte:
- Mapy v Javě
- Mapové metody
- Implementace Java Map
- Závěr
Mapy v Javě
Mapa v Javě je součástí rozhraní java.util.map. Rozhraní mapy není součástí rozhraní kolekce, a proto se mapy liší od ostatních kolekcí.
Níže je uvedena obecná hierarchie rozhraní mapy.
Jak je uvedeno výše, existují dvě rozhraní pro implementaci mapy, tj. Mapové rozhraní a tříděné rozhraní. Existují tři třídy, jmenovitě HashMap, TreeMap a LinkedHashMap.
Níže jsou popsány tyto typy map:
| Třída | Popis | |
|---|---|---|
| odstranit | V remove (klíč objektu) | Odstraňte položku mapy pro daný klíč |
| LinkedHashMap | Rozšiřuje se od třídy HashMap. Tato mapa udržuje pořadí vložení | |
| HashMap | Implementujte mapové rozhraní. HashMap neudržuje žádné pořadí. | |
| TreeMap | Implementuje jak mapové, tak tříděné rozhraní. TreeMap udržuje vzestupné pořadí. |
Body, které si o mapách pamatujete.
- V mapách může každý klíč mapovat nejvýše jednu hodnotu. V mapách také nemohou být duplicitní klíče.
- Mapové implementace jako HashMap a LinkedHashMap umožňují nulový klíč a nulové hodnoty. TreeMap to však neumožňuje.
- Mapu nelze procházet tak, jak je. Proto pro procházení je třeba jej převést na sadu pomocí metody keyset () nebo entrySet ().
Vytvořte mapu v Javě
Chcete-li vytvořit mapu v Javě, nejprve musíme do našeho programu zahrnout rozhraní. K importu funkčnosti mapy můžeme použít jeden z následujících příkazů v programu.
import java.util.*; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.TreeMap; Musíme provést instanci konkrétní implementace mapy, protože se jedná o rozhraní.
Následující příkazy vytvářejí mapu v Javě.
Map hash_map = new HashMap(); Map tree_map = new TreeMap(); Výše uvedená prohlášení vytvoří mapy s výchozími specifikacemi.
Můžeme také vytvořit obecné mapy určující typy pro klíč i hodnotu.
Map myMap = new HashMap(); Výše uvedená definice bude mít jako hodnoty klíče typu string a objekty.
Inicializovat mapu v Javě
Lze jej inicializovat pomocí následujících metod:
# 1) Používání sbírek
Třída Java Collections obsahuje tovární metody, které lze použít k inicializaci kolekcí včetně map.
Některé metody používané k inicializaci mapy jsou následující:
(1) Collections.EmptyMap ()
Collections.EmptyMap () vrací serializovatelnou a neměnnou mapu, která je prázdná. Například, následující řádek kódu,
Map myMap = Collections.EMPTY_MAP; Tím se vytvoří prázdná mapa. Výše uvedená metoda může vyvolat „upozornění na nekontrolované přiřazení“, a proto můžeme také použít typově bezpečný formulář následujícím způsobem.
Map myMap = Collections.emptyMap (); (2) Collections.unModifiableMap ()
Metoda unModifiableMap () bere jako argument jinou mapu a vytvoří nemodifikovatelný pohled na původní mapu.
Map myMap = Collections.EMPTY_MAP; Map map_unmodifiable = Collections.unmodifiableMap (myMap); (3) Collections.singletonMap ()
Třída Collections také poskytuje tovární metodu ‚singletonMap () ', která vytváří neměnnou mapu singletonů, která má pouze jednu položku.
Map singleton_map = Collections.singletonMap('CHN', 'Beijing'); # 2) Používání Java 8
Můžeme získat proud dat z metod Java 8 stream API a vytvářet mapy pomocí Collectors.
Některé z metod konstrukce map jsou:
(1) Collectors.toMap ()
Shromáždíme stream a poté pomocí metody Collectors.toMap () vytvoříme mapu.
Map map = Stream.of(new String()(){{'USA', 'Washington'}, {'United Kingdom', 'London'} }).collect(Collectors.toMap(p -> p(0), p -> p(1))); Výše uvedené prohlášení vytvoří mapu ze streamu Java 8.
(2) Collectors.collectingAndThen ()
V tomto upravíme metodu toMap (), která umožňuje kolektoru vytvořit neměnnou mapu pomocí 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) Použití metody put rozhraní mapového rozhraní
Metodu put () rozhraní mapy lze použít k přiřazení počátečních hodnot mapám.
# 4) Použití inicializace Double Brace
Technika „inicializace dvojitých závorek“ vytváří vnitřní třídu. Tato třída je anonymní a má v sobě inicializátor instance. Nejedná se o preferovanou techniku a je třeba se jí vyhnout, protože by to mohlo vést k nevracení paměti nebo problémům se serializací.
Níže uvedený program ukazuje různé metody inicializace mapy popsané výše.
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); } }Výstup:
hodnoty mapy unmodifiableMap: {}
singleton_map Hodnoty mapy: {10 = TEN}
hodnoty map_cities: {CH = Chennai, DL = Nové Dillí, MH = Bombaj}
hodnoty capitals_Map: {MAH = Bombaj, GOA = Panaji, KAR = Bangaluru}
Hodnoty na mapě: {USA = Washington, GER = Berlín, Velká Británie = Londýn, IND = Dillí}
Iterovat přes mapu v Javě a vytisknout mapu
Můžeme procházet mapu stejným způsobem, jakým procházíme ostatní sbírky. Kromě procházení položek mapy můžeme procházet pouze klíče nebo pouze hodnoty na mapě. Všimněte si, že k procházení mapy je třeba ji nejprve převést na nastavení.
K procházení položek mapy se používají následující metody.
Pomocí vstupního iterátoru
V této metodě získáme vstupní iterátor ze sady záznamů. Pak pomocí metod getKey a getValue načteme pár klíč – hodnota pro každou položku mapy.
Následující program ukazuje použití vstupního iterátoru.
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()); } } } Výstup:
Položky na mapě jsou:
KLÍČOVÁ HODNOTA
CH Chennai
DL Nové Dillí
MH Bombaj
Ve výše uvedeném programu získáme vstupní iterátor z mapy pomocí metody entrySet. Poté projdeme mapu pomocí metody hasNext () vstupního iterátoru a vytiskneme pár klíč – hodnota.
Použití záznamu pro každou smyčku
Zde procházíme položku entrySet pomocí smyčky for-each a implementace je uvedena níže.
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()); } } } Výstup:
Položky na mapě jsou:
KLÍČOVÁ HODNOTA
CH Chennai
DL Nové Dillí
MH Bombaj
Mapové metody
Mapové rozhraní v Javě podporuje různé operace podobné těm, které podporují jiné sbírky. V této části budeme diskutovat o různých metodách poskytovaných Map API v Javě. Protože rozsah tohoto kurzu je omezen na obecné zavedení mapového rozhraní, nebudeme tyto metody popisovat.
O těchto metodách budeme podrobně diskutovat při diskusích o třídách mapových rozhraní.
V následující tabulce jsou uvedeny všechny metody poskytované mapovým rozhraním API.
| Název metody | Metoda Prototyp | Popis |
|---|---|---|
| dostat | V get (klíč objektu) | Vrátí objekt nebo hodnotu pro daný klíč |
| dát | V put (klíč objektu, hodnota objektu) | Vložte do páru klíč – hodnota |
| putAll | void putAll (Mapa mapy) | Vložte dané mapové položky do mapy. Jinými slovy kopíruje nebo klonuje mapu. |
| keySet | Set keySet () | Vrátí nastavený pohled na mapu. |
| entrySet | Soubor | Vrátí nastavení zobrazení pro danou mapu |
| hodnoty | Hodnoty kolekce () | Vrátí zobrazení kolekce hodnot na mapě. |
| velikost | int velikost () | Vrátí počet záznamů na mapě |
| Průhledná | prázdnota clear () | Vymaže mapu |
| je prázdný | boolean isEmpty () | Zkontroluje, zda je mapa prázdná, a vrátí hodnotu true, pokud ano. |
| containsValue | boolean containsValue (hodnota objektu) | Vrátí true, pokud mapa obsahuje hodnotu rovnou dané hodnotě |
| containsKey | boolean containsKey (klíč objektu) | Vrátí true, pokud daný klíč na mapě existuje |
| rovná se | boolean se rovná (objekt o) | Porovná zadaný objekt o s mapou |
| hashCode | int hashCode () | vrátí hash kód pro Mapu |
| pro každého | void forEach (BiConsumer action) | Provede danou akci pro každou položku na mapě |
| getOrDefault | V getOrDefault (klíč objektu, V defaultValue) | Vrátí zadanou hodnotu pro daný klíč nebo jeho výchozí hodnotu, pokud klíč není k dispozici |
| odstranit | boolean remove (klíč objektu, hodnota objektu) | Odebere zadané klíče a hodnoty |
| nahradit | V nahradit (klíč K, hodnota V) | Nahradí daný klíč zadanou hodnotou |
| nahradit | boolean replace (klíč K, V oldValue, V newValue) | Nahradí starou hodnotu novou hodnotou pro daný klíč |
| vyměnit vše | void replaceAll (funkce BiFunction) | Vyvolá danou funkci, aby nahradil všechny položky mapy |
| putIfAbsent | V putIfAbsent (klíč K, hodnota V) | Vloží daný klíč, hodnotu, pouze pokud již není k dispozici |
| vypočítat | Výpočet V (klávesa K, funkce BiFunkce přemapování) | Vypočítá mapování pro zadaný klíč a hodnotu danou funkcí mapování. |
| computeIfAbsent | V computeIfAbsent (klávesa K, funkce mapování funkcí) | Vypočítejte hodnotu pro daný klíč pomocí funkce mapování, pokud již není k dispozici. |
| computeIfPresent | V computeIfPresent (klávesa K, BiFunction remappingFunction) | Vypočítá nové mapování pro daný klíč s danou funkcí přemapování, pokud je již hodnota klíče k dispozici |
| jít | Sloučení V (klávesa K, hodnota V, funkce BiFunkce přemapování) | Přidruží daný klíč k hodnotě, pokud již není přidružen nebo je přidružen k hodnotě null. |
Všechny výše uvedené metody jsou podporovány mapovým rozhraním. Všimněte si, že metody, které se zobrazují šedě, jsou nové metody, které byly zahrnuty do prostředí Java 8.
Implementace Java Map
Následující program implementuje příklad mapy v Javě. Zde používáme většinu výše diskutovaných metod.
Příklad ukazuje různé operace get, put a set.
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()); } } Výstup:
Klíč = CHN, hodnota: Čína
Klíč = XX, hodnota: null
null keyExists: true, null valueExists = true
sada záznamů pro mapu země: (null = Z, XX = null, CHN = Čína, SL = Srilanka, IND = Indie, KOR = Korea)
Velikost mapy země: 6
data_map mapped to country_map: {null = Z, XX = null, CHN = China, SL = Srilanka, IND = India, KOR = Kore
na}
hodnota nulového klíče pro data_map: Z
data_map po odebrání null key = {XX = null, CHN = Čína, SL = Srilanka, IND = Indie, KOR = Korea}
klíče datové mapy: (null, XX, CHN, SL, IND, KOR)
hodnoty datové mapy: (Z, null, Čína, Srílanka, Indie, Korea)
datová mapa po vymazání, je prázdná: true
Třídění mapy v Javě
Protože mapa se skládá z párů klíč – hodnota, můžeme mapu seřadit podle klíčů nebo hodnot.
V této části roztřídíme mapu na klíče i hodnoty.
Třídit podle klíče
K seřazení mapy podle klíčů můžeme použít stromovou mapu. Treemap seřadí klíče automaticky. Níže uvedený program Java převádí mapu na stromovou mapu a zobrazuje seřazené klíče.
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()); } } }Výstup:
Původní netříděná mapa:
Amerika
C Čína
D Dánsko
X Hongkong
Já Indie
Mapa seřazená podle klíče:
Amerika
C Čína
D Dánsko
Já Indie
X Hongkong
Výše uvedený program vytváří mapu skládající se z jediného abecedního kódu jako klíčů a názvů zemí jako hodnot. Nejprve zobrazíme původní mapu, která není tříděna. Poté mapu převedeme na mapu, která automaticky seřadí klíče. Nakonec zobrazíme seřazenou stromovou mapu na klíčích.
Třídit podle hodnoty
Chcete-li seřadit mapu na základě hodnot, nejprve ji převedeme do seznamu. Pak tento seznam roztřídíme pomocí metody Collections.sort (), která používá komparátor k porovnání hodnot a jejich uspořádání v konkrétním pořadí.
Jakmile je seznam seřazen, propojené položky seznamu jsou znovu zkopírovány na mapu, což nám dává seřazenou mapu.
Následující program Java demonstruje třídění mapy na základě hodnoty. Program používá LinkedHashMap, který je předán funkci třídění. Ve funkci třídění se převede na propojený seznam a setřídí se. Po seřazení se převede zpět na LinkedHashMap.
jaké e-maily tam jsou
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; } } Výstup:
Původní netříděná mapa:
{NEP = Káthmándú, IND = Nové Dillí, USA = Washington, Velká Británie = Londýn, AUS = Canberra
Mapa seřazená podle hodnoty:
Klíčová hodnota
Z Canberry
NEP Káthmándú
UK London
IND Nové Dillí
USA Washington
Souběžná mapa v Javě
ConcurrentMap je rozhraní, které dědí z rozhraní java.util.map. Rozhraní concurrentMap bylo poprvé představeno v JDK 1.5 a poskytuje mapu, která zpracovává souběžný přístup.
Rozhraní concurrentMap je součástí balíčku java.util.concurrent.
Následující program Java demonstruje concurrentMap v Javě.
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); } }Výstup:
Počáteční souběžná mapa: {100 = červená, 101 = zelená, 102 = modrá}
Po přidání chybějícího klíče 103: {100 = červená, 101 = zelená, 102 = modrá, 103 = fialová}
Souběžná mapa po odebrání 101: {100 = červená, 102 = modrá, 103 = fialová}
Přidat chybějící klíč 101: {100 = červená, 101 = hnědá, 102 = modrá, 103 = fialová}
Nahraďte hodnotu na klíči 101: {100 = červená, 101 = zelená, 102 = modrá, 103 = fialová}
Synchronizovaná mapa v Javě
Synchronizovaná mapa je mapa, která je bezpečná pro vlákna a je podložena danou mapou. V Javě se Synchronizovaná mapa získává pomocí metody synchronizedMap () třídy java.util.Collections. Tato metoda vrací synchronizovanou mapu pro danou mapu.
Tato vrácená synchronizovaná mapa se používá pro přístup k záložní mapě k dosažení sériového přístupu.
Obecná deklarace metody synchronizedMap () je:
public static Map synchronizedMap(Map m) kde m => je podkladová mapa.
Jak již bylo zmíněno, tato metoda vrací synchronizované zobrazení mapy m.
Níže uvedený program Java je příkladem synchronizované mapy.
klidné webové služby, otázky týkající se rozhovoru s Java
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); } } Výstup:
Původní (zálohovaná) mapa: {1 = 10, 2 = 20, 3 = 30, 4 = 40, 5 = 50}
Synchronizovaná mapa po odebrání (3, 30): {1 = 10, 2 = 20, 4 = 40, 5 = 50}
Statická mapa v Javě
Statická mapa v Javě je mapa, která je deklarována jako statická stejně jako statická proměnná. Deklarováním statické mapy se stane dostupnou proměnnou třídy bez použití objektu.
Existují dva přístupy k vytvoření a inicializaci statické mapy v Javě.
# 1) Použití statické proměnné
Zde vytvoříme proměnnou statické mapy a vytvoříme její instanci spolu s deklarací.
Tento přístup je demonstrován v následujícím programu 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); } }Výstup:
Statická mapa pomocí proměnné statické mapy:
{1 = Indie, 2 = Portugalsko, 3 = Německo}
# 2) Použití statického bloku
V tomto vytvoříme proměnnou statické mapy. Poté vytvoříme statický blok a uvnitř tohoto statického bloku inicializujeme proměnnou mapy.
Níže uvedený program to ukazuje.
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); } } Výstup:
Statická mapa pomocí statického bloku:
{1 = červená, 2 = zelená, 3 = modrá}
Převod seznamu na mapu
V této části budeme diskutovat o metodách převodu seznamu na mapu.
Tyto dvě metody zahrnují:
Tradiční metoda
V tradiční metodě je každý prvek seznamu zkopírován do mapy pomocí smyčky pro každou.
Tato implementace je uvedena níže:
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); } } Výstup:
Uvedený seznam: (červená, zelená, modrá, hnědá, bílá)
Mapa vygenerovaná ze seznamu: {1 = červená, 2 = zelená, 3 = modrá, 4 = hnědá, 5 = bílá}
Seznam na mapě v Javě 8
Můžeme také použít metodu Java 8 Collectors.mapOf (), která převede daný seznam na mapu.
Níže uvedený program to ukazuje.
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); } } Výstup:
Mapa získaná ze seznamu: {1 = Počitadlo, 2 = Matematika, 3 = Fyzika, Chemie}
V tomto programu máme třídu Předmět, která funguje jako třída seznamu. Třída Subjekt má dvě pole, tj. Sub_id a sub_name. Máme metody pro čtení hodnot pole z třídy. V hlavní funkci vytváříme objekty této třídy a vytváříme seznam.
Tento seznam se poté převede na mapu pomocí metody Collectors.MapOf, která jednotlivé prvky přebírá jeden po druhém. Také bere sub_Id jako klíč k mapě. Nakonec se vygeneruje mapa, která má sub_Id jako klíč a Sub_Name jako hodnotu.
Převést mapu na řetězec v Javě
Sbírku map lze převést na řetězec pomocí dvou přístupů:
Pomocí StringBuilder
Zde vytvoříme objekt StringBuilder a poté zkopírujeme páry klíč – hodnota mapy do objektu StringBuilder. Pak převedeme objekt StringBuilder na řetězec.
Níže uvedený program zobrazuje kód Java pro převod mapy na řetězec.
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()); } }Výstup:
Daná mapa: {20 = dvacet, 40 = čtyřicet, 10 = deset, 30 = třicet}
Řetězcová reprezentace mapy:
{20 = dvacet, 40 = čtyřicet, 10 = deset, 30 = třicet}
Používání streamů Java 8
V této metodě vytvoříme stream z mapových klíčů a poté jej převedeme na řetězec.
Níže uvedený program ukazuje převod mapy na řetězec pomocí proudů.
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); } }Výstup:
Daná mapa: {20 = dvacet, 40 = čtyřicet, 10 = deset, 30 = třicet}
Řetězcová reprezentace mapy:
{20 = dvacet, 40 = čtyřicet, 10 = deset, 30 = třicet}
Převést mapu na seznam v Javě
Mapa se skládá z klíčů a hodnot, zatímco seznam je posloupností jednotlivých prvků. Při převodu mapy na seznam obvykle převádíme klíče do seznamu klíčů a hodnot do seznamu hodnot.
Následující program Java ukazuje tuto konverzi.
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); } }Výstup:
Seznam klíčů z dané mapy:
(50, 20, 40, 10, 30)
Seznam hodnot z dané mapy:
(purpurová, zelená, azurová, červená, modrá)
Slovník vs. Mapa v Javě
Pojďme se bavit o hlavních rozdílech mezi slovníkem a mapou v Javě.
| Slovník | Mapa |
|---|---|
| Slovník je abstraktní třída. | Mapa je rozhraní. |
| Třídy a metody používané třídou slovníku předcházejí rámci kolekcí. | Třídy a metody používané třídami map jsou součástí rámce kolekce. |
| Pokud třída rozšiřuje slovník, nemůže rozšířit žádnou jinou třídu, protože Java podporuje pouze jednu dědičnost | Mapa je rozhraní, takže třída může dědit z mapy a dalších rozhraní |
| Stará implementace. V novějších verzích Java je téměř zastaralý. | Mapové rozhraní nahradilo implementaci slovníku. |
Často kladené otázky
Otázka č. 1) Proč používáme mapové rozhraní v Javě?
Odpovědět: Mapa je rozhraní v Javě, které je implementováno třídami ukládajícími data jako páry klíč – hodnota. Rozhraní mapy poskytuje operace / metody, které lze provádět na párech klíč – hodnota, jako je vkládání, aktualizace, mazání atd.
Otázka č. 2)Co znamená MAP v Javě?
Odpovědět: Mapa v Javě představuje mapování klíče se specifickou hodnotou. Mapa Java ukládá tyto páry klíč – hodnota na mapu. Můžeme vyhledat a načíst hodnotu spojenou s klíčem pouhým použitím klíče v mapě.
Mapa je implementována v Javě pomocí rozhraní, které není součástí rozhraní Collection. Ale mapa je sbírka.
Otázka č. 3)Co je MAP získat?
Odpovědět: Get () je metoda poskytovaná mapovým rozhraním v Javě, která se používá k načtení hodnoty spojené s konkrétním klíčem poskytnutým jako argument metodě get (). Pokud hodnota není k dispozici, vrátí se null.
Otázka č. 4)Je mapa sbírka?
Odpovědět: Ačkoli se mapa obecně zobrazuje jako kolekce, neimplementuje rozhraní kolekce. Některé z implementací mapy, například treemap, nepodporuje hodnoty null ani klíče.
Otázka č. 5)Jaký je rozdíl mezi sadou a mapou?
Odpovědět: Sada je pouze kolekce klíčů, zatímco mapa je kolekce párů klíč-hodnota. Zatímco sada neumožňuje hodnoty null, některé implementace mapy umožňují hodnoty null.
Sada neumožňuje duplicitní klíče. Mapa může umožňovat duplicitní hodnoty, ale klíče musí být jedinečné. Sada se obvykle používá, když chceme uložit kolekci jedinečných prvků. Mapu lze použít, když potřebujeme ukládat data ve formě párů klíč – hodnota.
Závěr
V tomto tutoriálu jsme probrali základy mapového rozhraní. Také jsme viděli různé metody a všechny další podrobnosti týkající se mapového rozhraní v Javě. Zjistili jsme, že existují různé implementace mapových rozhraní, včetně treemap, hashmap atd.
V našich připravovaných tutoriálech budeme podrobněji diskutovat o této implementaci mapy.
=> Navštivte zde a dozvíte se Java od začátku.
Doporučené čtení
- Co je HashMap v Javě?
- TreeMap v Javě - výuka s příklady Java TreeMap
- LinkedHashMap v Javě - příklad a implementace LinkedHashMap
- Set Interface In Java: Java Set Tutorial With examples
- Výukový program JAVA pro začátečníky: 100+ praktických výukových programů Java Video
- Výukový program Java Stack: Implementace třídy zásobníku s příklady
- Výukový program Java Reflection s příklady
- Jagged Array In Java - výukový program s příklady