Tutorial de la interfície de mapa de Java amb implementació i exemples

java map interface tutorial with implementation examples

Proveu El Nostre Instrument Per Eliminar Problemes

Seleccioneu El Sistema Operatiu Trieu Un Programa De Projecció (Opcionalment)

Descriviu El Vostre Problema

Aquest tutorial complet sobre mapes de Java descriu com crear, inicialitzar i iterar mitjançant mapes. També coneixereu els mètodes de mapes i els exemples d’implementació:

Coneixerà els conceptes bàsics de la interfície del mapa, els mètodes compatibles amb la interfície del mapa i altres termes específics relacionats amb la interfície del mapa.

La col·lecció de mapes a Java és una col·lecció que assigna una clau a un valor. És una col·lecció formada per claus i valors. Cada entrada del mapa consta d’una clau amb el seu valor corresponent. Les tecles són úniques als mapes. Els mapes es poden utilitzar normalment quan necessitem modificar una col·lecció en funció d’un valor clau.

=> Consulteu TOTS els tutorials de Java aquí.

Interfície de mapa a Java

Què aprendreu:

Mapes a Java
Mètodes del mapa
Implementació de mapes Java
Conclusió
- Lectura recomanada

Mapes a Java

El mapa a Java forma part de la interfície java.util.map. La interfície del mapa no forma part de la interfície de col·lecció i és per això que els mapes són diferents de les altres col·leccions.

A continuació es mostra la jerarquia general de la interfície del mapa.

jerarquia general de la interfície del mapa

Com es mostra més amunt, hi ha dues interfícies per implementar el mapa, és a dir, la interfície de mapa i la interfície sortedMap. Hi ha tres classes, és a dir, HashMap, TreeMap i LinkedHashMap.

Aquests tipus de mapes es descriuen a continuació:

Classe	Descripció
eliminar	Suprimeix V (clau d'objecte)	Suprimiu una entrada de mapa per a la clau donada
LinkedHashMap	S'estén des de la classe HashMap. Aquest mapa manté l'ordre d'inserció
HashMap	Implementar una interfície de mapa. HashMap no manté cap ordre.
Mapa d’arbres	Implementa la interfície map i sortedMap. TreeMap manté un ordre ascendent.

Punts per recordar sobre els mapes.

Als mapes, cada tecla pot assignar al màxim un valor. A més, no hi pot haver claus duplicades als mapes.
Les implementacions de mapes com HashMap i LinkedHashMap permeten claus nuls i valors nuls. Tot i això, TreeMap no ho permet.
No es pot recórrer un mapa tal com és. Per tant, per recórrer-lo, s’ha de convertir a configurar mitjançant el mètode keyset () o entrySet ().

Creeu un mapa a Java

Per crear un mapa a Java, primer hem d’incloure la interfície al nostre programa. Podem utilitzar una de les afirmacions següents al programa per importar la funcionalitat del mapa.

import java.util.*; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.TreeMap;

Hem d’instanciar una implementació concreta del mapa ja que és una interfície.

Les següents afirmacions creen un mapa a Java.

Map hash_map = new HashMap(); Map tree_map = new TreeMap();

Les afirmacions anteriors crearan mapes amb especificacions predeterminades.
També podem crear mapes genèrics que especifiquin els tipus tant de clau com de valor.

Map myMap = new HashMap();

La definició anterior tindrà claus de tipus string i objectes com a valors.

Inicialitzeu un mapa a Java

Es pot inicialitzar mitjançant els mètodes següents:

# 1) Ús de col·leccions

La classe Java Collections té mètodes de fàbrica que es poden utilitzar per inicialitzar col·leccions, inclosos els mapes.

Alguns mètodes utilitzats per inicialitzar el mapa són els següents:

(1) Collections.EmptyMap ()

Collections.EmptyMap () retorna un mapa serialitzable i immutable que està buit. Per exemple, la següent línia de codi,

Map myMap = Collections.EMPTY_MAP;

Això crearà un mapa buit. El mètode anterior pot generar un 'advertiment d'assignació sense comprovar' i, per tant, també podem utilitzar el formulari de tipus segur de la següent manera.

Map myMap = Collections.emptyMap ();

(2) Collections.unModifiableMap ()

El mètode unModifiableMap () pren un altre mapa com a argument i crea una vista no modificable del mapa original.

Map myMap = Collections.EMPTY_MAP; Map map_unmodifiable = Collections.unmodifiableMap (myMap);

(3) Collections.singletonMap ()

La classe Collections també proporciona un mètode de fàbrica 'singletonMap ()' que crea un mapa de singleton immutable que només té una entrada.

Map singleton_map = Collections.singletonMap('CHN', 'Beijing');

# 2) Ús de Java 8

Podem obtenir un flux de dades a partir de mètodes d’API de flux de Java 8 i construir mapes mitjançant Collectors.

Alguns dels mètodes per construir mapes són:

(1) Collectors.toMap ()

Recollim un flux i després fem servir el mètode Collectors.toMap () per construir un mapa.

 Map map = Stream.of(new String()(){{'USA', 'Washington'},   {'United Kingdom', 'London'}    }).collect(Collectors.toMap(p -> p(0), p -> p(1)));

La sentència anterior crea un mapa a partir del flux Java 8.

(2) Collectors.collectingAndThen ()

En això, adaptem el mètode toMap () que permet al col·leccionista produir un mapa immutable mitjançant el mètode 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) Utilitzant el mètode put de la interfície de mapa

