Meny

Java Kartgrensesnittveiledning med implementering og eksempler

  • Hoved
  • Annen
  • Java Kartgrensesnittveiledning med implementering og eksempler

java map interface tutorial with implementation examples

Prøv Instrumentet Vårt For Å Eliminere Problemer

Denne omfattende Java-kartopplæringen dekker hvordan du oppretter, initialiserer og itererer gjennom kart. Du vil også lære om kartmetoder og implementeringseksempler:

Du vil bli kjent med det grunnleggende om kartgrensesnitt, metoder som støttes av kartgrensesnitt og andre spesifikke termer relatert til kartgrensesnitt.

Kartsamling i Java er en samling som tilordner en nøkkel til en verdi. Det er en samling som består av nøkler og verdier. Hver oppføring på kartet består av en nøkkel med tilhørende verdi. Tastene er unike på kart. Kart kan vanligvis brukes når vi trenger å endre en samling basert på en nøkkelverdi.

=> Sjekk ALLE Java-opplæringsprogrammer her.

Kartgrensesnitt i Java

Hva du vil lære:

Kart i Java

Kartet i Java er en del av grensesnittet java.util.map. Kartgrensesnittet er ikke en del av samlingsgrensesnittet, og det er grunnen til at kartene er forskjellige fra de andre samlingene.

Det generelle hierarkiet til kartgrensesnittet er vist nedenfor.

generelt hierarki i kartgrensesnittet

Som vist ovenfor er det to grensesnitt for å implementere kart, dvs. kartgrensesnitt og sortedMap-grensesnitt. Det er tre klasser, dvs. HashMap, TreeMap og LinkedHashMap.

Disse karttypene er beskrevet nedenfor:

KlasseBeskrivelse
ta vekkV fjerne (Objektnøkkel)Slett en kartoppføring for den gitte nøkkelen
LinkedHashMapStrekker seg fra HashMap-klassen. Dette kartet opprettholder innsettingsrekkefølgen
HashMapImplementere et kartgrensesnitt. Ingen ordre opprettholdes av HashMap.
TreeMapImplementerer både kart og sortedMap-grensesnitt. TreeMap opprettholder en stigende rekkefølge.

Poeng å huske på kart.

  1. I kart kan hver nøkkel tilordnes høyst en verdi. Det kan heller ikke være dupliserte nøkler i kartene.
  2. Kartimplementeringer som HashMap og LinkedHashMap tillater nullnøkkel og nullverdier. TreeMap tillater imidlertid ikke det.
  3. Et kart kan ikke krysses slik det er. Derfor for å krysse, må den konverteres for å angis ved hjelp av keyset () eller entrySet () -metoden.

Lag et kart i Java

For å lage et kart i Java må vi først ta med grensesnittet i programmet vårt. Vi kan bruke en av følgende påstander i programmet for å importere kartfunksjonaliteten.

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

Vi må sette i gang en konkret implementering av kartet ettersom det er et grensesnitt.

Følgende utsagn oppretter et kart i Java.

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

Ovennevnte utsagn vil opprette kart med standardspesifikasjoner.
Vi kan også lage generiske kart som spesifiserer typene for både nøkkel og verdi.

Map myMap = new HashMap();

Ovennevnte definisjon vil ha nøkler av typen streng og objekter som verdier.

Initialiser et kart i Java

Det kan initialiseres ved hjelp av følgende metoder:

# 1) Bruke samlinger

Java Collections-klassen har fabrikkmetoder som kan brukes til å initialisere samlinger, inkludert kart.

Noen metoder som brukes til å initialisere kartet er som følger:

(1) Collections.EmptyMap ()

Collections.EmptyMap () returnerer et seriøst og uforanderlig kart som er tomt. For eksempel, følgende kodelinje,

Map myMap = Collections.EMPTY_MAP;

Dette vil skape et tomt kart. Ovennevnte metode kan kaste ‘ukontrollert oppdragsvarsel’, og dermed kan vi også bruke den typesikre skjemaet som følger.

