java map interface tutorial with implementation examples
Denne omfattende Java-kortvejledning dækker, hvordan du opretter, initialiserer og gentager via kort. Du vil også lære om kortmetoder og eksempler på implementering:
Du får kendskab til det grundlæggende i kortgrænsefladen, metoder, der understøttes af kortgrænsefladen og andre specifikke termer relateret til kortgrænsefladen.
Kortsamling i Java er en samling, der kortlægger en nøgle til en værdi. Det er en samling bestående af nøgler og værdier. Hver post på kortet består af en nøgle med dens tilsvarende værdi. Tasterne er unikke på kort. Kort kan typisk bruges, når vi har brug for at ændre en samling baseret på en nøgleværdi.
=> Tjek ALLE Java-tutorials her.
Hvad du vil lære:
- Kort i Java
- Kortmetoder
- Implementering af Java-kort
- Konklusion
Kort i Java
Kortet i Java er en del af java.util.map-grænsefladen. Kortgrænsefladen er ikke en del af samlingsgrænsefladen, og det er grunden til, at kort adskiller sig fra de andre samlinger.
Det generelle hierarki af kortgrænsefladen er vist nedenfor.
Som vist ovenfor er der to grænseflader til implementering af kort, dvs. kortgrænseflade og sorteret kortgrænseflade. Der er tre klasser, dvs. HashMap, TreeMap og LinkedHashMap.
Disse korttyper er beskrevet nedenfor:
| Klasse | Beskrivelse | |
|---|---|---|
| fjerne | V fjern (Objektnøgle) | Slet en kortindgang for den givne nøgle |
| LinkedHashMap | Udvides fra HashMap-klassen. Dette kort opretholder indsætningsrækkefølgen | |
| HashMap | Implementere en kortgrænseflade. Ingen ordre opretholdes af HashMap. | |
| TreeMap | Implementerer både kort og sortedMap interface. TreeMap opretholder en stigende rækkefølge. |
Point at huske om kort.
- På kort kan hver nøgle kortlægges til den højst én værdi. Der kan heller ikke være duplikatnøgler på kortene.
- Kortimplementeringer som HashMap og LinkedHashMap tillader null-nøgle og null-værdier. TreeMap tillader det dog ikke.
- Et kort kan ikke krydses, som det er. Derfor skal det konverteres for at krydse for at indstille ved hjælp af nøglesæt () eller entrySet () -metoden.
Opret et kort i Java
For at oprette et kort i Java skal vi først inkludere grænsefladen i vores program. Vi kan bruge et af følgende udsagn i programmet til at importere kortfunktionaliteten.
import java.util.*; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.TreeMap; Vi er nødt til at starte en konkret implementering af kortet, da det er en grænseflade.
Følgende udsagn opretter et kort i Java.
Map hash_map = new HashMap(); Map tree_map = new TreeMap(); Ovenstående udsagn opretter kort med standardspecifikationer.
Vi kan også oprette generiske kort, der specificerer typerne for både nøgle og værdi.
Map myMap = new HashMap(); Ovenstående definition vil have nøgler af typen streng og objekter som værdier.
Initialiser et kort i Java
Det kan initialiseres ved hjælp af følgende metoder:
# 1) Brug af samlinger
Java Collections-klassen har fabriksmetoder, der kan bruges til at initialisere samlinger inklusive kort.
Nogle metoder, der bruges til at initialisere kort, er som følger:
(1) Collections.EmptyMap ()
Collections.EmptyMap () returnerer et serielt og uforanderligt kort, der er tomt. For eksempel, følgende kodelinje,
Map myMap = Collections.EMPTY_MAP; Dette opretter et tomt kort. Ovenstående metode kan muligvis kaste 'ikke-markeret tildelingsadvarsel', og derfor kan vi også bruge den typesikre form som følger.
Map myMap = Collections.emptyMap (); (2) Collections.unModifiableMap ()
Metoden unModifiableMap () tager et andet kort som et argument og skaber en umodificerbar visning af det originale kort.
Map myMap = Collections.EMPTY_MAP; Map map_unmodifiable = Collections.unmodifiableMap (myMap); (3) Collections.singletonMap ()
Samlingsklassen giver også en fabriksmetode 'singletonMap ()', der skaber et uforanderligt singleton-kort, der kun har en post.
Map singleton_map = Collections.singletonMap('CHN', 'Beijing'); # 2) Brug af Java 8
Vi kan hente en datastrøm fra Java 8 stream API-metoder og konstruere kort ved hjælp af Collectors.
Nogle af metoderne til at konstruere kort er:
(1) Collectors.toMap ()
Vi indsamler en stream og bruger derefter Collectors.toMap () -metoden til at konstruere et kort.
Map map = Stream.of(new String()(){{'USA', 'Washington'}, {'United Kingdom', 'London'} }).collect(Collectors.toMap(p -> p(0), p -> p(1))); Ovenstående erklæring opretter et kort fra Java 8-strømmen.
(2) Collectors.collectingAndThen ()
I dette tilpasser vi metoden toMap (), der gør det muligt for samleren at producere et uforanderligt kort ved hjælp af 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) Brug af put-metoden i Map Interface
Put () -metoden i kortgrænsefladen kan bruges til at tildele startværdier til kort.
# 4) Brug af initialisering med dobbelt afstivning
Teknikken 'initialisering med dobbelt stivhed' skaber en indre klasse. Denne klasse er anonym og har en instans initialisering i den. Dette er ikke en foretrukken teknik og bør undgås, da det kan resultere i hukommelseslækager eller serialiseringsproblemer.
Nedenstående program viser de forskellige metoder til initialisering af et kort, der er diskuteret 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); } }Produktion:
umodificerbare kortværdier: {}
singleton_map Kortværdier: {10 = TEN}
map_cities værdier: {CH = Chennai, DL = New Delhi, MH = Mumbai}
capitals_Map-værdier: {MAH = Mumbai, GOA = Panaji, KAR = Bangaluru}
Kortværdier: {USA = Washington, GER = Berlin, UK = London, IND = Delhi}
Iterere over kort i Java og udskrive kortet
Vi kan krydse kortet på samme måde, som vi krydser de andre samlinger. Ud over at krydse kortindgange kan vi også kun krydse tasterne eller kun værdierne på kortet. Bemærk, at for at krydse et kort skal det konverteres for først at indstille det.
Følgende metoder bruges til at krydse kortindgange.
Brug af indgangsterator
I denne metode får vi en post-iterator fra et indgangssæt. Derefter henter vi nøgleværdipar for hver kortindgang ved hjælp af getKey og getValue-metoderne.
Det følgende program viser brugen af en post-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()); } } } Produktion:
Kortindgangene er:
NØGLEVÆRDI
CH Chennai
DL New Delhi
MH Mumbai
I ovenstående program får vi en post iterator fra kortet ved hjælp af metoden entrySet. Derefter krydser vi kortet ved hjælp af hasNext () -metoden til indtastning iterator og udskriver nøgleværdipar.
Brug af en post for hver løkke
Her krydser vi entrySet ved hjælp af 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()); } } } Produktion:
Kortindgangene er:
NØGLEVÆRDI
CH Chennai
DL New Delhi
MH Mumbai
Kortmetoder
Kortgrænseflade i Java understøtter forskellige operationer svarende til dem, der understøttes af andre samlinger. I dette afsnit vil vi diskutere de forskellige metoder, der leveres af Map API i Java. Da omfanget af denne vejledning er begrænset til at introducere en kortgrænseflade generelt, vil vi ikke beskrive disse metoder.
Vi vil diskutere disse metoder i detaljer, mens vi diskuterer kortinterfaceklasser.
Den følgende tabel viser alle de metoder, der leveres af map API.
| Metodenavn | Metode Prototype | Beskrivelse |
|---|---|---|
| få | V get (Objektnøgle) | Returnerer objektet eller værdien for den givne nøgle |
| sætte | V put (Objektnøgle, Objektværdi) | Indsæt nøgleværdiindtastning på kortet |
| sæt alt | void putAll (Kortkort) | Indsæt givne kortindgange på kortet. Med andre ord kopierer eller kloner et kort. |
| keySet | Set keySet () | Returnerer den indstillede visning af kortet. |
| entrySet | Sæt | Returnerer indstil visningen for et givet kort |
| værdier | Samlingsværdier () | Returnerer samlingsvisning af værdierne på kortet. |
| størrelse | int størrelse () | Returnerer antallet af poster på kortet |
| klar | ugyldigt klart () | Rydder kortet |
| er tom | boolsk isEmpty () | Kontrollerer, om kortet er tomt, og returnerer sandt, hvis ja. |
| indeholder værdi | boolean containValue (Objektværdi) | Returnerer sandt, hvis kortet indeholder værdien svarende til den givne værdi |
| indeholderKey | boolean containKey (Objektnøgle) | Returnerer sandt, hvis der findes en given nøgle på kortet |
| lige med | boolske lig (Objekt o) | Sammenligner specificeret objekt o med kortet |
| hashCode | int hashCode () | returnerer hash-koden til kortet |
| for hver | ugyldigt for hver (BiConsumer-handling) | Udfører en given handling for hver post på kortet |
| getOrDefault | V getOrDefault (Objektnøgle, V standardværdi) | Returnerer den angivne værdi for den givne nøgle eller dens standardværdi, hvis nøglen ikke er til stede |
| fjerne | boolsk fjernelse (Objektnøgle, Objektværdi) | Fjerner specificerede nøgler og værdier |
| erstatte | V erstat (K-tast, V-værdi) | Erstatter den givne nøgle med den angivne værdi |
| erstatte | boolsk erstatning (K-tast, V oldValue, V newValue) | Erstatter den gamle værdi med en ny værdi for en given nøgle |
| udskift alle | ugyldig erstatte alle (BiFunction-funktion) | Påkalder den givne funktion til at erstatte alle kortindgange |
| putIfAbsent | V putIfAbsent (K-tast, V-værdi) | Indsætter den givne nøgle, kun værdi, hvis den ikke allerede er til stede |
| beregne | V-beregning (K-tast, BiFunction-remappingFunction) | Beregner kortlægning for specificeret nøgle og værdi givet kortlægningsfunktionen. |
| ComputeIfAbsent | V computeIfAbsent (K-tast, FunktionsmappingFunction) | Beregn værdien for den givne nøgle ved hjælp af kortlægningsfunktionen, hvis den ikke allerede er til stede. |
| computeIfPresent | V computeIfPresent (K-tast, BiFunction remappingFunction) | Beregner ny kortlægning for den givne nøgle med den givne remapping-funktion, hvis nøgleværdien allerede er til stede |
| gå | V fletning (K-tast, V-værdi, BiFunction remappingFunction) | Associerer en given nøgle med værdien, hvis den ikke allerede er tilknyttet eller er knyttet til nulværdien. |
Alle ovenstående metoder understøttes af kortgrænsefladen. Bemærk, at metoderne, der ser skyggefulde ud, er de nye metoder, der blev inkluderet i Java 8.
Implementering af Java-kort
Det følgende program implementerer et korteksempel i Java. Her bruger vi de fleste af de metoder, der er diskuteret ovenfor.
Eksemplet viser forskellige få operationer, sætte og indstille operationer.
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()); } } Produktion:
Nøgle = CHN, værdi: Kina
Nøgle = XX, værdi: null
null keyExists: true, null valueExists = true
indgangssæt for country_map: (null = Z, XX = null, CHN = China, SL = Srilanka, IND = India, KOR = Korea)
Landets størrelse: 6
data_map kortlagt til country_map: {null = Z, XX = null, CHN = China, SL = Srilanka, IND = India, KOR = Kore
til}
nul nøgleværdi for data_map: Z
data_map efter fjernelse af nøgle = {XX = null, CHN = Kina, SL = Srilanka, IND = Indien, KOR = Korea}
datakortnøgler: (null, XX, CHN, SL, IND, KOR)
datakortværdier: (Z, null, Kina, Srilanka, Indien, Korea)
datakort efter klar drift er tomt: sandt
Sortering af et kort i Java
Da et kort består af nøgleværdipar, kan vi sortere kortet på taster eller værdier.
I dette afsnit sorterer vi et kort på både nøgler og værdier.
Sorter efter nøgle
For at sortere et kort på tasterne kan vi bruge et treemap. Trækortet sorterer tasterne automatisk. Nedenstående Java-program konverterer et kort til et trækort og viser de sorterede taster.
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()); } } }Produktion:
Originalt usorteret kort:
Et Amerika
C Kina
D Danmark
X Hongkong
Jeg Indien
Kort sorteret efter nøgle:
Et Amerika
C Kina
D Danmark
Jeg Indien
X Hongkong
Ovenstående program opretter et kort bestående af en enkelt alfabetkode som nøgler og landsnavne som værdier. Først viser vi det originale kort, som ikke er sorteret. Derefter konverterer vi kortet til et treemap, der automatisk sorterer tasterne. Endelig viser vi det sorterede trækort på tasterne.
Sorter efter værdi
For at sortere et kort baseret på værdier konverterer vi først kortet til en liste. Derefter sorterer vi denne liste ved hjælp af Collections.sort () -metoden, der bruger en komparator til at sammenligne værdierne og arrangere dem i en bestemt rækkefølge.
Når listen er sorteret, kopieres de sammenkædede listeindgange igen til kortet, hvilket giver os det sorterede kort.
Følgende Java-program viser sorteringen af et kort baseret på værdi. Programmet bruger LinkedHashMap, som sendes videre til sorteringsfunktion. I sorteringsfunktionen konverteres den til en linket liste og sorteres. Efter sortering konverteres den tilbage til LinkedHashMap.
hvordan man åbner swf-filer på pc
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; } } Produktion:
Oprindeligt usorteret kort:
{NEP = Kathmandu, IND = New Delhi, USA = Washington, UK = London, AUS = Canberra
Kort sorteret efter værdi:
Nøgleværdi
FRA Canberra
NEP Kathmandu
UK London
IND New Delhi
USA Washington
Samtidig kort i Java
En concurrentMap er en grænseflade, der arver fra java.util.map-grænsefladen. ConcurrentMap-grænsefladen blev først introduceret i JDK 1.5 og giver et kort, der håndterer samtidig adgang.
ConcurrentMap-grænsefladen er en del af java.util.concurrent-pakken.
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); } }Produktion:
Indledende samtidige kort: {100 = rød, 101 = grøn, 102 = blå}
Efter tilføjelse af fraværende tast 103: {100 = Rød, 101 = Grøn, 102 = Blå, 103 = Lilla}
Samtidig kort efter fjernelse af 101: {100 = rød, 102 = blå, 103 = lilla}
Tilføj fraværende nøgle 101: {100 = Rød, 101 = Brun, 102 = Blå, 103 = Lilla}
Erstat værdi ved tast 101: {100 = rød, 101 = grøn, 102 = blå, 103 = lilla}
Synkroniseret kort i Java
Et synkroniseret kort er et kort, der er trådsikkert og bakkes op af et givet kort. I Java opnås det synkroniserede kort ved hjælp af metoden synchronizedMap () i java.util.Collections-klassen. Denne metode returnerer et synkroniseret kort til et givet kort.
Dette returnerede synkroniserede kort bruges til at få adgang til baggrundskortet for at opnå seriel adgang.
Den generelle erklæring om synchronizedMap () -metoden er:
public static Map synchronizedMap(Map m) hvor m => er det bageste kort.
Som allerede nævnt returnerer denne metode den synkroniserede visning af kort m.
Nedenstående Java-program er et eksempel på et synkroniseret kort.
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); } } Produktion:
hvordan man får vist en eps-fil
Original (bakket) kort: {1 = 10, 2 = 20, 3 = 30, 4 = 40, 5 = 50}
Synkroniseret kort efter fjernelse (3, 30): {1 = 10, 2 = 20, 4 = 40, 5 = 50}
Statisk kort i Java
Et statisk kort i Java er et kort, der erklæres statisk ligesom en statisk variabel. Ved at erklære et kort statisk bliver det en tilgængelig klassevariabel uden at bruge objektet.
Der er to tilgange til oprettelse og initialisering af et statisk kort i Java.
# 1) Brug af en statisk variabel
Her opretter vi en statisk kortvariabel og instantierer den sammen med erklæringen.
Denne tilgang demonstreres i det følgende Java-program.
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); } }Produktion:
Statisk kort ved hjælp af statisk kortvariabel:
{1 = Indien, 2 = Portugal, 3 = Tyskland}
# 2) Brug af statisk blok
I dette opretter vi en statisk kortvariabel. Derefter opretter vi en statisk blok, og indeni denne statiske blok initialiserer vi kortvariablen.
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); } } Produktion:
Statisk kort ved hjælp af statisk blok:
{1 = Rød, 2 = Grøn, 3 = Blå}
Konvertering af listen til kort
I dette afsnit vil vi diskutere metoderne til at konvertere listen til et kort.
De to metoder inkluderer:
Traditionel metode
I den traditionelle metode kopieres hvert listeelement til kort ved hjælp af en for-hver løkke.
Denne implementering 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); } } Produktion:
Den givne liste: (Rød, Grøn, Blå, Brun, Hvid)
Kort genereret fra liste: {1 = rød, 2 = grøn, 3 = blå, 4 = brun, 5 = hvid}
Liste til kort i Java 8
Vi kan også bruge Java 8-metoden Collectors.mapOf (), der konverterer den givne liste til et kort.
Nedenstående program 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); } } Produktion:
Kort hentet fra listen: {1 = Kulemøde, 2 = Matematik, 3 = Fysik, kemi}
I dette program har vi et klasseemne, der fungerer som en listeklasse. Klassen Emne har to felter, dvs. sub_id og sub_name. Vi har metoder til at læse feltværdierne fra klassen. I hovedfunktionen opretter vi objekter af denne klasse og konstruerer en liste.
Denne liste konverteres derefter til kortet ved hjælp af Collectors.MapOf-metoden, der tager elementerne en efter en. Det tager også sub_Id som nøglen til kortet. Endelig genereres det kort, der har under_ID som nøgle og undernavn som værdi.
Konverter kort til streng i Java
En kortsamling kan konverteres til en streng ved hjælp af to tilgange:
Brug af StringBuilder
Her opretter vi et StringBuilder-objekt og kopierer derefter nøgleværdiparene på kortet til StringBuilder-objektet. Derefter konverterer vi StringBuilder-objektet til en streng.
Nedenstående program viser Java-koden til at konvertere kortet 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()); } }Produktion:
Det givne kort: {20 = Tyve, 40 = Fyrre, 10 = Ti, 30 = Tredive}
Strengrepræsentationen af kort:
{20 = Tyve, 40 = Fyrre, 10 = Ti, 30 = Tredive}
Brug af Java 8 Streams
I denne metode opretter vi en stream ud af kortnøglerne og konverterer den derefter til strengen.
Programmet nedenfor viser konvertering af kortet til en streng ved hjælp af streams.
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); } }Produktion:
Det givne kort: {20 = Tyve, 40 = Fyrre, 10 = Ti, 30 = Tredive}
Strengrepræsentationen af kort:
{20 = Tyve, 40 = Fyrre, 10 = Ti, 30 = Tredive}
Konverter kort til liste i Java
Et kort består af nøgler og værdier, mens en liste er en sekvens af individuelle elementer. Når vi konverterer kortet til en liste, konverterer vi normalt nøgler til en liste over nøgler og værdier til en liste over værdier.
Følgende Java-program viser denne konvertering.
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); } }Produktion:
Liste over nøgler fra det givne kort:
(50, 20, 40, 10, 30)
Liste over værdier fra det givne kort:
(magenta, grøn, cyan, rød, blå)
Dictionary Vs. Kort i Java
Lad os diskutere nogle af de største forskelle mellem en ordbog og et kort i Java.
| Ordbog | Kort |
|---|---|
| Ordbog er en abstrakt klasse. | Kortet er en grænseflade. |
| Klasser og metoder, der bruges af ordbogen, rammer forud for samlinger. | Klasser og metoder, der bruges af kortklasser, er en del af indsamlingsrammen. |
| Hvis en klasse udvider ordbogen, kan den ikke udvide nogen anden klasse, da Java kun understøtter en enkelt arv | Kortet er en grænseflade, så en klasse kan arve fra kortet og andre grænseflader |
| Gammel implementering. Næsten forældet i nyere versioner af Java. | Kortgrænsefladen har erstattet implementeringen af ordbogen. |
Ofte stillede spørgsmål
Q # 1) Hvorfor bruger vi en kortgrænseflade i Java?
Svar: Kortet er en grænseflade i Java, der implementeres af klasser, der lagrer data som nøgleværdipar. Kortgrænsefladen giver operationer / metoder, der kan udføres på nøgleværdipar som indsættelse, opdatering, sletning osv.
Q # 2)Hvad betyder MAP i Java?
Svar: Et kort i Java repræsenterer en kortlægning af en nøgle med en bestemt værdi. Et Java-kort gemmer disse nøgleværdipar på et kort. Vi kan slå op og hente den værdi, der er knyttet til en nøgle, bare ved at bruge nøglen på kortet.
Et kort implementeres i Java ved hjælp af en grænseflade, der ikke er en del af samlingsgrænsefladen. Men kortet er en samling.
Q # 3)Hvad er MAP get?
Svar: Get () er en metode, der leveres af et kortgrænseflade i Java, der bruges til at hente den værdi, der er knyttet til en bestemt nøgle, der er angivet som et argument for get () -metoden. Hvis værdien ikke er til stede, returneres en null.
Q # 4)Er kortet en samling?
Svar: Selvom kortet generelt ses som en samling, implementerer det ikke en samlingsgrænseflade. Nogle af implementeringerne af kort, som f.eks. Treemap, understøtter ikke nulværdier eller nøgler.
Q # 5)Hvad er forskellen mellem sæt og kort?
Svar: Sæt er kun en samling nøgler, mens kortet er en samling af nøgleværdipar. Mens sættet ikke tillader nulværdier, tillader nogle af kortimplementeringerne nulværdier.
Sæt tillader ikke duplikatnøgler. Kortet tillader muligvis duplikatværdier, men nøgler skal være unikke. Sæt bruges normalt, når vi vil gemme en samling af unikke elementer. Kortet kan bruges, når vi har brug for at gemme data i form af nøgleværdipar.
Konklusion
I denne vejledning har vi diskuteret det grundlæggende i kortgrænsefladen. Vi har også set de forskellige metoder og alle andre detaljer relateret til kortgrænsefladen i Java. Vi fik at vide, at der er forskellige implementeringer af kortgrænseflader, herunder treemap, hashmap osv.
I vores kommende tutorials vil vi diskutere denne kortimplementering mere detaljeret.
=> Besøg her for at lære Java fra bunden.
Anbefalet læsning
- Hvad er et HashMap i Java?
- TreeMap I Java - Vejledning med Java TreeMap-eksempler
- LinkedHashMap I Java - LinkedHashMap Eksempel og implementering
- Indstil interface i Java: Java Set-tutorial med eksempler
- JAVA-vejledning til begyndere: 100+ praktiske Java-videovejledninger
- Java Stack Tutorial: Stack Class Implementation With Eksempler
- Java Reflection Tutorial med eksempler
- Jagged Array In Java - Vejledning med eksempler