El mètode put () de la interfície del mapa es pot utilitzar per assignar valors inicials als mapes.

# 4) Ús de la inicialització de doble parèntesi

La tècnica 'inicialització de doble tirant' crea una classe interior. Aquesta classe és anònima i té un inicialitzador d’instància. Aquesta no és una tècnica preferida i s’ha d’evitar, ja que pot provocar fuites de memòria o problemes de serialització.

El programa següent mostra els diversos mètodes d'inicialització d'un mapa comentats anteriorment.

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); } }

Sortida:

valors del mapa de mapa no modificables: {}
valors del mapa singleton_map: {10 = TEN}
valors map_cities: {CH = Chennai, DL = Nova Delhi, MH = Bombai}
valors de capitals_Map: {MAH = Mumbai, GOA = Panaji, KAR = Bangaluru}
Valors del mapa: {EUA = Washington, GER = Berlín, Regne Unit = Londres, IND = Delhi}

inicialitzant un mapa

Repeteix el mapa a Java i imprimeix el mapa

Podem recórrer el mapa de la mateixa manera que recorrem les altres col·leccions. A més de recórrer les entrades del mapa, també podem recórrer només les tecles o només els valors del mapa. Tingueu en compte que per recórrer un mapa, primer cal convertir-lo a establert.

Els mètodes següents s’utilitzen per recórrer les entrades del mapa.

Utilització d’Iterator d’Entry

En aquest mètode, obtenim un iterador d’entrades d’un conjunt d’entrades. A continuació, mitjançant els mètodes getKey i getValue, recuperem el parell clau-valor de cada entrada de mapa.

El programa següent mostra l'ús d'un iterador d'entrades.

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()); } } }

Sortida:

Les entrades del mapa són:
VALOR CLAU
CH Chennai
DL Nova Delhi
MH Mumbai

S’utilitza l’iterador d’entrades

En el programa anterior, obtenim un iterador d’entrades del mapa mitjançant el mètode entrySet. A continuació, recorrem el mapa mitjançant el mètode hasNext () d'iterador d'entrada i imprimim el parell clau-valor.

Ús d’una entrada per a cada bucle

Aquí recorrem l'entradaSet utilitzant per a cada bucle i la implementació es mostra a continuació.

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()); } } }

Sortida:

Les entrades del mapa són:
VALOR CLAU
CH Chennai
DL Nova Delhi
MH Mumbai

Utilitzant una entrada per a cada bucle

Mètodes del mapa

La interfície de mapes a Java admet diverses operacions similars a les compatibles amb altres col·leccions. En aquesta secció, parlarem dels diversos mètodes proporcionats per Map API a Java. Com que l'abast d'aquest tutorial es limita a introduir una interfície de mapa en general, no descriurem aquests mètodes.

Discutirem detalladament aquests mètodes mentre discutim les classes de la interfície del mapa.

La taula següent llista tots els mètodes proporcionats per l'API del mapa.