Map myMap = Collections.emptyMap ();

(2) Collections.unModifiableMap ()

Metoden unModifiableMap () tar et annet kart som argument og skaper en umodifiserbar visning av det originale kartet.

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

(3) Collections.singletonMap ()

Samlingskurs gir også en fabrikkmetode ‘singletonMap ()’ som skaper et uforanderlig singleton-kart med bare én oppføring.

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

# 2) Bruke Java 8

Vi kan få en datastrøm fra Java 8 stream API-metoder og konstruere kart ved hjelp av Collectors.

Noen av metodene for å lage kart er:

(1) Collectors.toMap ()

Vi samler en strøm og bruker deretter Collectors.toMap () -metoden til å lage et kart.

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

Ovennevnte uttalelse oppretter et kart fra Java 8-strømmen.

(2) Collectors.collectingAndThen ()

I dette tilpasser vi metoden toMap () som gjør at samleren kan produsere et uforanderlig kart ved hjelp av metoden collectorAndThen ().

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) Bruker put-metoden til Kartgrensesnittet

Put () -metoden til kartgrensesnittet kan brukes til å tilordne startverdier til kart.

# 4) Bruke initialisering med dobbel brace

Teknikken 'initialisering av dobbelt stag' skaper en indre klasse. Denne klassen er anonym og har en instansestarter. Dette er ikke en foretrukket teknikk og bør unngås, da det kan føre til minnelekkasjer eller serialiseringsproblemer.

Programmet nedenfor viser de forskjellige metodene for initialisering av et kart som er diskutert ovenfor.

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

Produksjon:

umodifiserbare kartverdier: {}
singleton_map Kartverdier: {10 = TEN}
map_cities-verdier: {CH = Chennai, DL = New Delhi, MH = Mumbai}
capitals_Map-verdier: {MAH = Mumbai, GOA = Panaji, KAR = Bangaluru}
Kartverdier: {USA = Washington, GER = Berlin, UK = London, IND = Delhi}

initialisere et kart

Iterere over kart i Java og skrive ut kartet

Vi kan krysse kartet akkurat på samme måte som vi krysser de andre samlingene. I tillegg til å krysse kartoppføringer, kan vi også krysse bare tastene eller bare verdiene i kartet. Merk at for å krysse et kart, må det konverteres for å settes først.

Følgende metoder brukes til å krysse kartoppføringene.

Bruke Entry Iterator

I denne metoden får vi en oppførings-iterator fra et oppføringssett. Deretter henter vi nøkkelverdiparet for hver kartoppføring ved hjelp av getKey og getValue-metodene.

Følgende program viser bruken av en oppførings-iterator.

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

Produksjon:

Kartoppføringene er:
NØKKELVERDI
CH Chennai
DL New Delhi
MH Mumbai

Bruke entry iterator

I det ovennevnte programmet får vi en oppførings-iterator fra kartet ved å bruke metoden entrySet. Deretter krysser vi kartet ved hjelp av hasNext () -metoden for oppføring av iterator og skriver ut nøkkelverdiparet.

Bruke en oppføring for hver løkke

Her krysser vi entrySet ved hjelp av for-hver løkke, og implementeringen er vist nedenfor.

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

Produksjon:

Kartoppføringene er:
NØKKELVERDI
CH Chennai
DL New Delhi
MH Mumbai

Ved hjelp av en oppføring for hver løkke

Kartmetoder

Kartgrensesnitt i Java støtter forskjellige operasjoner som ligner på de som støttes av andre samlinger. I denne delen vil vi diskutere de forskjellige metodene som tilbys av Map API i Java. Siden omfanget av denne opplæringen er begrenset til å introdusere et kartgrensesnitt generelt, vil vi ikke beskrive disse metodene.

Vi vil diskutere disse metodene i detalj mens vi diskuterer kartgrensesnittklasser.

Tabellen nedenfor viser alle metodene som tilbys av map API.

