java map interface tutorial with implementation examples
Den här omfattande Java-karthandboken täcker hur man skapar, initierar och sparar genom kartor. Du lär dig också om kartmetoder och implementeringsexempel:
Du kommer att lära känna grunderna i kartgränssnittet, metoder som stöds av kartgränssnittet och andra specifika termer relaterade till kartgränssnittet.
Kartsamling i Java är en samling som kartlägger en nyckel till ett värde. Det är en samling som består av nycklar och värden. Varje post på kartan består av en nyckel med motsvarande värde. Nycklarna är unika på kartor. Kartor kan vanligtvis användas när vi behöver ändra en samling baserat på ett nyckelvärde.
=> Kontrollera ALLA Java-handledning här.
Vad du kommer att lära dig:
- Kartor i Java
- Kartmetoder
- Java Map Implementation
- Slutsats
Kartor i Java
Kartan i Java är en del av gränssnittet java.util.map. Kartgränssnittet är inte en del av samlingsgränssnittet och det är anledningen till att kartor skiljer sig från de andra samlingarna.
Den allmänna hierarkin för kartgränssnittet visas nedan.
Som visas ovan finns det två gränssnitt för att implementera karta, dvs. kartgränssnitt och sortedMap-gränssnitt. Det finns tre klasser, nämligen HashMap, TreeMap och LinkedHashMap.
Dessa karttyper beskrivs nedan:
| Klass | Beskrivning | |
|---|---|---|
| ta bort | V ta bort (Objektnyckel) | Radera en kartpost för den angivna nyckeln |
| LinkedHashMap | Utökas från HashMap-klassen. Denna karta behåller införingsordningen | |
| HashMap | Implementera ett kartgränssnitt. Ingen order upprätthålls av HashMap. | |
| TreeMap | Implementerar både karta och sortedMap-gränssnitt. TreeMap upprätthåller en stigande ordning. |
Poäng att komma ihåg om kartor.
- På kartor kan varje tangent mappa till högst ett värde. Det kan inte heller finnas dubbla nycklar på kartorna.
- Kartimplementeringar som HashMap och LinkedHashMap tillåter nullnyckel och nullvärden. TreeMap tillåter dock inte det.
- En karta kan inte passeras som den är. Därför måste det konverteras för att korsas för att ställa in med hjälp av knappsatsen () eller entrySet () -metoden.
Skapa en karta i Java
För att skapa en karta i Java måste vi först inkludera gränssnittet i vårt program. Vi kan använda en av följande påståenden i programmet för att importera kartfunktionaliteten.
import java.util.*; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.TreeMap; Vi måste starta en konkret implementering av kartan eftersom den är ett gränssnitt.
Följande uttalanden skapar en karta i Java.
Map hash_map = new HashMap(); Map tree_map = new TreeMap(); Ovanstående uttalanden skapar kartor med standardspecifikationer.
Vi kan också skapa generiska kartor som specificerar typerna för både nyckel och värde.
Map myMap = new HashMap(); Ovanstående definition kommer att ha nycklar av typsträng och objekt som värden.
Initiera en karta i Java
Det kan initieras med följande metoder:
# 1) Använda samlingar
Java Collections-klassen har fabriksmetoder som kan användas för att initiera samlingar inklusive kartor.
Några metoder som används för att initialisera kartan är som följer:
(1) Collections.EmptyMap ()
Collections.EmptyMap () returnerar en seriell och oföränderlig karta som är tom. Till exempel, följande kodrad,
Map myMap = Collections.EMPTY_MAP; Detta skapar en tom karta. Ovanstående metod kan kasta 'okontrollerad tilldelningsvarning' och därmed kan vi också använda den typsäkra formen enligt följande.
Map myMap = Collections.emptyMap (); (2) Collections.unModifiableMap ()
Metoden unModifiableMap () tar en annan karta som ett argument och skapar en omodifierbar vy av den ursprungliga kartan.
Map myMap = Collections.EMPTY_MAP; Map map_unmodifiable = Collections.unmodifiableMap (myMap); (3) Collections.singletonMap ()
Samlingskursen ger också en fabriksmetod 'singletonMap ()' som skapar en oföränderlig singleton-karta med endast en post.
Map singleton_map = Collections.singletonMap('CHN', 'Beijing'); # 2) Använda Java 8
Vi kan få en dataflöde från Java 8 stream API-metoder och konstruera kartor med hjälp av Collectors.
Några av metoderna för att konstruera kartor är:
(1) Collectors.toMap ()
Vi samlar en ström och använder sedan metoden Collectors.toMap () för att skapa en karta.
Map map = Stream.of(new String()(){{'USA', 'Washington'}, {'United Kingdom', 'London'} }).collect(Collectors.toMap(p -> p(0), p -> p(1))); Ovanstående uttalande skapar en karta från Java 8-strömmen.
(2) Collectors.collectingAndThen ()
I detta anpassar vi metoden toMap () som gör att samlaren kan producera en oföränderlig karta med 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) Använda put-metoden i Map Interface
Metoden put () i kartgränssnittet kan användas för att tilldela kartvärden initialvärden.
# 4) Använda dubbelstaginitiering
Tekniken 'initialisering med dubbla stag' skapar en inre klass. Den här klassen är anonym och har en instansinitierare. Detta är inte en föredragen teknik och bör undvikas eftersom det kan leda till minnesläckage eller serialiseringsproblem.
Nedanstående program visar de olika metoderna för att initiera en karta som diskuterats ovan.
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:
omodifierbara kartvärden: {}
singleton_map Kartvärden: {10 = TEN}
map_cities-värden: {CH = Chennai, DL = New Delhi, MH = Mumbai}
capitals_Map-värden: {MAH = Mumbai, GOA = Panaji, KAR = Bangaluru}
Kartvärden: {USA = Washington, GER = Berlin, UK = London, IND = Delhi}
Iterera över karta i Java och skriva ut kartan
Vi kan korsa kartan på samma sätt som vi korsar de andra samlingarna. Förutom att korsa kartposter kan vi också korsa endast knapparna eller bara värdena på kartan. Observera att för att korsa en karta måste den konverteras för att ställas in först.
Följande metoder används för att korsa kartposterna.
Använda Entry Iterator
I den här metoden får vi en post-iterator från en postuppsättning. Sedan använder vi getKey- och getValue-metoderna och hämtar nyckel-värdeparet för varje kartpost.
Följande program visar användningen av 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:
Kartposterna är:
NYCKELVÄRDE
CH Chennai
DL New Delhi
MH Mumbai
I ovanstående program får vi en post-iterator från kartan med hjälp av metoden entrySet. Sedan korsar vi kartan med hasNext () -metoden för inmatning iterator och skriver ut nyckel-värdeparet.
Använda en post för varje slinga
Här korsar vi entrySet med hjälp av för varje slinga och implementeringen visas nedan.
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:
Kartposterna är:
NYCKELVÄRDE
CH Chennai
DL New Delhi
MH Mumbai
Kartmetoder
Kartgränssnittet i Java stöder olika operationer som liknar de som stöds av andra samlingar. I det här avsnittet kommer vi att diskutera de olika metoderna som tillhandahålls av Map API i Java. Eftersom omfattningen av denna handledning är begränsad till att införa ett kartgränssnitt i allmänhet kommer vi inte att beskriva dessa metoder.
Vi kommer att diskutera dessa metoder i detalj medan vi diskuterar kartgränssnittsklasser.
I följande tabell listas alla metoder som tillhandahålls av map API.
| Metodens namn | Metodprototyp | Beskrivning |
|---|---|---|
| skaffa sig | V get (Objektnyckel) | Returnerar objektet eller värdet för den angivna nyckeln |
| sätta | V put (Objektnyckel, Objektvärde) | Infoga nyckel-värde-post på kartan |
| sätt alla | void putAll (Map map) | Infoga givna kartposter i kartan. Med andra ord kopierar eller klonerar en karta. |
| keySet | Set keySet () | Returnerar inställd vy över kartan. |
| entrySet | Uppsättning | Returer ställer in vyn för en given karta |
| värden | Samlingsvärden () | Returnerar samlingsvy för värdena på kartan. |
| storlek | int storlek () | Returnerar antalet poster på kartan |
| klar | ogiltig rensa () | Rensar kartan |
| är tom | boolean isEmpty () | Kontrollerar om kartan är tom och returnerar true om ja. |
| containsValue | boolean containsValue (Objektvärde) | Returnerar true om kartan innehåller värdet lika med det angivna värdet |
| innehållerKey | boolean containsKey (Objektnyckel) | Returnerar sant om en viss nyckel finns på kartan |
| är lika med | booleska lika (Objekt o) | Jämför specificerat objekt o med kartan |
| hash-kod | int hashCode () | returnerar hashkoden för kartan |
| för varje | ogiltig för varje (BiConsumer-åtgärd) | Utför given åtgärd för varje post på kartan |
| getOrDefault | V getOrDefault (Objektnyckel, V defaultValue) | Returnerar angivet värde för den angivna nyckeln eller dess standardvärde om nyckeln inte finns |
| ta bort | boolean remove (Objektnyckel, Objektvärde) | Tar bort angivna nycklar och värden |
| byta ut | V ersätt (K-tangent, V-värde) | Ersätter den angivna nyckeln med det angivna värdet |
| byta ut | boolean ersättare (K-tangent, V oldValue, V newValue) | Ersätter det gamla värdet med ett nytt värde för en viss nyckel |
| Ersätt alla | void replaceAll (BiFunction-funktion) | Påkallar en given funktion för att ersätta alla kartposter |
| putIfAbsent | V putIfAbsent (K-tangent, V-värde) | Infogar den angivna nyckeln, värdet bara om den inte redan finns |
| beräkna | V-beräkning (K-tangent, BiFunction remappingFunction) | Beräknar mappning för angiven nyckel och värde med tanke på mappningsfunktionen. |
| beräknaIfAbsent | V computeIfAbsent (K-tangent, Function mappingFunction) | Beräkna värdet för den angivna nyckeln med hjälp av mappningsfunktionen om den inte redan finns. |
| computeIfPresent | V computeIfPresent (K-tangent, BiFunction remappingFunction) | Beräknar ny mappning för den givna tangenten med den givna remapping-funktionen om nyckelvärdet redan finns |
| gå | V-sammanslagning (K-tangent, V-värde, BiFunction-remappingFunction) | Associerar en viss nyckel med värdet om den inte redan är associerad eller är associerad med nollvärdet. |
Alla ovanstående metoder stöds av kartgränssnittet. Observera att metoderna som verkar skuggade är de nya metoderna som inkluderades i Java 8.
Java Map Implementation
Följande program implementerar ett kartexempel i Java. Här använder vi de flesta av de metoder som diskuterats ovan.
Exemplet visar olika få operationer, put och set-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:
Nyckel = CHN, värde: Kina
Nyckel = XX, värde: null
null keyExists: true, null valueExists = true
postuppsättning för country_map: (null = Z, XX = null, CHN = China, SL = Srilanka, IND = India, KOR = Korea)
Storlek på landskarta: 6
data_map mappad till country_map: {null = Z, XX = null, CHN = China, SL = Srilanka, IND = India, KOR = Kore
till}
nullnyckelvärde för data_map: Z
data_map efter att ha tagit bort en nyckel = {XX = null, CHN = Kina, SL = Srilanka, IND = Indien, KOR = Korea}
datakartnycklar: (null, XX, CHN, SL, IND, KOR)
datakartvärden: (Z, null, Kina, Srilanka, Indien, Korea)
datakarta efter tydlig operation, är tom: sant
Sortera en karta i Java
Eftersom en karta består av nyckel-värdepar kan vi sortera kartan på nycklar eller värden.
I det här avsnittet sorterar vi en karta på både nycklar och värden.
Sortera efter nyckel
För att sortera en karta på nycklar kan vi använda en trädkarta. Trekartan sorterar nycklarna automatiskt. Nedanstående Java-program omvandlar en karta till en treemap och visar de sorterade tangenterna.
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:
Original osorterad karta:
Ett Amerika
C Kina
D Danmark
X Hongkong
Jag Indien
Karta sorterad efter nyckel:
Ett Amerika
C Kina
D Danmark
Jag Indien
X Hongkong
Ovanstående program skapar en karta som består av en enda alfabetkod som nycklar och landsnamn som värden. Först visar vi den ursprungliga kartan som inte är sorterad. Sedan konverterar vi kartan till en trädkarta som automatiskt sorterar nycklarna. Slutligen visar vi den sorterade trädkartan på tangenterna.
Sortera efter värde
För att sortera en karta baserat på värden konverterar vi först kartan till en lista. Sedan sorterar vi listan med hjälp av Collections.sort () -metoden som använder en komparator för att jämföra värdena och ordna dem i en specifik ordning.
När listan har sorterats kopieras de länkade listposterna till kartan igen vilket ger oss den sorterade kartan.
Följande Java-program visar sorteringen av en karta baserat på värde. Programmet använder LinkedHashMap som vidarebefordras till sorteringsfunktionen. I sorteringsfunktionen konverteras den till en länkad lista och sorteras. Efter sortering konverteras den tillbaka till LinkedHashMap.
nätverksingenjör intervju frågor 250 + frågor och svar förklarade pdf
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:
Ursprunglig osorterad karta:
{NEP = Katmandu, IND = New Delhi, USA = Washington, Storbritannien = London, AUS = Canberra
Karta sorterad efter värde:
Nyckelvärde
FRÅN Canberra
NEP Katmandu
Storbritannien London
IND New Delhi
USA Washington
Samtidig karta i Java
En concurrentMap är ett gränssnitt som ärver från java.util.map-gränssnittet. ConcurrentMap-gränssnittet introducerades först i JDK 1.5 och ger en karta som hanterar samtidig åtkomst.
ConcurrentMap-gränssnittet är en del av paketet java.util.concurrent.
Följande Java-program visar 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:
Inledande samtidiga karta: {100 = röd, 101 = grön, 102 = blå}
Efter att ha lagt till frånvarande tangent 103: {100 = Röd, 101 = Grön, 102 = Blå, 103 = Lila}
Samtidig karta efter borttagning av 101: {100 = Röd, 102 = Blå, 103 = Lila}
Lägg till frånvarande tangent 101: {100 = Röd, 101 = Brun, 102 = Blå, 103 = Lila}
Ersätt värde vid tangent 101: {100 = Röd, 101 = Grön, 102 = Blå, 103 = Lila}
Synkroniserad karta i Java
En synkroniserad karta är en karta som är trådsäker och backas upp av en given karta. I Java erhålls den synkroniserade kartan med hjälp av metoden synchronizedMap () i klassen java.util.Collections. Denna metod returnerar en synkroniserad karta för en given karta.
Den här returnerade synkroniserade kartan används för att komma åt backningskartan för att uppnå seriell åtkomst.
Den allmänna deklarationen av synchronizedMap () -metoden är:
public static Map synchronizedMap(Map m) där m => är den backade kartan.
Som redan nämnts returnerar denna metod den synkroniserade vyn av karta m.
Nedanstående Java-program är ett exempel på en synkroniserad karta.
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:
Original (baksida) Karta: {1 = 10, 2 = 20, 3 = 30, 4 = 40, 5 = 50}
Synkroniserad karta efter borttagning (3, 30): {1 = 10, 2 = 20, 4 = 40, 5 = 50}
Statisk karta i Java
En statisk karta i Java är en karta som förklaras statisk precis som en statisk variabel. Genom att deklarera en karta statisk blir det en tillgänglig klassvariabel utan att använda objektet.
Det finns två sätt att skapa och initiera en statisk karta i Java.
# 1) Använda en statisk variabel
Här skapar vi en statisk kartvariabel och instanserar den tillsammans med deklarationen.
Detta tillvägagångssätt demonstreras i följande 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 karta med variabel statisk karta:
{1 = Indien, 2 = Portugal, 3 = Tyskland}
# 2) Använda statisk blockering
I detta skapar vi en statisk kartvariabel. Sedan skapar vi ett statiskt block och inuti detta statiska block initialiserar vi kartvariabeln.
Programmet nedan visar detta.
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 karta med statiskt block:
{1 = Röd, 2 = Grön, 3 = Blå}
Omvandling av listan till karta
I detta avsnitt kommer vi att diskutera metoderna för att konvertera listan till en karta.
De två metoderna inkluderar:
Traditionell metod
I den traditionella metoden kopieras varje listelement till en karta med en för varje slinga.
Denna implementering visas nedan:
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 angivna listan: (Röd, grön, blå, brun, vit)
Karta genererad från listan: {1 = röd, 2 = grön, 3 = blå, 4 = brun, 5 = vit}
Lista till karta i Java 8
Vi kan också använda Java 8-metoden Collectors.mapOf () som konverterar den angivna listan till en karta.
Nedanstående program visar detta.
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:
Karta erhållen från listan: {1 = kulruta, 2 = matematik, 3 = fysik, kemi}
I det här programmet har vi ett klassämne som fungerar som en listklass. Klassen Ämne har två fält, dvs sub_id och sub_name. Vi har metoder för att läsa fältvärdena från klassen. I huvudfunktionen skapar vi objekt av denna klass och konstruerar en lista.
Denna lista konverteras sedan till kartan med metoden Collectors.MapOf som tar elementen en efter en. Det tar också sub_Id som nyckel till kartan. Slutligen genereras kartan som har sub_Id som nyckel och Sub_Name som värde.
Konvertera karta till sträng i Java
En kartsamling kan konverteras till en sträng med två metoder:
Använda StringBuilder
Här skapar vi ett StringBuilder-objekt och kopierar sedan nyckel-värde-paren på kartan till StringBuilder-objektet. Sedan konverterar vi StringBuilder-objektet till en sträng.
Programmet nedan visar Java-koden för att konvertera kartan till strängen.
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:
Den angivna kartan: {20 = tjugo, 40 = fyrtio, 10 = tio, 30 = trettio}
Strängrepresentationen för karta:
{20 = tjugo, 40 = fyrtio, 10 = tio, 30 = trettio}
Använda Java 8 Streams
I den här metoden skapar vi en ström ur kartnycklarna och konverterar den sedan till strängen.
Programmet nedan visar konvertering av kartan till en sträng med hjälp av strömmar.
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:
Den angivna kartan: {20 = tjugo, 40 = fyrtio, 10 = tio, 30 = trettio}
Strängrepresentationen för karta:
{20 = tjugo, 40 = fyrtio, 10 = tio, 30 = trettio}
Konvertera karta till lista i Java
En karta består av nycklar och värden medan en lista är en sekvens av enskilda element. När vi konverterar kartan till en lista konverterar vi vanligtvis nycklar till en lista med nycklar och värden till en lista över värden.
Följande Java-program visar denna 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:
c ++ binär sökträdsimplementering
Lista över nycklar från den angivna kartan:
(50, 20, 40, 10, 30)
Lista över värden från den angivna kartan:
(magenta, grön, cyan, röd, blå)
Dictionary Vs. Karta i Java
Låt oss diskutera några av de största skillnaderna mellan en ordbok och en karta i Java.
| Ordbok | Karta |
|---|---|
| Ordbok är en abstrakt klass. | Kartan är ett gränssnitt. |
| Klasser och metoder som används i ordboken klassens ramar för tidigare samlingar. | Klasser och metoder som används av kartklasser är en del av samlingsramen. |
| Om en klass utökar ordboken kan den inte utöka någon annan klass eftersom Java endast stöder enstaka arv | Kartan är ett gränssnitt, så en klass kan ärva från kartan och andra gränssnitt |
| Gammal implementering. Nästan föråldrad i nyare versioner av Java. | Kartgränssnittet har ersatt implementeringen av ordlistan. |
Vanliga frågor
F # 1) Varför använder vi ett kartgränssnitt i Java?
Svar: Kartan är ett gränssnitt i Java som implementeras av klasser som lagrar data som nyckel-värdepar. Kartgränssnittet ger operationer / metoder som kan utföras på nyckel-värdepar som insättning, uppdatering, radering, etc.
F # 2)Vad betyder MAP i Java?
Svar: En karta i Java representerar en kartläggning av en nyckel med ett specifikt värde. En Java-karta lagrar dessa nyckel-värdepar på en karta. Vi kan slå upp och hämta värdet som är associerat med en nyckel bara genom att använda tangenten på kartan.
En karta implementeras i Java med ett gränssnitt som inte ingår i samlingsgränssnittet. Men kartan är en samling.
F # 3)Vad är MAP get?
Svar: Get () är en metod som tillhandahålls av ett kartgränssnitt i Java som används för att hämta värdet som är associerat med en viss nyckel som tillhandahålls som ett argument för get () -metoden. Om värdet inte är närvarande returneras en null.
F # 4)Är kartan en samling?
Svar: Även om kartan ses som en samling i allmänhet implementerar den inte ett samlingsgränssnitt. Några av implementeringarna av kartan, som treemap, stöder inte nollvärden eller nycklar.
F # 5)Vad är skillnaden mellan uppsättning och karta?
Svar: Set är endast en samling nycklar medan kartan är en samling av nyckel-värdepar. Även om uppsättningen inte tillåter nollvärden, tillåter vissa av kartimplementeringarna nollvärden.
Uppsättningen tillåter inte dubbla nycklar. Kartan kan tillåta dubbla värden men nycklarna måste vara unika. Set används vanligtvis när vi vill lagra en samling unika element. Kartan kan användas när vi behöver lagra data i form av nyckel-värdepar.
Slutsats
I denna handledning har vi diskuterat grunderna i kartgränssnittet. Vi har också sett de olika metoderna och alla andra detaljer relaterade till kartgränssnittet i Java. Vi fick veta att det finns olika implementeringar av kartgränssnitt inklusive treemap, hashmap, etc.
I våra kommande handledning kommer vi att diskutera denna kartimplementering mer detaljerat.
=> Besök här för att lära dig Java från grunden.
Rekommenderad läsning
- Vad är en HashMap i Java?
- TreeMap In Java - Handledning med Java TreeMap-exempel
- LinkedHashMap I Java - LinkedHashMap Exempel och implementering
- Ställ in gränssnitt i Java: Java Set Tutorial med exempel
- JAVA-handledning för nybörjare: 100+ praktiska Java-videohandledning
- Java Stack-handledning: Stackklassimplementering med exempel
- Java Reflection Tutorial med exempel
- Jagged Array In Java - Handledning med exempel