Nom del mètode	Mètode prototip	Descripció
aconseguir	V get (clau d'objecte)	Retorna l'objecte o el valor de la clau donada
posar	V put (clau d'objecte, valor d'objecte)	Inseriu l'entrada de valor-clau al mapa
putAll	void putAll (mapa del mapa)	Inseriu les entrades del mapa donades al mapa. En altres paraules, copia o clona un mapa.
keySet	Estableix keySet ()	Retorna la visualització del mapa.
entrySet	ConjuntentrySet ()	Retorna defineix la vista d'un mapa determinat
valors	Valors de col·lecció ()	Retorna la vista de col·lecció dels valors del mapa.
mida	int size ()	Retorna el nombre d'entrades al mapa
clar	void clear ()	Esborra el mapa
està buit	boolean isEmpty ()	Comprova si el mapa està buit i torna cert si és afirmatiu.
contéValor	booleà contéValor (valor de l'objecte)	Retorna cert si el mapa conté el valor igual al valor donat
conté Clau	booleà contéKey (clau d'objecte)	Retorna cert si existeix una clau determinada al mapa
és igual	booleà és igual (objecte o)	Compara l'objecte o especificat amb el mapa
hashCode	int hashCode ()	retorna el codi de hash del mapa
per cadascú	void forEach (acció BiConsumer)	Realitza les accions donades per a cada entrada del mapa
getOrDefault	V getOrDefault (clau d'objecte, V defaultValue)	Retorna el valor especificat per a la clau donada o el seu valor per defecte si la clau no està present
eliminar	eliminar booleà (clau d'objecte, valor d'objecte)	Elimina les claus i els valors especificats
substituir	Substitució V (tecla K, valor V)	Substitueix la clau donada pel valor especificat
substituir	reemplaçament booleà (clau K, V valor antic, V valor nou)	Substitueix el valor antic per un valor nou per a una clau determinada
substituirTots	void replaceAll (funció BiFunction)	Invoca la funció donada per substituir totes les entrades del mapa
putIfAbsent	V putIfAbsent (clau K, valor V)	Insereix la clau donada, valor només si encara no està present
calcular	Càlcul en V (tecla K, funció de mapatge de BiFunction)	Calcula el mapatge per a la clau i el valor especificats donada la funció de mapatge.
computeIfAbsent	V computeIfAbsent (tecla K, funció assignació de funcions)	Calculeu el valor de la clau donada mitjançant la funció de mapatge si encara no està present.
computeIfPresent	V computeIfPresent (tecla K, BiFunction remappingFunction)	Calcula la nova assignació de la clau donada amb la funció de remapatge donada si el valor de la clau ja està present
vaja	Combinació en V (tecla K, valor en V, funció de mapatge de BiFunció)	Associa una clau determinada al valor si encara no està associada o està associada al valor nul.

La interfície del mapa admet tots els mètodes anteriors. Tingueu en compte que els mètodes que apareixen ombrejats són els nous mètodes inclosos a Java 8.

Implementació de mapes Java

El programa següent implementa un exemple de mapa a Java. Aquí fem servir la majoria dels mètodes comentats anteriorment.

L'exemple mostra diverses operacions 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()); } }

Sortida:

Clau = CHN, valor: Xina
Clau = XX, valor: nul
null keyExists: true, null valueExists = true
conjunt d'entrades per al mapa del país: (null = Z, XX = nul, CHN = Xina, SL = Srilanka, IND = Índia, KOR = Corea)
Mida de country_map: 6
mapa de dades assignat a mapa de país: {null = Z, XX = nul, CHN = Xina, SL = Srilanka, IND = Índia, KOR = Kore
a}
valor de clau nul per a data_map: Z
data_map després d’eliminar la clau nul·la = {XX = nul·la, CHN = Xina, SL = Srilanka, IND = Índia, KOR = Corea}
claus del mapa de dades: (null, XX, CHN, SL, IND, KOR)
valors del mapa de dades: (Z, nul, Xina, Srilanka, Índia, Corea)
el mapa de dades després de l’operació neta, està buit: cert

obtenir operacions, posar i configurar operacions

Ordenant un mapa a Java

Com que un mapa consta de parells clau-valor, podem ordenar el mapa per claus o valors.

En aquesta secció, ordenarem un mapa tant de claus com de valors.

Ordena per clau

Per ordenar un mapa amb les tecles, podem utilitzar un mapa d’arbres. El mapa de l’arbre ordena les tecles automàticament. El programa Java següent converteix un mapa en un mapa de l'arbre i mostra les claus ordenades.

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()); } } }