MetodenavnMetode PrototypeBeskrivelse
fåV get (Objektnøkkel)Returnerer objektet eller verdien for den gitte nøkkelen
setteV put (Objektnøkkel, Objektverdi)Sett inn nøkkelverdioppføring på kartet
putt allevoid putAll (Kartkart)Sett inn gitte kartoppføringer i kartet. Med andre ord kopierer eller kloner et kart.
keySetSet keySet ()Returnerer angitt visning av kartet.
entrySetSettentrySet ()Returnerer angir visningen for et gitt kart
verdierSamlingsverdier ()Returnerer samlingsvisning av verdiene i kartet.
størrelseint størrelse ()Returnerer antall oppføringer på kartet
klarugyldig klart ()Tømmer kartet
er tomboolsk isEmpty ()Sjekker om kartet er tomt og returnerer sant hvis ja.
inneholder verdiboolean containsValue (Objektverdi)Returnerer sant hvis kartet inneholder verdien lik den gitte verdien
inneholder nøkkelboolsk inneholderKey (Objektnøkkel)Returnerer sant hvis det finnes en gitt nøkkel i kartet
er likboolsk lik (Objekt o)Sammenligner spesifisert objekt o med kartet
hashCodeint hashCode ()
returnerer hash-koden for kartet
for hverugyldig forEach (BiConsumer action)Utfører gitt handling for hver oppføring på kartet
getOrDefaultV getOrDefault (Objektnøkkel, V defaultValue)Returnerer spesifisert verdi for den gitte nøkkelen eller standardverdien hvis nøkkelen ikke er tilstede
ta vekkboolsk fjern (Objektnøkkel, Objektverdi)Fjerner spesifiserte nøkler og verdier
erstatteV erstatt (K-tast, V-verdi)Erstatter den gitte nøkkelen med den angitte verdien
erstatteboolsk erstatning (K-tast, V oldValue, V newValue)Erstatter den gamle verdien med en ny verdi for en gitt nøkkel
erstatte alleugyldig erstatte alle (BiFunction-funksjon)Påkaller gitt funksjon for å erstatte alle kartoppføringene
putIfAbsentV putIfAbsent (K-tast, V-verdi)Setter inn den gitte nøkkelen, verdien bare hvis den ikke allerede er til stede
beregneV beregne (K-tast, BiFunction remappingFunction)Beregner kartlegging for spesifisert nøkkel og verdi gitt kartleggingsfunksjonen.
computeIfAbsentV computeIfAbsent (K-tast, Funksjon mappingFunction)Beregn verdien for den gitte nøkkelen ved hjelp av kartleggingsfunksjonen hvis den ikke allerede er til stede.
computeIfPresentV computeIfPresent (K-tast, BiFunction remappingFunction)Beregner ny kartlegging for den gitte nøkkelen med den gitte remapping-funksjonen hvis nøkkelverdien allerede er til stede
gåV flette (K-tast, V-verdi, BiFunction remappingFunction)Knytter en gitt nøkkel til verdien hvis den ikke allerede er tilknyttet eller er knyttet til nullverdien.

Alle metodene ovenfor støttes av kartgrensesnittet. Merk at metodene som ser ut til å være skyggelagte, er de nye metodene som ble inkludert i Java 8.

Java Map Implementation

Følgende program implementerer et karteksempel i Java. Her bruker vi de fleste metodene som er diskutert ovenfor.

Eksemplet viser forskjellige få operasjoner, sette og sette operasjoner.

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

Produksjon:

Nøkkel = CHN, Verdi: Kina
Nøkkel = XX, verdi: null
null keyExists: true, null valueExists = true
oppføringssett for country_map: (null = Z, XX = null, CHN = China, SL = Srilanka, IND = India, KOR = Korea)
Landstørrelse: 6
data_map kartlagt til country_map: {null = Z, XX = null, CHN = China, SL = Srilanka, IND = India, KOR = Kore
til}
null nøkkelverdi for data_map: Z
data_map etter fjerning av nullnøkkel = {XX = null, CHN = Kina, SL = Srilanka, IND = India, KOR = Korea}
datakartnøkler: (null, XX, CHN, SL, IND, KOR)
datakartverdier: (Z, null, Kina, Srilanka, India, Korea)
datakart etter klar drift, er tomt: sant

