java map interface tutorial with implementation examples
Acest tutorial cuprinzător de hărți Java acoperă modul de creare, inițializare și iterație prin hărți. De asemenea, veți afla despre metodele hărții și exemplele de implementare:
Veți cunoaște noțiunile de bază ale interfeței de hartă, metodele acceptate de interfața de hartă și alți termeni specifici legați de interfața de hartă.
Colecția de hărți în Java este o colecție care mapează o cheie la o valoare. Este o colecție formată din chei și valori. Fiecare intrare pe hartă constă dintr-o cheie cu valoarea sa corespunzătoare. Tastele sunt unice în hărți. Hărțile pot fi utilizate de obicei atunci când trebuie să modificăm o colecție pe baza unei valori cheie.
=> Verificați TOATE Tutorialele Java aici.
Ce veți învăța:
- Hărți în Java
- Metode de hartă
- Implementarea hărții Java
- Concluzie
Hărți în Java
Harta din Java face parte din interfața java.util.map. Interfața hărții nu face parte din interfața colecției și acesta este motivul pentru care hărțile sunt diferite de celelalte colecții.
Ierarhia generală a interfeței hărții este prezentată mai jos.
Așa cum se arată mai sus, există două interfețe pentru a implementa harta, adică interfața hartă și interfața sortedMap Există trei clase și anume HashMap, TreeMap și LinkedHashMap.
Aceste tipuri de hărți sunt descrise mai jos:
| Clasă | Descriere | |
|---|---|---|
| elimina | V remove (cheie obiect) | Ștergeți o intrare pe hartă pentru cheia dată |
| LinkedHashMap | Se extinde din clasa HashMap. Această hartă menține ordinea de inserare | |
| HashMap | Implementați o interfață de hartă. HashMap nu menține nicio comandă. | |
| TreeMap | Implementează atât interfața hartă, cât și cea sortată. TreeMap menține o ordine crescătoare. |
Puncte de reținut despre hărți.
- În hărți, fiecare tastă poate mapa la cel mult o valoare. De asemenea, nu pot exista chei duplicate pe hărți.
- Implementările de hărți precum HashMap și LinkedHashMap permit valori cheie nule și valori nule. Cu toate acestea, TreeMap nu o permite.
- O hartă nu poate fi parcursă așa cum este. Prin urmare, pentru traversare, trebuie convertit în setare folosind metoda keyset () sau entrySet ().
Creați o hartă în Java
Pentru a crea o hartă în Java, mai întâi, trebuie să includem interfața în programul nostru. Putem folosi una dintre următoarele afirmații din program pentru a importa funcționalitatea hărții.
import java.util.*; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.TreeMap; Trebuie să instanțiem o implementare concretă a hărții, deoarece aceasta este o interfață.
Următoarele declarații creează o hartă în Java.
Map hash_map = new HashMap(); Map tree_map = new TreeMap(); Afirmațiile de mai sus vor crea hărți cu specificații implicite.
De asemenea, putem crea hărți generice specificând tipurile atât pentru cheie, cât și pentru valoare.
Map myMap = new HashMap(); Definiția de mai sus va avea chei de tip șir și obiecte ca valori.
Inițializați o hartă în Java
Poate fi inițializat folosind următoarele metode:
# 1) Utilizarea colecțiilor
Clasa Colecții Java are metode din fabrică care pot fi utilizate pentru inițializarea colecțiilor, inclusiv hărți.
Unele metode utilizate pentru inițializarea hărții sunt următoarele:
(1) Colecții.EmptyMap ()
Collections.EmptyMap () returnează o hartă serializabilă și imuabilă care este goală. De exemplu, următoarea linie de cod,
Map myMap = Collections.EMPTY_MAP; Aceasta va crea o hartă goală. Metoda de mai sus poate lansa „avertisment de atribuire necontrolat” și, prin urmare, putem folosi și formularul tip-safe, după cum urmează.
Map myMap = Collections.emptyMap (); (2) Collections.unModifiableMap ()
Metoda unModifiableMap () ia o altă hartă ca argument și creează o vedere nemodificabilă a hărții originale.
Map myMap = Collections.EMPTY_MAP; Map map_unmodifiable = Collections.unmodifiableMap (myMap); (3) Collections.singletonMap ()
Clasa Colecții oferă, de asemenea, o metodă din fabrică „singletonMap ()” care creează o hartă imutabilă a singletonului care are o singură intrare.
Map singleton_map = Collections.singletonMap('CHN', 'Beijing'); # 2) Utilizarea Java 8
Putem obține un flux de date din metodele Java 8 stream API și putem construi hărți folosind Collectors.
Unele dintre metodele de construire a hărților sunt:
(1) Collectors.toMap ()
Colectăm un flux și apoi folosim metoda Collectors.toMap () pentru a construi o hartă.
Map map = Stream.of(new String()(){{'USA', 'Washington'}, {'United Kingdom', 'London'} }).collect(Collectors.toMap(p -> p(0), p -> p(1))); Afirmația de mai sus creează o hartă din fluxul Java 8.
(2) Collectors.collectingAndThen ()
În acest sens, adaptăm metoda toMap () care permite colectorului să producă o hartă imuabilă folosind metoda 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) Folosind metoda put a interfeței Map
Metoda put () a interfeței hărții poate fi utilizată pentru a atribui valori inițiale hărților.
# 4) Utilizarea inițializării Double Brace
Tehnica „inițializarea dublei acolade” creează o clasă interioară. Această clasă este anonimă și are un inițializator de instanță. Aceasta nu este o tehnică preferată și trebuie evitată, deoarece poate duce la scurgeri de memorie sau probleme de serializare.
Programul de mai jos prezintă diferitele metode de inițializare a unei hărți discutate mai sus.
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); } }Ieșire:
valori ale hărții unmodifiableMap: {}
valorile hărții singleton_map: {10 = TEN}
valori map_cities: {CH = Chennai, DL = New Delhi, MH = Mumbai}
majuscule_valori ale hărții: {MAH = Mumbai, GOA = Panaji, KAR = Bangaluru}
Valorile hărții: {SUA = Washington, GER = Berlin, UK = Londra, IND = Delhi}
Iterează peste hartă în Java și tipărește harta
Putem traversa harta exact în același mod în care traversăm celelalte colecții. În plus față de parcurgerea intrărilor pe hartă, putem parcurge doar tastele sau numai valorile din hartă. Rețineți că, pentru a parcurge o hartă, aceasta trebuie mai întâi convertită la setare.
Următoarele metode sunt folosite pentru a traversa intrările hărții.
Utilizarea Enter Iterator
În această metodă, obținem un iterator de intrări dintr-un set de intrări. Apoi, folosind metodele getKey și getValue, recuperăm perechea cheie-valoare pentru fiecare intrare pe hartă.
Următorul program arată utilizarea unui iterator de intrări.
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()); } } } Ieșire:
Intrările pe hartă sunt:
VALOARE CHEIE
CH Chennai
DL New Delhi
MH Mumbai
În programul de mai sus, obținem un iterator de intrări de pe hartă folosind metoda entrySet. Apoi traversăm harta folosind metoda hasNext () de iterator de intrare și imprimăm perechea cheie-valoare.
Utilizarea unei intrări pentru fiecare buclă
Aici traversăm entrySet folosind pentru fiecare buclă și implementarea este prezentată mai jos.
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()); } } } Ieșire:
Intrările pe hartă sunt:
VALOARE CHEIE
CH Chennai
DL New Delhi
MH Mumbai
Metode de hartă
Interfața de hartă în Java acceptă diverse operațiuni similare cu cele acceptate de alte colecții. În această secțiune, vom discuta despre diferitele metode furnizate de Map API în Java. Deoarece scopul acestui tutorial este limitat la introducerea unei interfețe de hartă în general, nu vom descrie aceste metode.
Vom discuta în detaliu aceste metode în timp ce vom discuta despre clasele de interfață cu hărțile.
Următorul tabel listează toate metodele furnizate de API-ul hărții.
| Nume metodă | Metoda prototip | Descriere |
|---|---|---|
| obține | V get (cheia obiectului) | Returnează obiectul sau valoarea cheii date |
| a pune | V put (cheie obiect, valoare obiect) | Introduceți intrarea valoare-cheie în hartă |
| pune tot | void putAll (hartă hartă) | Inserați intrări de hartă date în hartă. Cu alte cuvinte, copiază sau clonează o hartă. |
| keySet | Set keySet () | Returnează vizualizarea setată a hărții. |
| entrySet | A stabilit | Returnează setarea vizualizării pentru o hartă dată |
| valori | Valorile colecției () | Returnează vizualizarea colecției valorilor din hartă. |
| mărimea | int size () | Returnează numărul de intrări pe hartă |
| clar | gol clar () | Șterge harta |
| este gol | boolean isEmpty () | Verifică dacă harta este goală și returnează adevărat dacă da. |
| conține Valoare | boolean conține Valoare (valoarea obiectului) | Returnează adevărat dacă harta conține valoarea egală cu valoarea dată |
| conține Cheie | boolean conține Key (cheie obiect) | Returnează adevărat dacă există o cheie dată pe hartă |
| este egal | boolean este egal (Obiectul o) | Compară obiectul specificat o cu harta |
| hashCode | int hashCode () | returnează codul hash pentru hartă |
| pentru fiecare | nul pentru fiecare (acțiune BiConsumer) | Efectuează acțiunea dată pentru fiecare intrare pe hartă |
| getOrDefault | V getOrDefault (cheie obiect, V defaultValue) | Returnează valoarea specificată pentru cheia dată sau valoarea implicită a acesteia dacă cheia nu este prezentă |
| elimina | eliminare booleană (cheie obiect, valoare obiect) | Elimină cheile și valorile specificate |
| a inlocui | Înlocuire V (tasta K, valoare V) | Înlocuiește cheia dată cu valoarea specificată |
| a inlocui | înlocuire booleană (tasta K, V oldValue, V newValue) | Înlocuiește vechea valoare cu o nouă valoare pentru o cheie dată |
| înlocuiește-le pe toate | void replaceAll (funcția BiFunction) | Invocă funcția dată pentru a înlocui toate intrările de pe hartă |
| putIfAbsent | V putIfAbsent (cheie K, valoare V) | Inserează cheia dată, valoare numai dacă nu este deja prezentă |
| calcula | Calcul V (cheie K, funcție de remapare BiFunction) | Calculează maparea pentru cheia și valoarea specificate, dată fiind funcția de mapare. |
| computeIfAbsent | V computeIfAbsent (tasta K, funcția mapare funcție) | Calculați valoarea pentru cheia dată utilizând funcția de mapare dacă nu este deja prezentă. |
| computeIfPresent | V computeIfPresent (tasta K, funcția de remapare BiFunction) | Calculează noua mapare pentru cheia dată cu funcția de remapare dată dacă valoarea cheii este deja prezentă |
| merge | V merge (tasta K, valoarea V, funcția de remapare BiFunction) | Asociază o cheie dată cu valoarea dacă nu este deja asociată sau este asociată cu valoarea nulă. |
Toate metodele de mai sus sunt acceptate de interfața hărții. Rețineți că metodele care apar umbrite sunt noile metode care au fost incluse în Java 8.
Implementarea hărții Java
Următorul program implementează un exemplu de hartă în Java. Aici folosim majoritatea metodelor discutate mai sus.
Exemplul demonstrează diverse operații get, put și 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()); } } Ieșire:
Cheie = CHN, valoare: China
Cheie = XX, valoare: nul
null keyExists: true, null valueExists = true
set de intrări pentru țara_mapă: (nul = Z, XX = nul, CHN = China, SL = Srilanka, IND = India, KOR = Coreea)
Dimensiunea hărții țării: 6
data_map mapată la country_map: {null = Z, XX = nul, CHN = China, SL = Srilanka, IND = India, KOR = Kore
la}
valoare cheie nulă pentru data_map: Z
data_map după eliminarea cheii nule = {XX = null, CHN = China, SL = Srilanka, IND = India, KOR = Korea}
chei ale hărții de date: (null, XX, CHN, SL, IND, KOR)
valori ale hărții de date: (Z, nul, China, Srilanka, India, Coreea)
harta de date după operație clară, este goală: adevărat
Sortarea unei hărți în Java
Deoarece o hartă constă din perechi cheie-valoare, putem sorta harta pe chei sau valori.
În această secțiune, vom sorta o hartă atât pe chei, cât și pe valori.
Sortați după cheie
Pentru a sorta o hartă pe taste, putem folosi o hartă. Harta arbore sortează automat tastele. Programul Java de mai jos convertește o hartă într-o hartă și afișează tastele sortate.
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()); } } }Ieșire:
Harta originală nesortată:
O America
C China
D Danemarca
X Hongkong
Eu India
Harta sortată după cheie:
O America
C China
D Danemarca
Eu India
X Hongkong
Programul de mai sus creează o hartă formată dintr-un singur cod alfabet ca chei și numele țărilor ca valori. Mai întâi, afișăm harta originală care nu este sortată. Apoi convertim harta într-o hartă care sortează automat tastele. În cele din urmă, afișăm harta arborelui sortată pe taste.
Sortați după valoare
Pentru a sorta o hartă pe baza valorilor, mai întâi convertim harta într-o listă. Apoi sortăm această listă folosind metoda Collections.sort () care folosește un comparator pentru a compara valorile și a le aranja într-o ordine specifică.
Odată ce lista este sortată, intrările listei legate sunt copiate din nou pe hartă, ceea ce ne oferă harta sortată.
Următorul program Java demonstrează sortarea unei hărți pe baza valorii. Programul folosește LinkedHashMap care este trecut la funcția de sortare. În funcția de sortare, este convertită într-o listă legată și sortată. După sortare, este convertit înapoi în LinkedHashMap.
diferența dintre server sql și sql
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; } } Ieșire:
Harta originală nesortată:
{NEP = Kathmandu, IND = New Delhi, SUA = Washington, Marea Britanie = Londra, AUS = Canberra
Harta sortată după valoare:
Valoare cheie
DIN Canberra
NEP Kathmandu
Marea Britanie Londra
IND New Delhi
SUA Washington
Harta simultană în Java
Un concurrentMap este o interfață care moștenește de la interfața java.util.map. Interfața concurrentMap a fost introdusă pentru prima dată în JDK 1.5 și oferă o hartă care gestionează accesul simultan.
Interfața concurrentMap face parte din pachetul java.util.concurrent.
Următorul program Java demonstrează concurrentMap în 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); } }Ieșire:
Harta simultană inițială: {100 = Roșu, 101 = Verde, 102 = Albastru}
După adăugarea tastei absente 103: {100 = Roșu, 101 = Verde, 102 = Albastru, 103 = Violet}
Harta simultană după eliminarea 101: {100 = Roșu, 102 = Albastru, 103 = Violet}
Adăugați cheia absentă 101: {100 = Roșu, 101 = Maro, 102 = Albastru, 103 = Violet}
Înlocuiți valoarea la cheia 101: {100 = Roșu, 101 = Verde, 102 = Albastru, 103 = Violet}
Harta sincronizată în Java
O hartă sincronizată este o hartă sigură pentru fire și care este susținută de o hartă dată. În Java, harta sincronizată se obține utilizând metoda synchronizedMap () a clasei java.util.Collections. Această metodă returnează o hartă sincronizată pentru o hartă dată.
Această hartă sincronizată returnată este utilizată pentru a accesa harta de susținere pentru a obține acces serial.
Declarația generală a metodei synchronizedMap () este:
public static Map synchronizedMap(Map m) unde m => este harta susținută.
După cum sa menționat deja, această metodă returnează vizualizarea sincronizată a hărții m.
Programul Java de mai jos este un exemplu de hartă sincronizată.
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); } } Ieșire:
Harta originală (susținută): {1 = 10, 2 = 20, 3 = 30, 4 = 40, 5 = 50}
Harta sincronizată după eliminare (3, 30): {1 = 10, 2 = 20, 4 = 40, 5 = 50}
Harta statică în Java
O hartă statică în Java este o hartă care este declarată statică la fel ca o variabilă statică. Prin declararea unei hărți statică, aceasta devine o variabilă de clasă accesibilă fără a utiliza obiectul.
Există două abordări pentru crearea și inițializarea unei hărți statice în Java.
# 1) Utilizarea unei variabile statice
Aici, creăm o variabilă de hartă statică și o instanțăm împreună cu declarația.
Această abordare este demonstrată în următorul program 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); } }Ieșire:
Harta statică utilizând variabila de hartă statică:
{1 = India, 2 = Portugalia, 3 = Germania}
# 2) Utilizarea blocului static
În aceasta, creăm o variabilă de hartă statică. Apoi creăm un bloc static și, în interiorul acestui bloc static, inițializăm variabila hartă.
Programul de mai jos demonstrează acest lucru.
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); } } Ieșire:
Harta statică utilizând blocul static:
{1 = Roșu, 2 = Verde, 3 = Albastru}
Conversia listei în hartă
În această secțiune, vom discuta despre metodele de convertire a listei într-o hartă.
Cele două metode includ:
Metoda tradițională
În metoda tradițională, fiecare element de listă este copiat pe hartă folosind o buclă pentru fiecare.
Această implementare este prezentată mai jos:
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); } } Ieșire:
Lista dată: (Roșu, Verde, Albastru, Maro, Alb)
Harta generată din listă: {1 = roșu, 2 = verde, 3 = albastru, 4 = maro, 5 = alb}
Listă pentru mapare în Java 8
Putem folosi și metoda Java 8 Collectors.mapOf () care va converti lista dată într-o hartă.
Programul de mai jos demonstrează acest lucru.
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); } } Ieșire:
Harta obținută din listă: {1 = Abacus, 2 = Matematică, 3 = Fizică, Chimie}
În acest program, avem un subiect de clasă care acționează ca o listă de clasă. Clasa Subiect are două câmpuri, adică sub_id și sub_name. Avem metode pentru a citi valorile câmpului din clasă. În funcția principală, creăm obiecte din această clasă și construim o listă.
Această listă este apoi convertită în hartă utilizând metoda Collectors.MapOf care ia elementele unul câte unul. De asemenea, ia sub_Id ca cheie a hărții. În cele din urmă, se generează harta care are sub_Id ca cheie și Sub_Name ca valoare.
Convertiți harta în șir în Java
O colecție de hărți poate fi convertită într-un șir folosind două abordări:
Folosind StringBuilder
Aici creăm un obiect StringBuilder și apoi copiem perechile cheie-valoare ale hărții în obiectul StringBuilder. Apoi convertim obiectul StringBuilder într-un șir.
Programul de mai jos arată codul Java pentru a converti harta în șir.
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()); } }Ieșire:
Harta dată: {20 = Douăzeci, 40 = Patruzeci, 10 = Zece, 30 = Treizeci}
Reprezentarea în șir a hărții:
{20 = Douăzeci, 40 = Patruzeci, 10 = Zece, 30 = Treizeci}
Utilizarea fluxurilor Java 8
În această metodă, creăm un flux din tastele hărții și apoi îl convertim în șir.
Programul prezentat mai jos arată conversia hărții într-un șir folosind fluxuri.
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); } }Ieșire:
Harta dată: {20 = Douăzeci, 40 = Patruzeci, 10 = Zece, 30 = Treizeci}
Reprezentarea în șir a hărții:
{20 = Douăzeci, 40 = Patruzeci, 10 = Zece, 30 = Treizeci}
Convertiți harta în listă în Java
O hartă constă din chei și valori, în timp ce o listă este o succesiune de elemente individuale. Când convertim harta într-o listă, de obicei convertim cheile într-o listă de chei și valori într-o listă de valori.
Următorul program Java arată această conversie.
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); } }Ieșire:
Lista cheilor de pe harta dată:
(50, 20, 40, 10, 30)
Lista valorilor din harta dată:
(magenta, verde, cyan, roșu, albastru)
Dicționar Vs. Hartă în Java
Să discutăm câteva dintre diferențele majore dintre un dicționar și o hartă în Java.
| Dicţionar | Hartă |
|---|---|
| Dicționarul este o clasă abstractă. | Harta este o interfață. |
| Clasele și metodele utilizate de clasa dicționarului precedă cadrul colecțiilor. | Clasele și metodele utilizate de clasele de hărți fac parte din cadrul de colectare. |
| Dacă o clasă extinde dicționarul, nu poate extinde nicio altă clasă, deoarece Java acceptă doar o moștenire unică | Harta este o interfață, astfel încât o clasă poate moșteni de pe hartă și alte interfețe |
| Implementare veche. Aproape învechit în versiunile mai noi de Java. | Interfața hărții a înlocuit implementarea dicționarului. |
întrebări frecvente
Q # 1) De ce folosim o interfață de hartă în Java?
Răspuns: Harta este o interfață în Java care este implementată prin clase care stochează date ca perechi cheie-valoare. Interfața hartă oferă operațiuni / metode care pot fi efectuate pe perechi cheie-valoare precum inserarea, actualizarea, ștergerea etc.
Q # 2)Ce înseamnă MAP în Java?
Răspuns: O hartă în Java reprezintă o mapare a unei chei cu o valoare specifică. O hartă Java stochează aceste perechi cheie-valoare într-o hartă. Putem căuta și prelua valoarea asociată cu o cheie doar folosind cheia din hartă.
O hartă este implementată în Java folosind o interfață care nu face parte din interfața Colecție. Dar harta este o colecție.
Q # 3)Ce obține MAP?
Răspuns: Get () este o metodă furnizată de o interfață de hartă în Java care este utilizată pentru a extrage valoarea asociată cu o anumită cheie furnizată ca argument pentru metoda get (). Dacă valoarea nu este prezentă, se returnează un nul.
Q # 4)Harta este o colecție?
Răspuns: Deși harta este privită ca o colecție în general, nu implementează o interfață de colecție. Unele dintre implementările hărții, cum ar fi Treemap, nu acceptă valori sau chei nule.
cum se execută un fișier jar Windows 10
Q # 5)Care este diferența dintre set și hartă?
Răspuns: Setul este doar o colecție de chei, în timp ce harta este o colecție de perechi cheie-valoare. Deși setul nu permite valori nule, unele dintre implementările hărții permit valori nule.
Setul nu permite duplicarea cheilor. Harta poate permite valori duplicate, dar cheile trebuie să fie unice. Setul este de obicei folosit atunci când dorim să stocăm o colecție de elemente unice. Harta poate fi utilizată atunci când trebuie să stocăm date sub formă de perechi cheie-valoare.
Concluzie
În acest tutorial, am discutat elementele de bază ale interfeței hărții. De asemenea, am văzut diferitele metode și toate celelalte detalii legate de interfața hărții în Java. Am aflat că există diferite implementări ale interfețelor de hartă, inclusiv treemap, hashmap etc.
În tutorialele noastre viitoare, vom discuta despre această implementare a hărții în detaliu.
=> Vizitați aici pentru a afla Java de la zero.
Lectură recomandată
- Ce este un HashMap în Java?
- TreeMap în Java - Tutorial cu exemple de TreeMap Java
- LinkedHashMap în Java - Exemplu și implementare LinkedHashMap
- Setați interfața în Java: Tutorial de setare Java cu exemple
- Tutorial JAVA pentru începători: peste 100 de cursuri video Java practice
- Tutorial Java Stack: Implementarea clasei Stack cu exemple
- Tutorial de reflecție Java cu exemple
- Matrice Jagged în Java - Tutorial cu exemple