Sortida:

Mapa original sense classificar:
Una Amèrica
C Xina
D Dinamarca
X Hong Kong
I Índia
Mapa ordenat per clau:
Una Amèrica
C Xina
D Dinamarca
I Índia
X Hong Kong

Ordena per clau

El programa anterior crea un mapa format per un únic codi alfabètic com a tecles i noms de països com a valors. En primer lloc, mostrem el mapa original que no està ordenat. A continuació, convertim el mapa en un mapa de l’arbre que ordena automàticament les tecles. Finalment, mostrem el mapa de l’arbre ordenat a les tecles.

Ordena per valor

Per ordenar un mapa en funció de valors, primer el convertim en una llista. A continuació, ordenem aquesta llista mitjançant el mètode Collections.sort () que utilitza un comparador per comparar els valors i ordenar-los en un ordre específic.

Un cop ordenada la llista, les entrades de llista enllaçades es tornen a copiar al mapa que ens proporciona el mapa ordenat.

El següent programa Java mostra l’ordenació d’un mapa en funció del valor. El programa utilitza LinkedHashMap que es transmet a la funció d’ordenació. A la funció d’ordenació, es converteix en una llista enllaçada i s’ordena. Després de classificar-lo, es torna a convertir a LinkedHashMap.

HP alm preguntes i respostes de l'entrevista

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; } }

Sortida:

Mapa original sense classificar:
{NEP = Katmandú, IND = Nova Delhi, EUA = Washington, Regne Unit = Londres, AUS = Canberra

Mapa ordenat segons el valor:
Valor clau
DES DE Canberra
NEP Katmandú
Regne Unit de Londres
IND Nova Delhi
EUA Washington

Ordena per valor

Mapa simultani a Java

Un concurrentMap és una interfície que hereta de la interfície java.util.map. La interfície concurrentMap es va introduir per primera vegada a JDK 1.5 i proporciona un mapa que gestiona l'accés simultani.

La interfície concurrentMap forma part del paquet java.util.concurrent.

El següent programa Java mostra el mapa concurrent a 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); } }

Sortida:

Mapa simultani inicial: {100 = vermell, 101 = verd, 102 = blau}
Després d'afegir la clau absent 103: {100 = Vermell, 101 = Verd, 102 = Blau, 103 = Morat}
Mapa simultani després d'eliminar 101: {100 = vermell, 102 = blau, 103 = morat}
Afegiu la clau absent 101: {100 = vermell, 101 = marró, 102 = blau, 103 = morat}
Substitueix el valor de la clau 101: {100 = vermell, 101 = verd, 102 = blau, 103 = morat}

Mapa simultani a Java

Mapa sincronitzat a Java

Un mapa sincronitzat és un mapa protegit per fils i amb el suport d’un mapa determinat. A Java, el mapa sincronitzat s’obté mitjançant el mètode synchronizedMap () de la classe java.util.Collections. Aquest mètode retorna un mapa sincronitzat per a un mapa determinat.

Aquest mapa sincronitzat retornat s'utilitza per accedir al mapa de suport per obtenir accés en sèrie.

La declaració general del mètode synchronizedMap () és:

public static Map synchronizedMap(Map m)

on m => és el mapa recolzat.

Com ja s'ha esmentat, aquest mètode retorna la vista sincronitzada del mapa m.

El programa Java següent és un exemple de mapa sincronitzat.

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); } }

Sortida:

Mapa original (recolzat): {1 = 10, 2 = 20, 3 = 30, 4 = 40, 5 = 50}
Mapa sincronitzat després de treure (3, 30): {1 = 10, 2 = 20, 4 = 40, 5 = 50}

Mapa sincronitzat a Java

Mapa estàtic a Java

Un mapa estàtic a Java és un mapa que es declara estàtic igual que una variable estàtica. En declarar un mapa estàtic, es converteix en una variable de classe accessible sense utilitzar l'objecte.