få operasjoner, sette og sette operasjoner

Sortere et kart i Java

Ettersom et kart består av nøkkelverdipar, kan vi sortere kartet på nøkler eller verdier.

I denne delen vil vi sortere et kart på både nøkler og verdier.

Sorter etter nøkkel

For å sortere et kart på nøkler, kan vi bruke et trekart. Trekartet sorterer tastene automatisk. Java-programmet nedenfor konverterer et kart til et trekart og viser de sorterte tastene.

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

Produksjon:

Originalt usortert kart:
Et Amerika
C Kina
D Danmark
X Hongkong
Jeg India
Kart sortert etter nøkkel:
Et Amerika
C Kina
D Danmark
Jeg India
X Hongkong

Sorter etter nøkkel

Ovennevnte program oppretter et kart bestående av en enkelt alfabetkode som nøkler og landnavn som verdier. Først viser vi det originale kartet som ikke er sortert. Deretter konverterer vi kartet til et trekart som automatisk sorterer nøklene. Til slutt viser vi det sorterte trekartet på tastene.

Sorter etter verdi

For å sortere et kart basert på verdier, konverterer vi først kartet til en liste. Deretter sorterer vi denne listen ved hjelp av Collections.sort () -metoden som bruker en komparator for å sammenligne verdiene og ordne dem i en bestemt rekkefølge.

Når listen er sortert, kopieres de koblede listeoppføringene igjen til kartet som gir oss det sorterte kartet.

Følgende Java-program viser sorteringen av et kart basert på verdi. Programmet bruker LinkedHashMap som videreføres til sorteringsfunksjonen. I sorteringsfunksjonen konverteres den til en koblet liste og sorteres. Etter sortering konverteres den tilbake til LinkedHashMap.

de beste spillselskapene å jobbe for
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; } }

Produksjon:

Originalt usortert kart:
{NEP = Kathmandu, IND = New Delhi, USA = Washington, UK = London, AUS = Canberra

Kart sortert etter verdi:
Nøkkelverdi
FRA Canberra
NEP Katmandu
UK London
IND New Delhi
USA Washington

Sorter etter verdi

Samtidig kart i Java

En concurrentMap er et grensesnitt som arver fra java.util.map-grensesnittet. ConcurrentMap-grensesnittet ble først introdusert i JDK 1.5 og gir et kart som håndterer samtidig tilgang.

ConcurrentMap-grensesnittet er en del av pakken java.util.concurrent.

Følgende Java-program demonstrerer concurrentMap i 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); } }

Produksjon:

Innledende samtidig kart: {100 = rød, 101 = grønn, 102 = blå}
Etter å ha lagt til fraværende nøkkel 103: {100 = Rød, 101 = Grønn, 102 = Blå, 103 = Lilla}
Samtidig kart etter fjerning av 101: {100 = rød, 102 = blå, 103 = lilla}
Legg til fraværende nøkkel 101: {100 = Rød, 101 = Brun, 102 = Blå, 103 = Lilla}
Bytt ut verdien ved tast 101: {100 = Rød, 101 = Grønn, 102 = Blå, 103 = Lilla}

Samtidig kart i Java

Synkronisert kart i Java

Et synkronisert kart er et kart som er trådsikkert og støttet av et gitt kart. I Java oppnås det synkroniserte kartet ved hjelp av metoden synchronizedMap () i klassen java.util.Collections. Denne metoden returnerer et synkronisert kart for et gitt kart.

Dette returnerte synkroniserte kartet brukes til å få tilgang til sikkerhetskopikartet for å oppnå seriell tilgang.

Den generelle erklæringen om synchronizedMap () -metoden er:

public static Map synchronizedMap(Map m)

