java map interface tutorial with implementation examples
Ova sveobuhvatna lekcija za Java mapu pokriva kako stvoriti, inicijalizirati i obraditi pomoću Mapsa. Također ćete naučiti o metodama karata i primjerima implementacije:
Upoznat ćete osnove sučelja karte, metode podržane sučeljem karte i druge specifične pojmove povezane sa sučeljem karte.
Zbirka mapa u Javi zbirka je koja preslikava ključ vrijednosti. To je zbirka koja se sastoji od ključeva i vrijednosti. Svaki unos na karti sastoji se od ključa s pripadajućom vrijednošću. Tipke su jedinstvene na kartama. Karte se obično mogu koristiti kada moramo izmijeniti zbirku na temelju vrijednosti ključa.
=> Ovdje provjerite SVE Java tutorijale.
Što ćete naučiti:
- Karte u Javi
- Metode mapiranja
- Implementacija Java Mape
- Zaključak
Karte u Javi
Karta u Javi dio je sučelja java.util.map. Sučelje karte nije dio sučelja zbirke i to je razlog zbog kojeg se karte razlikuju od ostalih zbirki.
Općenita hijerarhija sučelja karte prikazana je u nastavku.
Kao što je gore prikazano, postoje dva sučelja za implementaciju karte, tj. Sučelje karte i sučelje sortedMap. Postoje tri klase, tj. HashMap, TreeMap i LinkedHashMap.
U nastavku su opisane ove vrste karata:
Razred | Opis | |
---|---|---|
ukloniti | V uklanjanje (tipka objekta) | Izbrišite unos karte za zadani ključ |
LinkedHashMap | Proširuje se iz klase HashMap. Ova karta održava redoslijed umetanja | |
HashMap | Implementirati sučelje karte. HashMap ne održava redoslijed. | |
TreeMap | Provodi sučelje map i sortedMap. TreeMap održava uzlazni poredak. |
Bodovi koje treba zapamtiti o kartama.
- Na kartama se svaki ključ može preslikati na najviše jednu vrijednost. Također, na kartama ne mogu biti duplicirani ključevi.
- Implementacije mapa poput HashMap i LinkedHashMap omogućuju null i null vrijednosti. Međutim, TreeMap to ne dopušta.
- Zemljovid se ne može prevaliti takav kakav je. Stoga ga je za pretjecanje potrebno pretvoriti u set pomoću metode keyset () ili entrySet ().
Stvorite mapu na Javi
Da bismo stvorili kartu u Javi, prvo moramo uključiti sučelje u naš program. Za uvoz funkcije karte možemo koristiti jednu od sljedećih izjava u programu.
import java.util.*; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.TreeMap;
Moramo izvesti konkretnu implementaciju karte jer je ona sučelje.
Sljedeće izjave stvaraju mapu u Javi.
Map hash_map = new HashMap(); Map tree_map = new TreeMap();
Gornje izjave stvorit će karte sa zadanim specifikacijama.
Također možemo stvoriti generičke mape navodeći vrste i za ključ i za vrijednost.
Map myMap = new HashMap();
Gornja će definicija kao vrijednosti imati ključeve tipa string i objekte.
Inicijalizirajte kartu u Javi
Može se inicijalizirati pomoću sljedećih metoda:
# 1) Korištenje zbirki
Klasa Java Collections ima tvorničke metode koje se mogu koristiti za inicijalizaciju zbirki, uključujući karte.
Neke metode koje se koriste za inicijalizaciju mape su kako slijedi:
(1) Zbirke.EmptyMap ()
Collections.EmptyMap () vraća serijsku i nepromjenjivu kartu koja je prazna. Na primjer, sljedeći redak koda,
Map myMap = Collections.EMPTY_MAP;
Ovo će stvoriti praznu kartu. Gornja metoda može izbaciti 'upozorenje o neprovjerenom dodjeljivanju', pa stoga također možemo koristiti obrazac za siguran tip, kako slijedi.
Map myMap = Collections.emptyMap ();
(2) Zbirke.unModifiableMap ()
Metoda unModifiableMap () uzima drugu kartu kao argument i stvara neizmijenjivi prikaz izvorne karte.
Map myMap = Collections.EMPTY_MAP; Map map_unmodifiable = Collections.unmodifiableMap (myMap);
(3) Zbirke.singletonMap ()
Klasa zbirki također nudi tvorničku metodu ‘singletonMap ()’ koja stvara nepromjenjivu singleton mapu koja ima samo jedan unos.
Map singleton_map = Collections.singletonMap('CHN', 'Beijing');
# 2) Korištenje Jave 8
Možemo dobiti tok podataka iz Java 8 stream API metoda i konstruirati karte pomoću Collectors-a.
Neke od metoda za izgradnju mapa su:
(1) Collectors.toMap ()
Prikupljamo tok, a zatim koristimo metodu Collectors.toMap () za izgradnju mape.
Map map = Stream.of(new String[][]{{'USA', 'Washington'}, {'United Kingdom', 'London'} }).collect(Collectors.toMap(p -> p[0], p -> p[1]));
Gornja izjava stvara mapu iz Java 8 toka.
(2) Collectors.collectingAndThen ()
U ovome prilagođavamo metodu toMap () koja kolektoru omogućuje izradu nepromjenjive mape metodom collectionAndThen ().
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) Korištenjem metode put sučelja karte
Metoda put () sučelja karte može se koristiti za dodjeljivanje početnih vrijednosti kartama.
# 4) Korištenje inicijalizacije Double Brace
Tehnika 'inicijalizacija dvostrukim zagradama' stvara unutarnju klasu. Ova je klasa anonimna i u sebi ima inicijalizator instance. To nije preferirana tehnika i treba je izbjegavati jer može dovesti do curenja memorije ili problema sa serializacijom.
Program u nastavku prikazuje razne metode inicijalizacije karte o kojima je ranije bilo riječi.
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); } }
Izlaz:
vrijednosti karte nemodificirane karte: {}
Vrijednosti karte singleton_map: {10 = TEN}
vrijednosti map_cities: {CH = Chennai, DL = New Delhi, MH = Mumbai}
capitals_Map vrijednosti: {MAH = Mumbai, GOA = Panaji, KAR = Bangaluru}
Vrijednosti karte: {USA = Washington, GER = Berlin, UK = London, IND = Delhi}
Ponavljajte kartu na Javi i ispišite kartu
Zemljovid možemo prelaziti na isti način kao i ostale zbirke. Osim prelaska preko unosa na karti, također možemo prelaziti samo tipke ili samo vrijednosti na karti. Imajte na umu da je za preslikavanje karte potrebno prvo pretvoriti da bi se postavila.
Sljedeće se metode koriste za prelazak unosa na karti.
Korištenje Entre Iteratora
Ovom metodom dobivamo iterator unosa iz skupa unosa. Zatim pomoću metoda getKey i getValue dohvaćamo par ključ / vrijednost za svaki unos karte.
Sljedeći program prikazuje upotrebu iteratora unosa.
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()); } } }
Izlaz:
Unosi na karti su:
KLJUČNA VRIJEDNOST
CH Chennai
DL New Delhi
MH Mumbai
U gore navedenom programu s karte dobivamo iterator unosa metodom entrySet. Zatim prelazimo kartu koristeći hasNext () metodu iteratora unosa i ispisujemo par ključ / vrijednost.
Korištenje unosa za svaku petlju
Ovdje prelazimo entrySet koristeći for-svaka petlja, a implementacija je prikazana u nastavku.
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()); } } }
Izlaz:
Unosi na karti su:
KLJUČNA VRIJEDNOST
CH Chennai
DL New Delhi
MH Mumbai
Metode mapiranja
Sučelje karte u Javi podržava razne operacije slične onima koje podržavaju druge zbirke. U ovom ćemo odjeljku razgovarati o raznim metodama koje Map API nudi u Javi. Budući da je opseg ovog vodiča ograničen na uvođenje sučelja karte općenito, nećemo opisivati ove metode.
O ovim ćemo metodama detaljno razgovarati dok ćemo razgovarati o klasama sučelja karte.
Sljedeća tablica navodi sve metode koje pruža API mape.
Naziv metode | Prototip metode | Opis |
---|---|---|
dobiti | V get (tipka objekta) | Vraća objekt ili vrijednost za zadani ključ |
staviti | V put (ključ objekta, vrijednost objekta) | Na kartu umetnite unos ključ / vrijednost |
staviSve | void putAll (karta na karti) | Na kartu umetnite zadane unose na karti. Drugim riječima, kopira ili klonira kartu. |
keySet | Postavi keySet () | Vraća postavljeni prikaz karte. |
entrySet | Postavi | Povratak postavlja prikaz za datu kartu |
vrijednosti | Vrijednosti zbirke () | Vraća prikaz zbirke vrijednosti na karti. |
veličina | veličina int () | Vraća broj unosa na karti |
čisto | void clear () | Briše kartu |
prazno je | logički isEmpty () | Provjerava je li karta prazna i vraća li vrijednost true ako da. |
sadržiVrijednost | boolean containsValue (vrijednost objekta) | Vraća true ako karta sadrži vrijednost jednaku zadanoj vrijednosti |
sadržiKljuč | boolean containsKey (ključ objekta) | Vraća true ako na karti postoji zadani ključ |
jednako | boolean jednako (Objekt o) | Uspoređuje navedeni objekt o s mapom |
hashCode | int hashCode () | vraća hash kod za Map |
za svakoga | void forEach (BiConsumer akcija) | Izvodi zadanu radnju za svaki unos na karti |
getOrDefault | V getOrDefault (Tipka objekta, V defaultValue) | Vraća specificiranu vrijednost za zadani ključ ili njegovu zadanu vrijednost ako ključ nije prisutan |
ukloniti | logičko uklanjanje (ključ objekta, vrijednost objekta) | Uklanja određene ključeve i vrijednosti |
zamijeniti | V zamjena (tipka K, vrijednost V) | Zamjenjuje dati ključ navedenom vrijednošću |
zamijeniti | logička zamjena (tipka K, V oldValue, V newValue) | Zamjenjuje staru vrijednost novom vrijednošću za zadani ključ |
zamjeni sve | void replaceAll (funkcija BiFunction) | Priziva zadanu funkciju za zamjenu svih unosa na karti |
putIfAbsent | V putIfAbsent (K ključ, V vrijednost) | Umeće dati ključ, vrijednost samo ako već nije prisutan |
izračunati | V izračunavanje (tipka K, BiFunction remappingFunction) | Izračunava mapiranje za navedeni ključ i vrijednost s obzirom na funkciju mapiranja. |
computeIfAbsent | V computeIfAbsent (tipka K, preslikavanje funkcije Funkcija) | Izračunajte vrijednost za zadani ključ pomoću funkcije mapiranja ako već nije prisutna. |
computeIfPresent | V computeIfPresent (tipka K, BiFunction remappingFunction) | Izračunava novo mapiranje za zadani ključ s danom funkcijom ponovnog mapiranja ako je vrijednost ključa već prisutna |
ići | Spajanje V (tipka K, V vrijednost, BiFunction remappingFunction) | Dodijeljeni ključ pridružuje vrijednosti ako već nije pridružen ili je povezan s null vrijednošću. |
Sve gore navedene metode podržavaju sučelje karte. Imajte na umu da su metode koje se čine zasjenjene nove metode koje su bile uključene u Java 8.
Implementacija Java Mape
Sljedeći program implementira primjer karte u Javi. Ovdje koristimo većinu gore raspravljenih metoda.
Primjer pokazuje razne operacije dobivanja, stavljanja i postavljanja operacija.
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()); } }
Izlaz:
Ključ = CHN, vrijednost: Kina
Ključ = XX, Vrijednost: null
null keyExists: true, null valueExists = true
unos postavljen za kartu zemlje: [null = Z, XX = null, CHN = Kina, SL = Srilanka, IND = Indija, KOR = Koreja]
Veličina zemlje_zemlje: 6
data_map preslikana na map_zemlje: {null = Z, XX = null, CHN = Kina, SL = Srilanka, IND = Indija, KOR = Kore
do}
null vrijednost ključa za data_map: Z
data_map nakon uklanjanja null ključa = {XX = null, CHN = China, SL = Srilanka, IND = India, KOR = Korea}
tipke mape podataka: [null, XX, CHN, SL, IND, KOR]
vrijednosti karte podataka: [Z, null, Kina, Srilanka, Indija, Koreja]
karta podataka nakon jasnog rada je prazna: true
Sortiranje karte u Javi
Kako se karta sastoji od parova ključ / vrijednost, kartu možemo razvrstati po ključevima ili vrijednostima.
U ovom ćemo odjeljku sortirati kartu i na ključevima i na vrijednostima.
Poredaj po ključu
Za razvrstavanje karte po tipkama možemo upotrijebiti mapu stabla. Mapa drveća automatski sortira tipke. Program Java u nastavku pretvara kartu u stablo i prikazuje sortirane ključeve.
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()); } } }
Izlaz:
Izvorna nesortirana karta:
Amerika
C Kina
D Danska
X Hongkong
Ja Indija
Karta poredana po ključu:
Amerika
C Kina
D Danska
Ja Indija
X Hongkong
Gornji program stvara kartu koja se sastoji od jednog abecednog koda kao ključeva i imena država kao vrijednosti. Prvo prikazujemo izvornu kartu koja nije sortirana. Zatim kartu pretvaramo u kartu stabla koja automatski sortira tipke. Na kraju prikazujemo razvrstanu kartu stabla na tipkama.
Poredaj po vrijednosti
Da bismo sortirali kartu na temelju vrijednosti, kartu prvo pretvaramo u popis. Zatim sortiramo ovaj popis metodom Collections.sort () koja koristi usporednik za usporedbu vrijednosti i njihovo raspoređivanje u određenom redoslijedu.
Nakon što se popis sortira, povezani unosi na popisu ponovno se kopiraju na mapu koja nam daje razvrstanu kartu.
Sljedeći Java program prikazuje sortiranje karte na temelju vrijednosti. Program koristi LinkedHashMap koji se prenosi na funkciju sortiranja. U funkciji sortiranja pretvara se u povezani popis i sortira. Nakon sortiranja pretvara se natrag u LinkedHashMap.
gdje mogu pronaći svoj mrežni sigurnosni ključ
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; } }
Izlaz:
Izvorna nesortirana karta:
{NEP = Kathmandu, IND = New Delhi, SAD = Washington, UK = London, AUS = Canberra
Karta poredana po vrijednosti:
Ključna vrijednost
IZ Canberre
NEP Katmandu
UK London
IND New Delhi
SAD Washington
Istodobna karta u Javi
ConcurrentMap je sučelje koje nasljeđuje od java.util.map sučelja. Sučelje concurrentMap prvi je put predstavljeno u JDK 1.5 i pruža mapu koja obrađuje istodobni pristup.
Sučelje concurrentMap dio je paketa java.util.concurrent.
najbolji privatni poslužitelji world of warcraft
Sljedeći Java program prikazuje istodobnu kartu na Javi.
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); } }
Izlaz:
Početna istodobna karta: {100 = crvena, 101 = zelena, 102 = plava}
Nakon dodavanja odsutnog ključa 103: {100 = crvena, 101 = zelena, 102 = plava, 103 = ljubičasta}
Istodobna karta nakon uklanjanja 101: {100 = crvena, 102 = plava, 103 = ljubičasta}
Dodajte odsutni ključ 101: {100 = crvena, 101 = smeđa, 102 = plava, 103 = ljubičasta}
Zamijenite vrijednost na ključu 101: {100 = crvena, 101 = zelena, 102 = plava, 103 = ljubičasta}
Sinkronizirana karta u Javi
Sinkronizirana karta je karta koja je zaštićena niti i iza koje stoji zadana karta. U Javi se sinkronizirana karta dobiva uporabom metode synchronizedMap () klase java.util.Collections. Ova metoda vraća sinkroniziranu kartu za datu kartu.
Ova vraćena sinkronizirana karta koristi se za pristup pozadinskoj mapi radi postizanja serijskog pristupa.
Opća deklaracija metode synchronizedMap () je:
public static Map synchronizedMap(Map m)
gdje je m => podržana karta.
Kao što je već spomenuto, ova metoda vraća sinkronizirani prikaz karte m.
Sljedeći Java program primjer je sinkronizirane mape.
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); } }
Izlaz:
Izvorna (podržana) karta: {1 = 10, 2 = 20, 3 = 30, 4 = 40, 5 = 50}
Sinkronizirana karta nakon uklanjanja (3, 30): {1 = 10, 2 = 20, 4 = 40, 5 = 50}
Statička karta u Javi
Statička karta u Javi je karta koja se proglašava statičnom baš poput statičke varijable. Deklariranjem karte statičnom, ona postaje pristupačna varijabla klase bez korištenja objekta.
Postoje dva pristupa stvaranju i inicijalizaciji statičke mape u Javi.
# 1) Korištenje statičke varijable
Ovdje stvaramo statičku varijablu mape i instanciramo je zajedno s deklaracijom.
Ovaj pristup je demonstriran u sljedećem Java programu.
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); } }
Izlaz:
Statička karta pomoću statičke varijable karte:
{1 = Indija, 2 = Portugal, 3 = Njemačka}
# 2) Korištenje statičkog bloka
U ovome stvaramo statičku varijablu mape. Zatim kreiramo statički blok i unutar ovog statičkog bloka inicijaliziramo varijablu karte.
Program u nastavku to pokazuje.
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); } }
Izlaz:
Statička karta pomoću statičkog bloka:
{1 = Crvena, 2 = Zelena, 3 = Plava}
Pretvorba popisa u mapu
U ovom ćemo odjeljku razgovarati o načinima pretvaranja popisa u kartu.
Dvije metode uključuju:
Tradicionalna metoda
U tradicionalnoj metodi svaki se element popisa kopira na mapu pomoću petlje za svaku.
Ova implementacija prikazana je u nastavku:
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); } }
Izlaz:
Navedeni popis: [Crvena, Zelena, Plava, Smeđa, Bijela]
Karta generirana s popisa: {1 = crvena, 2 = zelena, 3 = plava, 4 = smeđa, 5 = bijela}
Popis za mapiranje u Javi 8
Također se možemo poslužiti Java 8 metodom Collectors.mapOf () koja će pretvoriti zadani popis u mapu.
Program u nastavku to pokazuje.
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); } }
Izlaz:
Karta dobivena sa popisa: {1 = Abacus, 2 = Matematika, 3 = Fizika, Kemija}
U ovom programu imamo predmet Predmet koji djeluje kao klasa s popisa. Predmet klase ima dva polja, tj. Sub_id i sub_name. Imamo metode za očitavanje vrijednosti polja iz klase. U glavnoj funkciji stvaramo objekte ove klase i konstruiramo popis.
Popis se zatim pretvara u kartu pomoću metode Collectors.MapOf koja uzima elemente jedan po jedan. Također uzima sub_Id kao ključ karte. Konačno, generira se karta koja ima sub_Id kao ključ i Sub_Name kao vrijednost.
Pretvori kartu u niz u Javi
Zbirka mapa može se pretvoriti u niz pomoću dva pristupa:
Korištenje StringBuilder-a
Ovdje stvaramo objekt StringBuilder, a zatim kopiramo parove ključ / vrijednost karte u objekt StringBuilder. Zatim pretvaramo objekt StringBuilder u niz.
Program u nastavku prikazuje Java kôd za pretvaranje karte u niz.
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()); } }
Izlaz:
Dana karta: {20 = dvadeset, 40 = četrdeset, 10 = deset, 30 = trideset}
Nizni prikaz karte:
{20 = Dvadeset, 40 = Četrdeset, 10 = Deset, 30 = Trideset}
Korištenje Java 8 Streamova
Ovom metodom stvaramo tok iz ključeva karte, a zatim je pretvaramo u niz.
Dolje navedeni program prikazuje pretvorbu karte u niz pomoću strujanja.
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); } }
Izlaz:
Dana karta: {20 = dvadeset, 40 = četrdeset, 10 = deset, 30 = trideset}
Nizni prikaz karte:
{20 = Dvadeset, 40 = Četrdeset, 10 = Deset, 30 = Trideset}
Pretvori kartu u popis na Javi
Karta se sastoji od ključeva i vrijednosti, dok je popis niz pojedinačnih elemenata. Pri pretvaranju karte u popis, ključeve obično pretvaramo u popis ključeva i vrijednosti u popis vrijednosti.
Sljedeći Java program prikazuje ovu pretvorbu.
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); } }
Izlaz:
Popis ključeva s dane karte:
[50, 20, 40, 10, 30]
Popis vrijednosti s dane karte:
[magenta, zelena, cijan, crvena, plava]
Rječnik vs. Karta u Javi
Razmotrimo neke od glavnih razlika između rječnika i mape u Javi.
Rječnik | Karta |
---|---|
Rječnik je apstraktna klasa. | Karta je sučelje. |
Klase i metode koje koristi klasa rječnika prethodi okviru zbirki. | Klase i metode koje koriste klase mapa dio su okvira zbirke. |
Ako klasa proširuje rječnik, ne može proširiti nijednu drugu klasu jer Java podržava samo jedno nasljeđivanje | Karta je sučelje, tako da klasa može naslijediti s karte i drugih sučelja |
Stara implementacija. Gotovo zastario u novijim verzijama Jave. | Sučelje karte zamijenilo je implementaciju rječnika. |
Često postavljana pitanja
P # 1) Zašto u Java koristimo sučelje karte?
Odgovor: Karta je sučelje u Javi koje se provodi klasama koje pohranjuju podatke kao parove ključ / vrijednost. Sučelje karte pruža operacije / metode koje se mogu izvoditi na parovima ključ / vrijednost poput umetanja, ažuriranja, brisanja itd.
P # 2)Što MAP znači na Javi?
Odgovor: Karta u Javi predstavlja mapiranje ključa s određenom vrijednošću. Java karta pohranjuje ove parove ključ / vrijednost na kartu. Možemo potražiti i dohvatiti vrijednost povezanu s ključem samo pomoću ključa na karti.
Karta se implementira u Javi pomoću sučelja koje nije dio sučelja Collection. Ali karta je zbirka.
3. pitanje)Što dobiva MAP?
Odgovor: Get () je metoda koju pruža sučelje mape u Javi koja se koristi za dohvaćanje vrijednosti povezane s određenim ključem navedenim kao argument metode get (). Ako vrijednost nije prisutna, vraća se null.
P # 4)Je li karta kolekcija?
Odgovor: Iako se karta općenito gleda kao zbirka, ona ne implementira sučelje zbirke. Neke od implementacija mape, poput treemap, ne podržavaju null vrijednosti ili ključeve.
5. pitanje)Koja je razlika između skupa i karte?
Odgovor: Set je zbirka samo ključeva, dok je karta kolekcija parova ključ / vrijednost. Iako skup ne dopušta null vrijednosti, neke od implementacija mape dopuštaju null vrijednosti.
Set ne dopušta duplicirane ključeve. Karta može dopuštati dvostruke vrijednosti, ali ključevi moraju biti jedinstveni. Set se obično koristi kada želimo pohraniti kolekciju jedinstvenih elemenata. Karta se može koristiti kada trebamo pohraniti podatke u obliku parova ključ / vrijednost.
Zaključak
U ovom uputstvu raspravljali smo o osnovama sučelja karte. Također smo vidjeli razne metode i sve ostale detalje povezane sa sučeljem karte u Javi. Otkrili smo da postoje razne implementacije sučelja karata, uključujući mapu stabla, hashmapu itd.
U našim predstojećim vodičima detaljnije ćemo razmotriti ovu implementaciju karte.
=> Posjetite ovdje da biste naučili Javu ispočetka.
Preporučena literatura
- Što je hash-karta u Javi?
- TreeMap u Javi - Vodič uz primjere Java TreeMap
- LinkedHashMap u Javi - Primjer i implementacija LinkedHashMap
- Postavljanje sučelja u Javi: Vodič za postavljanje Java s primjerima
- JAVA Tutorial za početnike: 100+ praktičnih Java Video tutorijala
- Vodič za Java stack: Primjena klase steka s primjerima
- Java Vodič za refleksiju s primjerima
- Nazubljeni niz u Javi - Vodič s primjerima