Hi ha dos enfocaments per crear i inicialitzar un mapa estàtic a Java.

# 1) Utilització d'una variable estàtica

Aquí, creem una variable de mapa estàtic i la instanciem juntament amb la declaració.

Aquest enfocament es demostra al següent programa 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); } }

Sortida:

Mapa estàtic mitjançant la variable de mapa estàtic:
{1 = Índia, 2 = Portugal, 3 = Alemanya}

Utilitzant bloc estàtic

# 2) Ús de bloc estàtic

En això, creem una variable de mapa estàtic. A continuació, creem un bloc estàtic i dins d’aquest bloc estàtic inicialitzem la variable del mapa.

El programa següent ho demostra.

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); } }

Sortida:

Mapa estàtic amb bloc estàtic:
{1 = Vermell, 2 = Verd, 3 = Blau}

quin tipus de programari necessiteu per utilitzar un telèfon d'Internet?

Utilitzant bloc estàtic

Conversió de la llista al mapa

En aquesta secció, parlarem dels mètodes per convertir la llista en un mapa.

Els dos mètodes inclouen:

Mètode tradicional

En el mètode tradicional, cada element de la llista es copia al mapa mitjançant un bucle per a cada bucle.

Aquesta implementació es mostra a continuació:

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); } }

Sortida:

La llista donada: (Vermell, verd, blau, marró, blanc)
Mapa generat a partir de la llista: {1 = vermell, 2 = verd, 3 = blau, 4 = marró, 5 = blanc}

Mètode tradicional

Llista per mapar a Java 8

També podem utilitzar el mètode Java 8 Collectors.mapOf () que convertirà la llista donada en un mapa.

El programa següent ho demostra.

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); } }

Sortida:

Mapa obtingut de la llista: {1 = Àbac, 2 = Matemàtiques, 3 = Física, Química}

Llista al mapa a Java 8

En aquest programa, tenim una classe Subject que actua com a classe de llista. La classe Subject té dos camps, és a dir, sub_id i sub_name. Disposem de mètodes per llegir els valors del camp de la classe. A la funció principal, creem objectes d’aquesta classe i construïm una llista.

Aquesta llista es converteix al mapa mitjançant el mètode Collectors.MapOf que pren els elements un per un. També pren el sub_Id com a clau del mapa. Finalment, es genera el mapa que té sub_Id com a clau i Sub_Name com a valor.

Converteix el mapa en cadena a Java

Una col·lecció de mapes es pot convertir en una cadena mitjançant dos enfocaments:

Utilització de StringBuilder

Aquí creem un objecte StringBuilder i després copiem els parells clau-valor del mapa a l’objecte StringBuilder. A continuació, convertim l’objecte StringBuilder en una cadena.

El programa següent mostra el codi Java per convertir el mapa a la cadena.

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()); } }

Sortida:

El mapa donat: {20 = Vint, 40 = Quaranta, 10 = Deu, 30 = Trenta}
La representació en cadena del mapa:
{20 = Vint, 40 = Quaranta, 10 = Deu, 30 = Trenta}

Utilització de StringBuilder

Ús de corrents de Java 8

En aquest mètode, creem un flux a partir de les tecles del mapa i després el convertim a la cadena.

El programa que es mostra a continuació mostra la conversió del mapa a una cadena mitjançant fluxos.

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); } }

Sortida:

El mapa donat: {20 = Vint, 40 = Quaranta, 10 = Deu, 30 = Trenta}
La representació en cadena del mapa:
{20 = Vint, 40 = Quaranta, 10 = Deu, 30 = Trenta}

Utilitzant corrents de Java 8

Converteix el mapa en llista a Java

Un mapa consta de claus i valors mentre que una llista és una seqüència d'elements individuals. En convertir el mapa en una llista, normalment convertim les claus en una llista de claus i valors en una llista de valors.

El següent programa Java mostra aquesta conversió.

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); } }

Sortida:

Llista de claus del mapa donat:
(50, 20, 40, 10, 30)
Llista de valors del mapa donat:
(magenta, verd, cian, vermell, blau)

Convertiu el mapa a la llista a Java