hvor m => er kartet som støttes.

Som allerede nevnt returnerer denne metoden den synkroniserte visningen av kart m.

Java-programmet nedenfor er et eksempel på et synkronisert kart.

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

Produksjon:

Original (støttet) Kart: {1 = 10, 2 = 20, 3 = 30, 4 = 40, 5 = 50}
Synkronisert kart etter fjerning (3, 30): {1 = 10, 2 = 20, 4 = 40, 5 = 50}

Synkronisert kart i Java

Statisk kart i Java

Et statisk kart i Java er et kart som blir erklært statisk akkurat som en statisk variabel. Ved å erklære et kart statisk blir det en tilgjengelig klassevariabel uten å bruke objektet.

Det er to tilnærminger for å lage og initialisere et statisk kart i Java.

# 1) Bruke en statisk variabel

Her lager vi en statisk kartvariabel og instantiserer den sammen med erklæringen.

Denne tilnærmingen er demonstrert i det følgende Java-programmet.

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

Produksjon:

Statisk kart ved bruk av statisk kartvariabel:
{1 = India, 2 = Portugal, 3 = Tyskland}

Bruker statisk blokk

# 2) Bruke statisk blokk

I dette lager vi en statisk kartvariabel. Deretter lager vi en statisk blokk og inne i denne statiske blokken initialiserer vi kartvariabelen.

Programmet nedenfor viser dette.

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

Produksjon:

Statisk kart ved bruk av statisk blokk:
{1 = Rød, 2 = Grønn, 3 = Blå}

Bruker statisk blokk

Konvertering av listen til kart

I denne delen vil vi diskutere metodene for å konvertere listen til et kart.

De to metodene inkluderer:

Tradisjonell metode

I den tradisjonelle metoden kopieres hvert listeelement til kart ved hjelp av en for-hver sløyfe.

Denne implementeringen er vist nedenfor:

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

Produksjon:

Den gitte listen: (Rød, Grønn, Blå, Brun, Hvit)
Kart generert fra liste: {1 = rød, 2 = grønn, 3 = blå, 4 = brun, 5 = hvit}

Tradisjonell metode

Liste over kart i Java 8

Vi kan også bruke Java 8-metoden Collectors.mapOf () som konverterer den gitte listen til et kart.

Programmet nedenfor viser dette.

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

Produksjon:

Kart hentet fra listen: {1 = kuleramme, 2 = matematikk, 3 = fysikk, kjemi}

Liste over kart i Java 8

I dette programmet har vi en klasse Emne som fungerer som en liste klasse. Klassen Emne har to felt, dvs. undernavn og undernavn. Vi har metoder for å lese feltverdiene fra klassen. I hovedfunksjonen lager vi objekter av denne klassen og lager en liste.

Denne listen blir deretter konvertert til kartet ved hjelp av Collectors.MapOf-metoden som tar elementene en etter en. Det tar også sub_Id som nøkkelen til kartet. Til slutt genereres kartet som har under_id som nøkkel og undernavn som verdi.

Konverter kart til streng i Java

En kortsamling kan konverteres til en streng ved å bruke to tilnærminger:

Bruke StringBuilder

Her oppretter vi et StringBuilder-objekt og kopierer deretter nøkkelverdiparene til kartet til StringBuilder-objektet. Deretter konverterer vi StringBuilder-objektet til en streng.

Programmet nedenfor viser Java-koden for å konvertere kartet til strengen.

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

Produksjon:

Det gitte kartet: {20 = tjue, 40 = førti, 10 = ti, 30 = tretti}
Strengrepresentasjonen av kart:
{20 = Tjue, 40 = Førti, 10 = Ti, 30 = Tretti}

Bruke StringBuilder

Bruke Java 8 Streams

I denne metoden oppretter vi en strøm ut av karttastene og konverterer den deretter til strengen.

Programmet nedenfor viser konvertering av kartet til en streng ved hjelp av strømmer.

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

Produksjon:

