java map interface tutorial with implementation examples
Tento komplexný výukový program pre mapy Java obsahuje informácie o tom, ako vytvárať, inicializovať a iterovať mapy. Dozviete sa tiež o mapových metódach a príkladoch implementácie:
Osvojíte si základy mapového rozhrania, metódy podporované mapovým rozhraním a ďalšie špecifické pojmy súvisiace s mapovým rozhraním.
Zbierka máp v Jave je kolekcia, ktorá mapuje kľúč k hodnote. Je to zbierka pozostávajúca z kľúčov a hodnôt. Každý záznam na mape pozostáva z kľúča s príslušnou hodnotou. Kľúče sú v mapách jedinečné. Mapy sa dajú zvyčajne použiť, keď potrebujeme upraviť kolekciu na základe kľúčovej hodnoty.
=> Skontrolujte VŠETKY návody Java tu.
Čo sa dozviete:
- Mapy v Jave
- Mapové metódy
- Implementácia mapy Java
- Záver
Mapy v Jave
Mapa v Jave je súčasťou rozhrania java.util.map. Rozhranie mapy nie je súčasťou rozhrania zbierky, a preto sa mapy líšia od ostatných zbierok.
Všeobecná hierarchia rozhrania mapy je uvedená nižšie.
Ako je uvedené vyššie, na implementáciu mapy existujú dve rozhrania, t. J. Mapové rozhranie a triedené rozhranie. Existujú tri triedy, tj. HashMap, TreeMap a LinkedHashMap.
Tieto typy máp sú opísané nižšie:
| Trieda | Popis | |
|---|---|---|
| odstrániť | V remove (kľúč objektu) | Odstráňte záznam na mape pre daný kľúč |
| LinkedHashMap | Vychádza z triedy HashMap. Táto mapa udržuje poradie vloženia | |
| HashMap | Implementujte mapové rozhranie. HashMap nezachováva žiadne poradie. | |
| TreeMap | Implementuje rozhranie mapy aj triedenej mapy. TreeMap udržuje vzostupné poradie. |
Body, ktoré si treba pamätať na mapách.
- Na mapách môže každý kláves mapovať najviac jednu hodnotu. Na mapách tiež nemôžu byť duplicitné kľúče.
- Implementácie máp ako HashMap a LinkedHashMap umožňujú nulový kľúč a nulové hodnoty. TreeMap to však neumožňuje.
- Po mape nemožno prechádzať tak, ako je. Preto pri prechode je potrebné ho konvertovať na nastavenie pomocou metódy keyset () alebo entrySet ().
Vytvorte mapu v Jave
Aby sme vytvorili mapu v Jave, najskôr musíme do nášho programu zahrnúť rozhranie. Na importovanie funkcie mapy môžeme použiť jeden z nasledujúcich príkazov v programe.
import java.util.*; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.TreeMap; Musíme vytvoriť inštanciu konkrétnej implementácie mapy, pretože ide o rozhranie.
Nasledujúce príkazy vytvárajú mapu v prostredí Java.
Map hash_map = new HashMap(); Map tree_map = new TreeMap(); Vyššie uvedené vyhlásenia vytvoria mapy s predvolenými špecifikáciami.
Môžeme tiež vytvoriť všeobecné mapy určujúce typy kľúčov aj hodnôt.
Map myMap = new HashMap(); Vyššie uvedená definícia bude mať ako hodnoty kľúče typu string a objekty.
Inicializácia mapy v prostredí Java
Môže sa inicializovať pomocou nasledujúcich metód:
# 1) Používanie zbierok
Trieda Java Collections obsahuje továrenské metódy, ktoré možno použiť na inicializáciu zbierok vrátane máp.
Niektoré metódy používané na inicializáciu mapy sú:
(1) Collections.EmptyMap ()
Collections.EmptyMap () vracia serializovateľnú a nemennú mapu, ktorá je prázdna. Napríklad, nasledujúci riadok kódu,
Map myMap = Collections.EMPTY_MAP; Takto sa vytvorí prázdna mapa. Vyššie uvedená metóda môže vyvolať „upozornenie na nekontrolované priradenie“, a preto môžeme tiež použiť nasledujúci formulár pre bezpečný typ.
Map myMap = Collections.emptyMap (); (2) Collections.unModifiableMap ()
Metóda unModifiableMap () berie ako argument inú mapu a vytvorí nemodifikovateľný pohľad na pôvodnú mapu.
Map myMap = Collections.EMPTY_MAP; Map map_unmodifiable = Collections.unmodifiableMap (myMap); (3) Collections.singletonMap ()
Trieda Collections tiež poskytuje továrenskú metódu 'singletonMap ()', ktorá vytvára nemennú mapu singletonov, ktorá má iba jednu položku.
Map singleton_map = Collections.singletonMap('CHN', 'Beijing'); # 2) Používanie Java 8
Môžeme získať prúd dát z metód Java 8 stream API a vytvárať mapy pomocou Collectors.
Niektoré z metód na zostavenie máp sú:
(1) Collectors.toMap ()
Zhromaždíme stream a potom pomocou metódy Collectors.toMap () zostrojíme mapu.
Map map = Stream.of(new String()(){{'USA', 'Washington'}, {'United Kingdom', 'London'} }).collect(Collectors.toMap(p -> p(0), p -> p(1))); Vyššie uvedené vyhlásenie vytvorí mapu z toku Java 8.
(2) Collectors.collectingAndThen ()
V tomto prispôsobujeme metódu toMap (), ktorá umožňuje zberateľovi vytvoriť nemennú mapu pomocou metódy 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žitie metódy put rozhrania mapy
Na priradenie počiatočných hodnôt k mapám je možné použiť metódu put () rozhrania mapy.
# 4) Použitie inicializácie dvojitej zátvorky
Technika „inicializácie dvojitej zátvorky“ vytvára vnútornú triedu. Táto trieda je anonymná a má v sebe inicializátor inštancie. Toto nie je preferovaná technika a je potrebné sa mu vyhnúť, pretože by to mohlo viesť k úniku pamäte alebo problémom so serializáciou.
Nasledujúci program zobrazuje rôzne spôsoby inicializácie mapy, ktoré sú popísané vyššie.
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ýkon:
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 mapy: {USA = Washington, GER = Berlín, Spojené kráľovstvo = Londýn, IND = Dillí}
Iterácia nad mapou v Jave a tlač mapy
Môžeme prechádzať po mape rovnakým spôsobom, akým prechádzame ostatné zbierky. Okrem prechádzania záznamov na mape môžeme prechádzať aj iba kľúče alebo iba hodnoty na mape. Upozorňujeme, že na prechádzanie mapou je potrebné ju najskôr konvertovať na nastavenie.
Na prechádzanie položkami mapy sa používajú nasledujúce metódy.
Pomocou vstupného iterátora
V tejto metóde získame vstupný iterátor zo vstupnej sady. Potom pomocou metód getKey a getValue získame pár kľúč - hodnota pre každú položku mapy.
Nasledujúci program ukazuje použitie vstupného iterátora.
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ýkon:
Položky na mape sú:
KĽÚČOVÁ HODNOTA
CH Chennai
DL Nové Dillí
MH Bombaj
Vo vyššie uvedenom programe získame vstupný iterátor z mapy pomocou metódy entrySet. Potom prechádzame po mape metódou vstupného iterátora hasNext () a tlačíme pár kľúč - hodnota.
Použitie záznamu pre každú slučku
Tu prechádzame vstupnou sadou pomocou slučky for-each a implementácia je uvedená nižšie.
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ýkon:
Položky na mape sú:
KĽÚČOVÁ HODNOTA
CH Chennai
DL Nové Dillí
MH Bombaj
Mapové metódy
Mapové rozhranie v Jave podporuje rôzne operácie podobné tým, ktoré sú podporované v iných kolekciách. V tejto časti si rozoberieme rôzne metódy poskytované rozhraním Map API v Jave. Pretože rozsah tohto tutoriálu je obmedzený na všeobecné predstavenie mapového rozhrania, nebudeme tieto metódy popisovať.
O týchto metódach sa budeme podrobne rozprávať pri diskusii o triedach mapových rozhraní.
V nasledujúcej tabuľke sú uvedené všetky metódy poskytované mapovým rozhraním API.
| Názov metódy | Metóda Prototyp | Popis |
|---|---|---|
| dostať | V get (kľúč objektu) | Vráti objekt alebo hodnotu pre daný kľúč |
| dať | V put (kľúč objektu, hodnota objektu) | Vložte záznam kľúč - hodnota do mapy |
| putAll | void putAll (Mapa mapa) | Vložte dané mapové položky do mapy. Inými slovami kopíruje alebo klonuje mapu. |
| keySet | Set keySet () | Vráti nastavené zobrazenie mapy. |
| entrySet | Nastaviť | Vráti nastavenie zobrazenia pre danú mapu |
| hodnoty | Hodnoty zbierky () | Vráti zobrazenie kolekcie hodnôt na mape. |
| veľkosť | veľkosť int () | Vráti počet záznamov na mape |
| jasný | prázdnota clear () | Vymaže mapu |
| je prázdny | boolean isEmpty () | Skontroluje, či je mapa prázdna, a vráti hodnotu true, ak áno. |
| containsValue | boolean containsValue (hodnota objektu) | Vráti hodnotu true, ak mapa obsahuje hodnotu rovnajúcu sa danej hodnote |
| obsahujeKey | boolean containsKey (kľúč objektu) | Vráti hodnotu true, ak daný kľúč na mape existuje |
| rovná sa | boolean equals (Objekt o) | Porovná zadaný objekt o s mapou |
| hashCode | int hashCode () | vráti hash kód pre Mapu |
| pre každý | void forEach (BiConsumer action) | Vykoná danú akciu pre každú položku na mape |
| getOrDefault | V getOrDefault (kľúč objektu, V defaultValue) | Vráti zadanú hodnotu pre daný kľúč alebo jeho predvolenú hodnotu, ak kľúč nie je k dispozícii |
| odstrániť | boolean remove (kľúč objektu, hodnota objektu) | Odstráni zadané kľúče a hodnoty |
| vymeniť | V nahradiť (kláves K, hodnota V) | Nahradí daný kľúč zadanou hodnotou |
| vymeniť | boolovská zámena (kláves K, V oldValue, V newValue) | Nahradí starú hodnotu novou hodnotou pre daný kľúč |
| nahradiť všetko | void replaceAll (funkcia BiFunction) | Vyvolá danú funkciu a nahradí všetky položky na mape |
| putIfAbsent | V putIfAbsent (kľúč K, hodnota V) | Vloží daný kľúč, hodnotu, iba ak ešte nie je prítomný |
| vypočítať | Výpočet V (kláves K, BiFunction remappingFunction) | Vypočíta mapovanie pre zadaný kľúč a hodnotu danú funkciou mapovania. |
| computeIfAbsent | V computeIfAbsent (kláves K, Function mappingFunction) | Vypočítajte hodnotu pre daný kľúč pomocou funkcie mapovania, ak ešte nie je k dispozícii. |
| computeIfPresent | V computeIfPresent (kláves K, BiFunction remappingFunction) | Vypočíta nové mapovanie pre daný kľúč s danou funkciou premapovania, ak je už hodnota kľúča k dispozícii |
| choď | Zlúčenie V (kláves K, hodnota V, BiFunction remappingFunction) | Priradí daný kľúč k hodnote, ak ešte nie je priradená alebo je spojená s nulovou hodnotou. |
Všetky vyššie uvedené metódy podporuje mapové rozhranie. Všimnite si, že tieňované metódy sú nové metódy, ktoré boli obsiahnuté v prostredí Java 8.
Implementácia mapy Java
Nasledujúci program implementuje príklad mapy v Jave. Tu používame väčšinu vyššie diskutovaných metód.
Tento príklad demonštruje rôzne operácie 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ýkon:
Kľúč = CHN, hodnota: Čína
Kľúč = XX, hodnota: null
null keyExists: true, null valueExists = true
množina položiek pre mapu country_map: (null = Z, XX = null, CHN = Čína, SL = Srilanka, IND = India, KOR = Kórea)
Veľkosť mapy krajiny: 6
mapa údajov mapovaná do mapy krajín: {null = Z, XX = null, CHN = Čína, SL = Srilanka, IND = India, KOR = Kore
do}
hodnota nulového kľúča pre data_map: Z
data_map po odstránení nulového kľúča = {XX = nulový, CHN = Čína, SL = Srilanka, IND = India, KOR = Kórea}
kľúče dátových máp: (null, XX, CHN, SL, IND, KOR)
hodnoty údajovej mapy: (Z, null, Čína, Srílanka, India, Kórea)
dátová mapa po vyčistení, je prázdna: true
Triedenie mapy v Jave
Pretože mapa pozostáva z párov kľúč - hodnota, môžeme mapu triediť podľa kľúčov alebo hodnôt.
V tejto časti zoradíme mapu podľa kľúčov aj hodnôt.
Zoradiť podľa kľúča
Na zoradenie mapy podľa kľúčov môžeme použiť stromovú mapu. Treemap triedi klávesy automaticky. Nižšie uvedený program Java prevádza mapu na mapu stromu a zobrazuje zoradené kľúč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ýkon:
Pôvodná netriedená mapa:
Amerika
C Čína
D Dánsko
X Hongkong
Ja India
Mapa zoradená podľa kľúča:
Amerika
C Čína
D Dánsko
Ja India
X Hongkong
Vyššie uvedený program vytvára mapu pozostávajúcu z jediného abecedného kódu ako kľúčov a názvov krajín ako hodnôt. Najskôr zobrazíme pôvodnú mapu, ktorá nie je zoradená. Potom mapu prevedieme na mapu stromu, ktorá automaticky triedi kľúče. Nakoniec na klávesoch zobrazíme zoradenú stromovú mapu.
Zoradiť podľa hodnoty
Aby sme mapu zoradili na základe hodnôt, najskôr ju prevedieme do zoznamu. Potom tento zoznam triedime pomocou metódy Collections.sort (), ktorá pomocou komparátora porovnáva hodnoty a usporiada ich v konkrétnom poradí.
Po zoradení zoznamu sa prepojené položky zoznamu znova skopírujú na mapu, ktorá nám poskytne zoradenú mapu.
Nasledujúci program Java demonštruje triedenie mapy na základe hodnoty. Program používa LinkedHashMap, ktorá sa odovzdáva funkcii triedenia. Vo funkcii triedenia sa prevedie na prepojený zoznam a zoradí sa. Po zoradení sa prevedie späť na LinkedHashMap.
kde nájdem svoj kľúč zabezpečenia siete
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ýkon:
Pôvodná netriedená mapa:
{NEP = Káthmandu, IND = Nové Dillí, USA = Washington, Spojené kráľovstvo = Londýn, AUS = Canberra
Mapa zoradená podľa hodnoty:
Kľúčová hodnota
Z Canberry
NEP Káthmandu
UK London
IND Nové Dillí
USA Washington
Súbežná mapa v Jave
ConcurrentMap je rozhranie, ktoré dedí z rozhrania java.util.map. Rozhranie concurrentMap bolo prvýkrát predstavené v JDK 1.5 a poskytuje mapu, ktorá spracováva súbežný prístup.
Rozhranie concurrentMap je súčasťou balíka java.util.concurrent.
Nasledujúci program Java demonštruje concurrentMap v jazyku 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); } }Výkon:
Počiatočná súbežná mapa: {100 = červená, 101 = zelená, 102 = modrá}
Po pridaní chýbajúceho kľúča 103: {100 = červená, 101 = zelená, 102 = modrá, 103 = fialová}
Súbežná mapa po odstránení 101: {100 = červená, 102 = modrá, 103 = fialová}
Pridajte neprítomný kľúč 101: {100 = červená, 101 = hnedá, 102 = modrá, 103 = fialová}
Nahraďte hodnotu na kľúči 101: {100 = červená, 101 = zelená, 102 = modrá, 103 = fialová}
Synchronizovaná mapa v Jave
Synchronizovaná mapa je mapa, ktorá je bezpečná voči vláknam a je podložená danou mapou. V Jave sa Synchronizovaná mapa získava pomocou metódy synchronizedMap () triedy java.util.Collections. Táto metóda vráti synchronizovanú mapu pre danú mapu.
ako otvárať súbory SWF na Chrome
Táto vrátená synchronizovaná mapa sa používa na prístup k podkladovej mape na dosiahnutie sériového prístupu.
Všeobecné vyhlásenie metódy synchronizedMap () je:
public static Map synchronizedMap(Map m) kde m => je podkladová mapa.
Ako už bolo spomenuté, táto metóda vracia synchronizované zobrazenie mapy m.
Nižšie uvedený program Java je príkladom synchronizovanej 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); } } Výkon:
Originálna (zálohovaná) mapa: {1 = 10, 2 = 20, 3 = 30, 4 = 40, 5 = 50}
Synchronizovaná mapa po odstránení (3, 30): {1 = 10, 2 = 20, 4 = 40, 5 = 50}
Statická mapa v Jave
Statická mapa v Jave je mapa, ktorá je vyhlásená za statickú rovnako ako statická premenná. Vyhlásením mapy za statickú sa stane prístupnou premennou triedy bez použitia objektu.
Existujú dva prístupy k vytvoreniu a inicializácii statickej mapy v Jave.
# 1) Použitie statickej premennej
Tu vytvoríme premennú statickej mapy a vytvoríme jej inštanciu spolu s deklaráciou.
Tento prístup je demonštrovaný v nasledujúcom programe 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ýkon:
Statická mapa pomocou premennej statickej mapy:
{1 = India, 2 = Portugalsko, 3 = Nemecko}
# 2) Použitie statického bloku
V tomto vytvoríme premennú statickej mapy. Potom vytvoríme statický blok a vo vnútri tohto statického bloku inicializujeme premennú mapy.
Nasledujúci program to demonštruje.
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ýkon:
Statická mapa pomocou statického bloku:
{1 = červená, 2 = zelená, 3 = modrá}
Konverzia zoznamu na mapu
V tejto časti sa budeme zaoberať metódami prevodu zoznamu na mapu.
Tieto dve metódy zahŕňajú:
Tradičná metóda
Pri tradičnej metóde sa každý prvok zoznamu kopíruje do mapy pomocou slučky pre každú z nich.
Táto implementácia je uvedená nižšie:
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ýkon:
Uvedený zoznam: (červená, zelená, modrá, hnedá, biela)
Mapa vygenerovaná zo zoznamu: {1 = červená, 2 = zelená, 3 = modrá, 4 = hnedá, 5 = biela}
Zoznam na mape v prostredí Java 8
Môžeme tiež použiť metódu Collectors.mapOf () v jazyku Java 8, ktorá prevedie daný zoznam na mapu.
Nasledujúci program to demonštruje.
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ýkon:
Mapa získaná zo zoznamu: {1 = Počítadlo, 2 = Matematika, 3 = Fyzika, Chémia}
V tomto programe máme triedu Subjekt, ktorá funguje ako trieda zoznamu. Trieda Subjekt má dve polia, tj. Sub_id a sub_name. Máme metódy na načítanie hodnôt poľa z triedy. V hlavnej funkcii vytvárame objekty tejto triedy a zostavujeme zoznam.
Tento zoznam sa potom prevedie na mapu pomocou metódy Collectors.MapOf, ktorá preberá prvky jeden po druhom. Berie tiež sub_Id ako kľúč na mapu. Nakoniec sa vygeneruje mapa, ktorá má ako kľúč sub_Id a ako hodnotu Sub_Name.
Prevod mapy na reťazec v Jave
Zbierku máp je možné previesť na reťazec pomocou dvoch prístupov:
Pomocou StringBuilder
Tu vytvoríme objekt StringBuilder a potom skopírujeme páry kľúč - hodnota mapy do objektu StringBuilder. Potom prevedieme objekt StringBuilder na reťazec.
Nasledujúci program zobrazuje kód Java na prevod mapy na reťazec.
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ýkon:
Daná mapa: {20 = dvadsať, 40 = štyridsať, 10 = desať, 30 = tridsať}
Reťazcové znázornenie mapy:
{20 = dvadsať, 40 = štyridsať, 10 = desať, 30 = tridsať}
Používanie streamov Java 8
V tejto metóde vytvoríme prúd z mapových kľúčov a potom ho prevedieme na reťazec.
Program uvedený nižšie zobrazuje prevod mapy na reťazec pomocou prúdov.
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ýkon:
Daná mapa: {20 = dvadsať, 40 = štyridsať, 10 = desať, 30 = tridsať}
Reťazcové znázornenie mapy:
{20 = dvadsať, 40 = štyridsať, 10 = desať, 30 = tridsať}
Preveďte mapu na zoznam v prostredí Java
Mapa sa skladá z kľúčov a hodnôt, zatiaľ čo zoznam je postupnosťou jednotlivých prvkov. Pri konverzii mapy na zoznam obvykle prevádzame kľúče na zoznam kľúčov a hodnoty do zoznamu hodnôt.
Nasledujúci program Java zobrazuje túto konverziu.
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ýkon:
Zoznam kľúčov od danej mapy:
(50, 20, 40, 10, 30)
Zoznam hodnôt z danej mapy:
(purpurová, zelená, azúrová, červená, modrá)
Slovník vs. Mapa v Jave
Poďme si predstaviť niektoré hlavné rozdiely medzi slovníkom a mapou v Jave.
| Slovník | Mapa |
|---|---|
| Slovník je abstraktná trieda. | Mapa je rozhranie. |
| Triedy a metódy používané triedou slovníka predchádzajú rámcu zbierok. | Triedy a metódy používané triedami máp sú súčasťou rámca zbierky. |
| Ak trieda rozširuje slovník, nemôže rozšíriť žiadnu inú triedu, pretože Java podporuje iba jednu dedičnosť | Mapa je rozhranie, takže trieda môže dediť z mapy a iných rozhraní |
| Stará implementácia. V novších verziách Java je takmer zastaraný. | Mapové rozhranie nahradilo implementáciu slovníka. |
často kladené otázky
Otázka 1) Prečo používame mapové rozhranie v Jave?
Odpoveď: Mapa je rozhranie v Jave, ktoré je implementované triedami ukladajúcimi údaje ako páry kľúč - hodnota. Rozhranie mapy poskytuje operácie / metódy, ktoré je možné vykonávať na pároch kľúč - hodnota, ako je vkladanie, aktualizácia, mazanie atď.
Otázka č. 2)Čo znamená MAP v Jave?
Odpoveď: Mapa v Jave predstavuje mapovanie kľúča so špecifickou hodnotou. Mapa Java uchováva tieto páry kľúč - hodnota na mape. Môžeme vyhľadať a získať hodnotu spojenú s kľúčom iba pomocou kľúča na mape.
Mapa je implementovaná v prostredí Java pomocou rozhrania, ktoré nie je súčasťou rozhrania kolekcie. Ale mapa je zbierka.
Otázka č. 3)Čo je to MAP?
Odpoveď: Get () je metóda poskytovaná mapovým rozhraním v Jave, ktorá sa používa na získanie hodnoty spojenej s konkrétnym kľúčom poskytnutú ako argument pre metódu get (). Ak hodnota nie je k dispozícii, vráti sa null.
Otázka č. 4)Je mapa zbierkou?
Odpoveď: Aj keď sa mapa všeobecne považuje za kolekciu, neimplementuje rozhranie kolekcie. Niektoré z implementácií mapy, napríklad treemap, nepodporuje nulové hodnoty ani kľúče.
Otázka č. 5)Aký je rozdiel medzi sadou a mapou?
Odpoveď: Sada je iba kolekcia kľúčov, zatiaľ čo mapa je kolekcia párov kľúč - hodnota. Aj keď množina neumožňuje nulové hodnoty, niektoré implementácie mapy umožňujú nulové hodnoty.
Sada neumožňuje duplicitné kľúče. Mapa môže umožňovať duplicitné hodnoty, ale kľúče musia byť jedinečné. Sada sa zvyčajne používa, keď chceme uložiť kolekciu jedinečných prvkov. Mapu je možné použiť, keď potrebujeme ukladať údaje vo forme párov kľúč - hodnota.
Záver
V tomto tutoriáli sme prebrali základné informácie o mapovom rozhraní. Tiež sme videli rôzne metódy a všetky ďalšie podrobnosti týkajúce sa mapového rozhrania v Jave. Dozvedeli sme sa, že existujú rôzne implementácie mapových rozhraní vrátane treemap, hashmap atď.
V našich pripravovaných tutoriáloch sa budeme podrobnejšie zaoberať touto implementáciou mapy.
=> Navštívte tu a dozviete sa Java od začiatku.
Odporúčané čítanie
- Čo je HashMap v Jave?
- TreeMap In Java - návod s príkladmi Java TreeMap
- LinkedHashMap v Jave - Príklad a implementácia LinkedHashMap
- Nastaviť rozhranie v prostredí Java: Výukový program sady Java s príkladmi
- Výukový program JAVA pre začiatočníkov: viac ako 100 praktických výučbových programov Java Video
- Výukový program Java Stack: Implementácia triedy Stack s príkladmi
- Výukový program Java Reflection s príkladmi
- Jagged Array In Java - návod s príkladmi