Java Map-gränssnittet är en del av Java Collection-ramverket, men det är inte en undertyp av Collection-gränssnittet. Så det beter sig på ett annat sätt jämfört med till exempel listor eller andra samlingsobjekt. Varje element i Map<Key, Value> representerar ett nyckel-värdepar. Både Nyckel och värde är några objekt. Alla nycklar i en viss karta är unika, medan värden inte är det, så de kan dupliceras. Du kanske tänker på Map in Java som en sorts ordbok eller onlinebutikskatalog, där du kan hitta alla föremål med hjälp av dess unika index. Nyckeln är en unik identifierare för värdet i en karta. Till exempel i Map<String, Item> String är ett ID för en artikel från onlinebutiken. Enligt dokumentation har Map följande undergränssnitt:
Bindningar ;
ConcurrentMap<K,V> ;
ConcurrentNavigableMap<K,V> ;
LogicalMessageContext ;
MessageContext ;
NavigableMap<K,V> ;
SOAPMessageContext ;
Sorterad karta<K,V> .
Och implementerar klasser:
Abstrakt karta
Attribut
AuthProvider
ConcurrentHashMap
ConcurrentSkipListMap
EnumMap
HashMap
Hastbar
IdentityHashMap
LinkedHashMap
PrinterStateReasons
Egenskaper
Leverantör
RenderingTips
SimpleBindings
TabularDataSupport
Trädkarta
UIDfaults
WeakHashMap
Java AbstractMap är en abstrakt klass som implementerar det mesta av kartgränssnittet.
Java HashMap är en datastruktur för att lagra nyckel-värdepar med hjälp av en hashtabell.
Java TreeMap är en datastruktur för att använda ett träd, dvs display med sorterade nycklar.
WeakHashMap för att använda en hashtabell med svaga nycklar, visas med värden som kan raderas av sophämtaren om de inte längre används.
LinkedHashMap är en karta med ordningen för att lägga till element, tillåter iteration i insättningsordningen.
EnumMap utökar klassen AbstractMap för användning med enum-nycklar.
IdentityHashMap använder referensekvivalenskontroll vid jämförelse av dokument, mappning med nycklar jämfört med
==- operationen istället för metoden
equals()
Här är vi intresserade av de mest populära implementeringarna av Map Interface: HashMap, TreeMap och LinkedHashMap. Förresten beror ordningen på kartelement på specifika implementeringar. Säg, TreeMap och LinkedHashMap har förutsägbar ordning på elementen, medan HashMap inte har det.
Kartmetoder
Huvudfunktionerna för en karta är att infoga, ta bort och söka efter element.
public Object put(Objektnyckel, Objektvärde) infogar ett element i kartan.
public void putAll(Map map) infogar den angivna kartan inuti kartan.
public Object remove(Object key) tar bort en post enligt den angivna nyckeln.
public Object get(Objektnyckel) returnerar värdet för den angivna nyckeln.
public boolean containsKey(Objektnyckel) söker efter den angivna nyckeln från denna karta
public Set keySet() returnerar en Set-vy som innehåller alla nycklar
public Set entrySet() returnerar en Set-vy med alla nycklar och värden.
Vad är HashMap
Vad är HashMap? Det är den mest populära implementeringen av Map<Key,Value>-gränssnittet. Denna datastruktur är baserad på hashprincipen.
Huvudprincipen för HashMap-arbete: hashing
För att förstå vad en hashmap är och hur den fungerar, låt oss först prata om hash- och hashfunktioner. En hashfunktion är bara en funktion i matematisk mening. Så det finns ett indatavärde (ett objekt, en bit data) och funktionen konverterar det med hjälp av en korrekt regel till utdatavärde - en hash. Ganska ofta är hash ett hexadecimalt tal med rätt längd. Reglerna för konverteringsprocesser kan vara annorlunda, men de är föremål för följande principer:
En viss ingång (objekt) har en speciell hashkod.
Om två objekt är lika, är deras hash-koder lika. Det omvända är inte sant.
Om hashkoderna är olika är objekten definitivt inte lika.
Ibland kan olika objekt ha samma hashkod. Det är en mycket osannolik händelse, kallad "kollision" och en hashfunktion av god kvalitet bör minimera sannolikheten för kollisioner.
I Java har varje objekt en hash-kod. Den beräknas med hashCode-metoden för klassen Object, föräldraklass för alla Java-objekt. Vanligtvis åsidosätter utvecklare denna metod för sina egna klasser och lika med metoder associerade med den.
HashMap: hur det fungerar
Så Klass HashMap<K,V> eftersom varje kartimplementering består av nycklar och värden. Den lagrar nycklar med hjälp av hash-principer. Inuti HashMap lagras nyckel-värdepar i "buckets", dessa hinkar skapar tillsammans en "tabell", en intern uppsättning länkade listor och dess initiala storlek är 16. HashMap i Java använder nyckelns hashkod för att bestämma en hink där nyckel/värdeparet ska mappas: Den knepiga egenskapen med HashMap är att varje cell (bucket) i tabellen [] innehåller inte bara ett par utan flera. De lagras inte som ett explicit objekt (som LinkedList), utan som en implicit kedja. Kedjan skapas på grund av att varje par lagrar en länk till nästa par. Det vill säga alla HashMap-par är utspridda över 16 kedjor. När du lägger ett nytt par i bordet, beaktas nyckelns hash. Denna hash är inte en hashkodfunktion inbyggd i nyckelobjektet. Det anses ligga i intervallet 0-15. Paret läggs till i kedjan av par som lagras i hinken med hashindex. Detta tillvägagångssätt ger oss sökacceleration. När du söker efter ett par med nyckel behöver du inte gå igenom hela tabellen. Nyckelns hash beaktas och endast kedjan som är lagrad i cellen med hashindex kontrolleras. Om det finns för många par i HashMap blir kedjorna för långa. Sedan ökar storleken på arrayen, hashen för alla lagrade objekt räknas om och de sprids utmed nya kedjor.
HashMap-deklaration
Om du går till klassen HashMap-koden hittar du nästa deklaration:
public class HashMap extends AbstractMap implements Map, Cloneable, Serializable
Där K är den typ av nycklar som upprätthålls av denna karta och V - typen av mappade värden. Det här är ett exempel på HashMap-deklaration med heltalsnyckel och strängvärde i din kod:
HashMap<Integer, String> myHashMap = new HashMap<Integer, String>();
HashMap metoder
Här är listan över HashMap-metoder.
Objekt get(Objektnyckel) returnerar värdet för den angivna nyckeln;
Objekt put(Key k, Value v) infogar nyckelvärdesmappning i kartan;
Object remove(Objektnyckel) tar bort mappningen för den angivna nyckeln från denna karta om den finns;
void clear() tar bort alla nyckel-värdepar från HashMap;
Object clone() returnerar en ytlig kopia av denna HashMap-instans utan att klona nycklarna och värdena;
boolean containsKey(Objektnyckel) returnerar true om den angivna nyckeln hittas i kartan, false om inte;
boolean containsValue(Object Value) returnerar sant om den angivna nyckeln hittas i kartan, false om inte;
boolean isEmpty() returnerar true om kartan är tom, false om den inte är det;
Set keySet() returnerar uppsättningen av nycklar som hämtats från kartan;
int size() returnerar mängden nyckel-värde-mappning;
Collection values() returnerar en samling av kartans värden;
Object remove(Object key) tar bort nyckel-värdeparet för den angivna nyckeln;
void putAll(Map m) kopierar alla delar av kartan till den andra kartan.
Java HashMap Exempel
Låt oss skapa ett program med Java HashMap Exempel för att visa hur det fungerar:
import java.util.HashMap;
import java.util.Map;
import java.util.Iterator;
import java.util.Set;
public class HashMap {
public static void main(String[] args) {
{
// HashMap declaration
HashMap<Integer, String> myHashMap = new HashMap<Integer, String>();
//Adding elements into HashMap
myHashMap.put(7, "Johnny");
myHashMap.put(8, "Ivy");
myHashMap.put(1, "Rick");
myHashMap.put(4, "Stan");
myHashMap.put(3, "Kyle");
//print out the map content using Iterator
Set set = myHashMap.entrySet();
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
Map.Entry mapEntry = (Map.Entry) iterator.next();
System.out.print("key: " + mapEntry.getKey() + " value: ");
System.out.println(mapEntry.getValue());
}
System.out.println("get an element from myHashMap via key and print the value out:");
System.out.println(myHashMap.get(8));
//print out hashMap on standard way:
System.out.println(myHashMap);
// Get values based on key
String var = myHashMap.get(2);
//here we'll get null, we don't have such a key
System.out.println("Value with key 2: " + var);
var = myHashMap.get(7);
System.out.println("Value with key 7: " + var);
// Remove values based on key
myHashMap.remove(4);
System.out.println("myHashMap after removing element:");
System.out.println(myHashMap);
myHashMap.clear();
System.out.println("myHashMap after total clearing:");
System.out.println(myHashMap);
}
}
}
Resultatet av att köra programmet:
key: 1 value: Rick
key: 3 value: Kyle
key: 4 value: Stan
key: 7 value: Johnny
key: 8 value: Ivy
get an element from myHashMap via key and print the value out:
Ivy
{1=Rick, 3=Kyle, 4=Stan, 7=Johnny, 8=Ivy}
Value with key 2: null
Value with key 7: Johnny
myHashMap after removing element:
{1=Rick, 3=Kyle, 7=Johnny, 8=Ivy}
myHashMap after total clearing:
{}
Trädkarta
TreeMap i Java implementerar också Map<Key,Value>-gränssnittet, men det är baserat på röd-svart träddatastruktur. Ett träd består av "noder" och linjer som förbinder noder - grenar. "Root"-noden är högst upp i trädet. Från roten kan det finnas grenar och noder. Det är en hierarkisk struktur, du kanske tänker på dessa noder som "barn" till roten. Barnnod kan ha sina egna barn - lägre noder. Noder utan barn kallas "ändnoder" eller "löv". Ett binärt träd är ett träd, där varje nod har noll, en , eller två underordnade. Det binära sökträdet är en struktur, där varje intern nod lagrar en nyckel, och ibland ett associerat värde, och har två distingerade underträd ("vänster" och "höger"). Ett självbalanserande binärt sökträd är ett nodbaserat binärt sökträd som automatiskt håller sin höjd (maximalt antal nivåer under roten) liten inför godtyckliga objektinsättningar och borttagningar. Ett röd-svart träd är ett balanserat binärt träd med egenskaperna:
Varje nod är antingen röd eller svart
Roten är alltid svart
Varje löv är en NIL (typ av tom, noll) nod och den är svart
Om en nod är röd är dess barn definitivt svarta.
Varje enkel väg från en nod till ett släktblad innehåller samma antal svarta noder.
En TreeMap funktioner
En TreeMap använder en träddatastruktur för att lagra nycklarna som noder och sorterar nycklarna med algoritmen Red-Black Tree. Så, TreeMap håller sina poster sorterade enligt den naturliga ordningen för dess nycklar. För siffror är naturlig stigande ordning, för strängar - alfabetisk ordning. Du kan använda en komparator om du behöver ändra logiken för beställning. Att sortera objekt på ett naturligt sätt är en stor fördel med TreeMap, liksom att hitta vissa objekt med hjälp av olika filter och villkor.
TreeMap metoder
Objekt get(Objektnyckel) returnerar värdet på motsvarande nyckel;
Objekt put(Objektnyckel, Objektvärde) infogar en mappning i en karta;
Object remove(Objektnyckel) tar bort mappningen för denna nyckel från om TreeMap innehåller den;
boolean containsKey(Objektnyckel) returnerar true om denna karta innehåller en mappning för den angivna nyckeln;
boolean containsValue(Objektvärde) returnerar sant om TreeMap mappar en eller flera nycklar till det angivna värdet;
Objekt firstKey() returnerar den första nyckeln för närvarande i den sorterade kartan;
Objekt lastKey() returnerar den sista nyckeln för närvarande i den sorterade kartan;
void putAll(Map map) kopierar alla mappningar från den angivna kartan till kartan;
Set entrySet() returnerar en setvy av mappningarna
int size() returnerar mängden nyckel-värde-mappningar
Collection values() returnerar en samlingsvy av värdena
Object clone() returnerar en ytlig kopia av TreeMap
void clear() tar bort alla mappningar från TreeMap
SortedMap headMap(Object key_value) returnerar en vy av den del av kartan som är mindre än parametern key_value
Set keySet() returnerar en Set-vy av nycklarna som finns i trädkartan
SortedMap subMap(K fromKey, K toKey) returnerar en vy av den del av denna karta vars nycklar sträcker sig från fromKey, inklusive, till toKey, exklusiv
Objekt firstKey() returnerar den första nyckeln från TreeMap.
TreeMap exempel
import java.util.TreeMap;
import java.util.Set;
import java.util.Iterator;
import java.util.Map;
public class TreeMapExample {
public static void main(String args[]) {
//TreeMap declaration
TreeMap<Integer, String> myTreeMap = new TreeMap<Integer, String>();
//put elements to TreeMap
myTreeMap.put(1, "Stuart");
myTreeMap.put(23, "Michael");
myTreeMap.put(7, "Johnny");
myTreeMap.put(5, "Ivy");
myTreeMap.put(2, "Alex");
//Display and print out myTreeMap using Iterator
Set set = myTreeMap.entrySet();
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
Map.Entry myEntry = (Map.Entry) iterator.next();
System.out.print("key: " + myEntry.getKey() + " value: ");
System.out.println(myEntry.getValue());
}
//TreeMap printed in classical way
System.out.println(myTreeMap);
//removing an element with the key =2
myTreeMap.remove(2);
//myTreeMap after removing:
System.out.println(myTreeMap);
}
}
Resultatet av att köra programmet:
key: 1 value: Stuart
key: 2 value: Alex
key: 5 value: Ivy
key: 7 value: Johnny
key: 23 value: Michael
{1=Stuart, 2=Alex, 5=Ivy, 7=Johnny, 23=Michael}
{1=Stuart, 5=Ivy, 7=Johnny, 23=Michael}
LinkedHashMap
LinkedHashMap är en datastruktur som kombinerar länkade listor och hashkartor. Faktum är att LinkedHashMap utökar HashMap-klassen och implementerar Map-gränssnittet, men vad handlar det om länkade listor? Deklarationen från LinkedHashMap:
Map <Integer, String> linkedHashMap = new LinkedHashMap <Integer, String>();
Denna nya linkedHashMap ärver egenskaper från HashMap (som tabell, loadFactor, threshold, size, entrySet), får också två speciella egenskaper:
header är huvudet på en dubbellänkad lista. Under initieringen indikerar den sig själv
accessOrder anger hur man får tillgång till element med iterator. Om sant, i den ordning som den senaste åtkomsten. Om falskt kommer åtkomsten att vara i den ordning som elementen infogades.
Denna länkade lista definierar iterationsordningen. Vanligtvis är det ordningen för nycklar som infogas i kartan.
LinkedHashMap-metoder
Objekt get(Objektnyckel) returnerar värdet som den angivna nyckeln är mappad till, eller null om denna karta inte innehåller någon mappning för nyckeln
void clear() tar bort alla mappningar från kartan.
boolean containsKey(Objektnyckel) returnerar sant om det angivna elementet mappas av en eller flera nycklar
boolean removeEldestEntry(Map.Entry eldest) returnerar sant om kartan tar bort sin äldsta post från kartan
Set<Map.Entry<K,V>> entrySet() returnerar en Set-vy av mappningarna som finns i denna karta
void forEach(BiConsumer<? super K,? super V> action) utför den givna åtgärden för varje post i denna karta tills alla poster har bearbetats eller åtgärden ger ett undantag.
Objekt getOrDefault(Objektnyckel, V defaultValue) returnerar värdet som den angivna nyckeln är mappad till. Om kartan inte innehåller en mappning för nyckeln returneras defaultValue.
Set<K> keySet() returnerar en Set-vy av nycklarna som finns i kartan
boolean removeEldestEntry(Map.Entry<K,V> eldest) returnerar sant om denna karta skulle ta bort sin äldsta post
void replaceAll(BiFunction<? super K,? super V,? utökar V>-funktionen) ersätter varje inmatningsvärde med resultatet av att anropa den givna funktionen på den posten tills alla poster har bearbetats eller funktionen ger ett undantag.
Collection<v>values() returnerar en samlingsvy av värdena som finns i kartan
Exempel på LinkedHashMap
import java.util.LinkedHashMap;
import java.util.Set;
import java.util.Iterator;
import java.util.Map;
public class HashLinkedListExample {
public static void main(String args[]) {
// LinkedHashMap Declaration
LinkedHashMap<Integer, String> myLinkedHashMap =
new LinkedHashMap<Integer, String>();
//Adding elements into LinkedHashMap
myLinkedHashMap.put(7, "Johnny");
myLinkedHashMap.put(12, "Rick");
myLinkedHashMap.put(1, "Kyle");
myLinkedHashMap.put(5, "Percy");
myLinkedHashMap.put(85, "Sebastian");
// Generate a Set of entries
Set set = myLinkedHashMap.entrySet();
// Display and print out the nodes of LinkedHashMap
Iterator iterator = set.iterator();
while(iterator.hasNext()) {
Map.Entry me = (Map.Entry)iterator.next();
System.out.print("key: "+ me.getKey() +
" value: "+me.getValue()+"\n");
}
//print out HashLinkedMap on standard way:
System.out.println(myLinkedHashMap);
myLinkedHashMap.put(21, "Ivy");
System.out.println(myLinkedHashMap);
myLinkedHashMap.remove(12);
System.out.println(myLinkedHashMap);
myLinkedHashMap.put(12, "Ronny");
System.out.println(myLinkedHashMap);
myLinkedHashMap.put(1, "Stan");
System.out.println(myLinkedHashMap);
}
}
Här skapar vi en ny LinkedHashMap, lägger till fem element och skriver sedan ut den med iterator och på ett klassiskt sätt. Som du kan se upprätthåller LinkedHashMap insättningsordningen. Efter det tar vi bort ett element från vår karta, lägger sedan till det nya och senare - ytterligare ett element med nyckeln, som redan finns på kartan. Det ersätter det gamla värdet som är mappat till denna nyckel. Resultatet av att köra programmet:
HashMap, TreeMap och LinkedHashMap är implementeringar av kartgränssnitt. HashMap och LinkedHashMap är datastrukturer som hashar nycklar. TreeMap använder den naturliga ordningen för sina nycklar för att organisera ett sökträd. Beställa:
HashMap upprätthåller ingen ordning.
TreeMap sorterar posterna i stigande ordning av nycklar.
LinkedHashMap upprätthåller insättningsordningen.
Null-nycklar:
HashMap och LinkedHashMap tillåter att ha en null-nyckel.
LinkedHashMap tillåter inte noll-nycklar om nycklarna använder naturlig ordning eller Comparator stöder inte jämförelse på noll-leys.
Låt oss ta ett exempel på Java-karta som inkluderar alla tre implementeringar som granskas i den här artikeln:
Som vi kan se är ordningen på element i HashMap inte självklar, i treeMap beror det på nycklar, i LinkedHashMap handlar det om insättningsordning. Om vi försöker lägga in null-nyckel i linkedHashMap får vi NullPointerException, men i linkedHashMap1, där nycklar är String, kan vi göra det. En hashkarta är den bästa kartimplementeringen för allmänna ändamål. Det ger maximal sökhastighet, snabb lagring och hämtning, men du bör komma ihåg om dess kaotiska ordning. En länkad hashkarta ärver HashMap-fördelar och får en beställning på nycklarna. Däremot innehåller den linkedList, vilket är relativt dyrt sett till minne. det är långsammare än HashMap i sökning och lite långsammare för att lägga till/ta bort på grund av att den länkade listan upprätthålls. En trädkarta lagrar nycklar sorterade i stigande ordning. Dock, För att förstärka det du lärde dig föreslår vi att du tittar på en videolektion från vår Java-kurs
GO TO FULL VERSION