Det gitte kartet: {20 = tjue, 40 = førti, 10 = ti, 30 = tretti}
Strengrepresentasjonen av kart:
{20 = Tjue, 40 = Førti, 10 = Ti, 30 = Tretti}

Bruke Java 8-strømmer

kjør .jar-filvinduer 10

Konverter kart til liste i Java

Et kart består av nøkler og verdier, mens en liste er en sekvens av individuelle elementer. Når vi konverterer kartet til en liste, konverterer vi vanligvis nøkler til en liste over nøkler og verdier til en liste over verdier.

Følgende Java-program viser denne konverteringen.

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

Produksjon:

Liste over nøkler fra det gitte kartet:
(50, 20, 40, 10, 30)
Liste over verdier fra det gitte kartet:
(magenta, grønn, cyan, rød, blå)

Konverter kartet til liste i Java

Dictionary Vs. Kart i Java

La oss diskutere noen av de største forskjellene mellom en ordbok og et kart i Java.

OrdbokKart
Ordbok er en abstrakt klasse.Kartet er et grensesnitt.
Klasser og metoder som brukes av ordboksklassen, rammer for samlinger før samlinger.Klasser og metoder som brukes av kartklasser er en del av samlerammen.
Hvis en klasse utvider ordboken, kan den ikke utvide noen annen klasse siden Java bare støtter enkelt arvKartet er et grensesnitt, slik at en klasse kan arve fra kartet og andre grensesnitt
Gammel implementering. Nesten foreldet i nyere versjoner av Java.Kartgrensesnittet har erstattet ordboksimplementeringen.

ofte stilte spørsmål

Q # 1) Hvorfor bruker vi et kartgrensesnitt i Java?

Svar: Kartet er et grensesnitt i Java som implementeres av klasser som lagrer data som nøkkelverdipar. Kartgrensesnittet gir operasjoner / metoder som kan utføres på nøkkelverdipar som innsetting, oppdatering, sletting, etc.

Q # 2)Hva betyr MAP i Java?

Svar: Et kart i Java representerer en kartlegging av en nøkkel med en spesifikk verdi. Et Java-kart lagrer disse nøkkelverdiparene på et kart. Vi kan slå opp og hente verdien som er knyttet til en nøkkel bare ved å bruke nøkkelen i kartet.

Et kart er implementert i Java ved hjelp av et grensesnitt som ikke er en del av samlingsgrensesnittet. Men kartet er en samling.

Q # 3)Hva er MAP get?

Svar: Get () er en metode levert av et kartgrensesnitt i Java som brukes til å hente verdien som er knyttet til en bestemt nøkkel som er gitt som et argument for get () -metoden. Hvis verdien ikke er tilstede, returneres null.

Q # 4)Er kartet en samling?

Svar: Selv om kartet blir sett på som en samling generelt, implementerer det ikke et samlingsgrensesnitt. Noen av implementeringene av kart, som treemap, støtter ikke nullverdier eller nøkler.

Q # 5)Hva er forskjellen mellom sett og kart?

Svar: Sett er bare en samling nøkler mens kartet er en samling av nøkkelverdipar. Mens settet ikke tillater nullverdier, tillater noen av kartimplementeringene nullverdier.

Sett tillater ikke dupliserte nøkler. Kartet kan tillate dupliserte verdier, men nøklene må være unike. Sett brukes vanligvis når vi vil lagre en samling av unike elementer. Kartet kan brukes når vi trenger å lagre data i form av nøkkelverdipar.

Konklusjon

I denne veiledningen har vi diskutert det grunnleggende i kartgrensesnittet. Vi har også sett de forskjellige metodene og alle andre detaljer relatert til kartgrensesnittet i Java. Vi fikk vite at det er forskjellige implementeringer av kartgrensesnitt, inkludert treemap, hashmap, etc.

I våre kommende veiledninger vil vi diskutere denne kartimplementeringen mer detaljert.

=> Besøk her for å lære Java fra bunnen av.

Anbefalt lesing

^