Diccionari vs. Mapa a Java

Analitzem algunes de les principals diferències entre un diccionari i un mapa a Java.

Diccionari	Mapa
Diccionari és una classe abstracta.	El mapa és una interfície.
Les classes i mètodes utilitzats per la classe del diccionari són anteriors al marc de col·leccions.	Les classes i els mètodes utilitzats per les classes de mapes formen part del marc de col·lecció.
Si una classe amplia el diccionari, no pot ampliar cap altra classe ja que Java només admet una sola herència	El mapa és una interfície, de manera que una classe pot heretar del mapa i d'altres interfícies
Implementació antiga. Quasi obsolet en les versions més recents de Java.	La interfície del mapa ha substituït la implementació del diccionari.

Preguntes freqüents

P # 1) Per què fem servir una interfície de mapa a Java?

Resposta: El mapa és una interfície a Java que s’implementa mitjançant classes que emmagatzemen dades com a parells clau-valor. La interfície de mapa proporciona operacions / mètodes que es poden realitzar en parells clau-valor com ara inserció, actualització, supressió, etc.

Q # 2)Què significa MAP a Java?

Resposta: Un mapa a Java representa un mapatge d’una clau amb un valor específic. Un mapa Java emmagatzema aquests parells clau-valor en un mapa. Podem mirar cap amunt i recuperar el valor associat a una clau només utilitzant la clau del mapa.

Un mapa s’implementa a Java mitjançant una interfície que no forma part de la interfície de col·lecció. Però el mapa és una col·lecció.

Q # 3)Què és MAP?

Resposta: El get () és un mètode proporcionat per una interfície de mapa a Java que s’utilitza per recuperar el valor associat a una clau determinada proporcionada com a argument del mètode get (). Si el valor no està present, es torna un valor nul.

Q # 4)El mapa és una col·lecció?

Resposta: Tot i que el mapa es visualitza com una col·lecció en general, no implementa una interfície de col·lecció. Algunes de les implementacions de mapes, com treemap, no admeten valors ni claus nuls.

Q # 5)Quina diferència hi ha entre el conjunt i el mapa?

Resposta: El conjunt és només una col·lecció de claus mentre que el mapa és una col·lecció de parells clau-valor. Tot i que el conjunt no permet valors nuls, algunes de les implementacions de mapes permeten valors nuls.

El conjunt no permet duplicar les claus. El mapa pot permetre valors duplicats, però les claus han de ser úniques. El conjunt s’utilitza generalment quan volem emmagatzemar una col·lecció d’elements únics. El mapa es pot utilitzar quan necessitem emmagatzemar dades en forma de parells clau-valor.

Conclusió

En aquest tutorial, hem comentat els conceptes bàsics de la interfície del mapa. També hem vist els diversos mètodes i tots els altres detalls relacionats amb la interfície del mapa a Java. Vam saber que hi ha diverses implementacions d’interfícies de mapes com ara treemap, hashmap, etc.

En els nostres propers tutorials, analitzarem aquesta implementació del mapa amb més detall.

=> Visiteu aquí per aprendre Java des de zero.

Tutorial de la interfície de mapa de Java amb implementació i exemples

Mapes a Java

Creeu un mapa a Java

Inicialitzeu un mapa a Java

# 1) Ús de col·leccions

# 2) Ús de Java 8

# 3) Utilitzant el mètode put de la interfície de mapa

# 4) Ús de la inicialització de doble parèntesi

Repeteix el mapa a Java i imprimeix el mapa

Utilització d’Iterator d’Entry

Ús d’una entrada per a cada bucle

Mètodes del mapa

Implementació de mapes Java

Ordenant un mapa a Java

Ordena per clau

Ordena per valor

Mapa simultani a Java

Mapa sincronitzat a Java

Mapa estàtic a Java

# 1) Utilització d'una variable estàtica

# 2) Ús de bloc estàtic

Conversió de la llista al mapa

Mètode tradicional

Llista per mapar a Java 8

Converteix el mapa en cadena a Java

Utilització de StringBuilder

Ús de corrents de Java 8

Converteix el mapa en llista a Java

Diccionari vs. Mapa a Java

Preguntes freqüents

Conclusió

Lectura recomanada