A Java Map felület a Java Collection keretrendszer része, de nem altípusa a Gyűjtemény felületnek. Tehát másképpen viselkedik, mint például a listák vagy más gyűjteményobjektumok. A Map<Kulcs, Érték> minden eleme egy kulcs-érték párt képvisel. A kulcs és az érték is néhány objektum. Egy adott térképen minden kulcs egyedi, míg az értékek nem, így megkettőzhetők. Gondolhat a Java térképre, például egy szótárra vagy online bolti katalógusra, ahol bármilyen elemet megtalálhat annak egyedi indexe alapján. A kulcs az érték egyedi azonosítója a térképen. Például a Map<String-ben az Item> String az online áruház egyes tételeinek azonosítója. A dokumentáció szerint a Map a következő alinterfészekkel rendelkezik:
Kötések ;
ConcurrentMap<K,V> ;
ConcurrentNavigableMap<K,V> ;
LogicalMessageContext ;
MessageContext ;
NavigableMap<K,V> ;
SOAPMessageContext ;
Rendezetttérkép<K,V> .
És megvalósítja az osztályokat:
AbstractMap
Attribútumok
AuthProvider
ConcurrentHashMap
ConcurrentSkipListMap
EnumMap
HashMap
Hashtable
IdentityHashMap
LinkedHashMap
PrinterStateReasons
Tulajdonságok
Szolgáltató
RenderingHints
SimpleBindings
TabularDataSupport
TreeMap
UIDalapértelmezettek
WeakHashMap
A Java AbstractMap egy absztrakt osztály, amely a legtöbb Map felületet megvalósítja.
A Java HashMap egy adatstruktúra kulcs-érték párok tárolására hash tábla segítségével.
A Java TreeMap egy adatstruktúra fa használatára, azaz rendezett kulcsokkal való megjelenítésre.
A WeakHashMap gyenge kulcsokkal rendelkező hash tábla használatához, olyan értékek megjelenítéséhez, amelyeket a szemétgyűjtő törölhet, ha már nem használják őket.
A LinkedHashMap egy térkép az elemek hozzáadásának sorrendjével, lehetővé teszi az iterációt a beillesztési sorrendben.
Az EnumMap kiterjeszti az AbstractMap osztályt az enum kulcsokkal való használatra.
Az IdentityHashMap hivatkozási egyenértékűség-ellenőrzést használ a dokumentumok összehasonlításakor, a kulcsokkal való leképezést
== művelettel hasonlítja össze az equals() metódus helyett
Itt a Map Interface legnépszerűbb implementációira vagyunk kíváncsiak: HashMap, TreeMap és LinkedHashMap. A térképelemek sorrendje egyébként a konkrét megvalósításoktól függ. Tegyük fel, hogy a TreeMap és a LinkedHashMap az elemek sorrendje kiszámítható, míg a HashMap nem.
Térképes módszerek
Bármely térkép fő műveletei az elemek beszúrása, eltávolítása és keresése.
public Object put (Object key, Object value) beszúr egy elemet a térképbe.
public void putAll(Map map) beszúrja a megadott térképet a térképbe.
public Object Remove (Object key) törli a bejegyzést a megadott kulcsnak megfelelően.
public Object get(Object key) a megadott kulcs értékét adja vissza.
public boolean includeKey(Object key) a megadott kulcsot keresi erről a térképről
public Set keySet() az összes kulcsot tartalmazó Set nézetet adja vissza
public Set entrySet() egy Set nézetet ad vissza az összes kulccsal és értékkel.
Mi az a HashMap
Mi az a HashMap? Ez a Map<Key,Value> felület legnépszerűbb megvalósítása. Ez az adatstruktúra a hash elvén alapul.
A HashMap munka fő elve: hash
Ahhoz, hogy megértsük, mi a hashmap és hogyan működik, beszéljünk először a hash-ről és a hash függvényekről. A hash függvény csak matematikai értelemben vett függvény. Tehát van valamilyen bemeneti érték (egy objektum, egy adat), és a függvény egy megfelelő szabály segítségével kimeneti értékké konvertálja – hash-vé. A hash gyakran egy megfelelő hosszúságú hexadecimális szám. Az átalakítási folyamatok szabályai eltérőek lehetnek, de ezekre a következő elvek vonatkoznak:
Egy adott bemenetnek (objektumnak) van egy adott hash kódja.
Ha két objektum egyenlő, akkor a hash kódjuk is egyenlő. Ennek a fordítottja nem igaz.
Ha a hash kódok különböznek, az objektumok határozottan nem azonosak.
Néha különböző objektumok ugyanazzal a hash kóddal rendelkezhetnek. Ez egy nagyon valószínűtlen esemény, az úgynevezett „ütközés”, és egy jó minőségű hash függvény minimalizálja az ütközések valószínűségét.
Java nyelven minden objektumnak van hash kódja. Kiszámítása az Object osztály hashCode metódusával történik, amely az összes Java objektum szülői osztálya. Általában a fejlesztők felülírják ezt a metódust saját osztályaikra, valamint a hozzá tartozó azonos módszerekre.
HashMap: hogyan működik
Tehát a HashMap<K,V> osztály, mint minden Map implementáció kulcsokból és értékekből áll. A kulcsokat kivonatolási elvek szerint tárolja. A HashMap kulcsérték párok „vödrökben” vannak tárolva, ezek a gyűjtőzónák együtt alkotnak egy „táblázatot”, egy belső linkelt listák tömbjét, amelynek kezdeti mérete 16. A Java HashMap a kulcs hashkódját használja annak meghatározására, hogy a kulcs/érték párnak melyik gyűjtőt kell leképeznie: A HashMap trükkös tulajdonsága, hogy a [] tábla minden cellája (vödöre) nem csak egy párt tárol, hanem több párat is. Nem explicit objektumként (mint például a LinkedList) tárolódnak, hanem implicit láncként. A lánc annak a ténynek köszönhető, hogy minden pár tárol egy linket a következő párhoz. Vagyis az összes HashMap pár 16 láncban van szétszórva. Amikor új párt tesz a táblázatba, a kulcs kivonatát veszi figyelembe. Ez a hash nem a kulcsobjektumba épített hashcode függvény. 0-15 tartományba esik. A pár hozzáadódik a hash indexű vödörben tárolt párok láncához. Ez a megközelítés felgyorsítja a keresést. Ha kulcs alapján keres párat, nem kell végigmenni a teljes táblázaton. A rendszer figyelembe veszi a kulcs hash-ét, és csak azt a láncot ellenőrzi, amely a hash indexű cellában van tárolva. Ha túl sok pár van a HashMapben, a láncok túl hosszúak lesznek. Ezután a tömb mérete megnő, az összes tárolt objektum hash-je újraszámításra kerül, és új láncok mentén szétszóródik.
HashMap nyilatkozat
Ha a HashMap osztály kódjára lép, a következő deklarációt találja:
public class HashMap extends AbstractMap implements Map, Cloneable, Serializable
Ahol K a leképezés által karbantartott kulcsok típusa, V pedig a leképezett értékek típusa. Ez egy példa a HashMap deklarációra Integer kulccsal és String értékkel a kódban:
HashMap<Integer, String> myHashMap = new HashMap<Integer, String>();
HashMap módszerek
Itt található a HashMap metódusok listája.
Az Object get(Object key) a megadott kulcs értékét adja vissza;
Object put(Key k, Value v) kulcsértékleképezést illeszt be a térképbe;
Az objektum eltávolítása (Object key) eltávolítja a megadott kulcs leképezését erről a leképezésről, ha van;
void clear() eltávolítja az összes kulcs-érték párt a HashMap-ről;
Az Object clone() ennek a HashMap-példánynak egy sekély másolatát adja vissza a kulcsok és értékek klónozása nélkül;
boolean includeKey(Object key) true értéket ad vissza, ha a megadott kulcs megtalálható a térképen, hamis értéket, ha nem;
boolean includeValue(Object Value) igazat ad vissza, ha a megadott kulcs megtalálható a térképen, hamis értéket, ha nem;
A logikai isEmpty() igaz értéket ad vissza, ha a térkép üres, hamis értéket, ha nem;
A Set keySet() a térképről leolvasott kulcsok halmazát adja vissza;
int size() a kulcs-érték leképezés mennyiségét adja vissza;
A Collection values() a térkép értékeinek gyűjteményét adja vissza;
Az objektum eltávolítása (Object key) eltávolítja a megadott kulcs kulcs-érték párját;
void putAll(Map m) a térkép összes elemét átmásolja a másik térképre.
Java HashMap példa
Hozzunk létre egy programot a Java HashMap példával, hogy bemutassuk, hogyan működik:
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);
}
}
}
A program futtatásának eredménye:
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:
{}
TreeMap
A TreeMap a Java-ban is megvalósítja a Map<Key,Value> interfészt, de ez a Red-Black fa adatstruktúrán alapul. A fa "csomópontokból" és vonalakból áll, amelyek csomópontokat - ágakat kötnek össze. A "gyökér" csomópont a fa tetején található. A gyökértől kezdve lehetnek ágak és csomópontok. Ez egy hierarchikus struktúra, gondolhatnánk ezek a csomópontok a gyökér „gyermekei" A bináris keresési fa egy olyan struktúra, amelyben minden belső csomópont tárol egy kulcsot és néha egy hozzá tartozó értéket, és két megkülönböztetett alfával rendelkezik ("bal" és "jobb"). Az önkiegyensúlyozó bináris keresési fa egy csomópont alapú bináris keresési fa, amely automatikusan alacsonyan tartja magasságát (a gyökér alatti szintek maximális számát) tetszőleges elembeszúrások és -törlések esetén. A piros-fekete fa egy kiegyensúlyozott bináris fa a következő tulajdonságokkal:
Minden csomópont piros vagy fekete
A gyökér mindig fekete
Minden levél egy NIL (egyfajta üres, nulla) csomópont, és fekete
Ha egy csomópont piros, gyermekei határozottan feketék.
Minden egyszerű útvonal egy csomóponttól a leszármazott levélig ugyanannyi fekete csomópontot tartalmaz.
A TreeMap jellemzői
A TreeMap egy fa adatszerkezetet használ a kulcsok csomópontként való tárolására, és a kulcsokat a Red-Black Tree algoritmus segítségével rendezi. Tehát a TreeMap bejegyzéseit a kulcsok természetes sorrendje szerint rendezi. Számok esetében a természetes növekvő sorrend, karakterláncok esetén - ábécé. Használhat összehasonlító eszközt, ha meg kell változtatnia a rendelés logikáját. Az objektumok természetes módon történő rendezése a TreeMap nagy előnye, valamint egyes objektumok megtalálása különböző szűrőkkel és feltételekkel.
TreeMap módszerek
Az Object get(Object key) a megfelelő kulcs értékét adja vissza;
Object put(Object key, Object value) leképezést szúr be a térképbe;
Az objektum eltávolítása (Object key) eltávolítja a kulcs leképezését, ha a TreeMap tartalmazza azt;
Boolean includeKey(Object key) igazat ad vissza, ha ez a leképezés tartalmazza a megadott kulcs leképezését;
A logikai értékű includeValue(Object value) értéke igaz, ha a TreeMap egy vagy több kulcsot leképez a megadott értékre;
Az Object firstKey() az aktuálisan rendezett térkép első kulcsát adja vissza;
Az Object lastKey() az utolsó kulcsot adja vissza a rendezett térképen;
void putAll(Map map) az összes leképezést átmásolja a megadott térképről a térképre;
Set entrySet() a leképezések halmaznézetét adja vissza
Az int size() a kulcsérték-leképezések mennyiségét adja vissza
A Collection values() az értékek gyűjteménynézetét adja vissza
Az Object clone() a TreeMap sekély másolatát adja vissza
A void clear() eltávolít minden hozzárendelést a TreeMap-ről
A SortedMap headMap(Object key_value) a leképezés azon részének nézetét adja vissza, amely kisebb, mint a kulcsérték paraméter
A Set keySet() a fatérképben található kulcsok halmaznézetét adja vissza
A SortedMap subMap(K fromKey, K toKey) a térkép azon részének nézetét adja vissza, amelynek kulcsai a kulcstól a kulcstól a kulcsig, kizárólagosig terjednek.
Az Object firstKey() a TreeMap első kulcsát adja vissza.
TreeMap példa
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);
}
}
A program futtatásának eredménye:
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
A LinkedHashMap egy olyan adatstruktúra, amely összekapcsolja a hivatkozott listákat és a hash térképeket. Valójában a LinkedHashMap kiterjeszti a HashMap osztályt és megvalósítja a Map felületet, de mi a helyzet a hivatkozott listákkal? A LinkedHashMap nyilatkozata:
Map <Integer, String> linkedHashMap = new LinkedHashMap <Integer, String>();
Ez az új linkedHashMap a HashMap tulajdonságait örökli (például tábla, loadFactor, threshold, size, entrySet), két speciális tulajdonságot is kap:
a fejléc egy duplán linkelt lista feje. Az inicializálás során jelzi magát
Az accessOrder jelzi, hogyan lehet hozzáférni az elemekhez az iterátor segítségével. Ha igaz, akkor az utolsó hozzáférés sorrendjében. Ha hamis, a hozzáférés az elemek beszúrásának sorrendjében történik.
Ez a linkelt lista határozza meg az iterációs sorrendet. Általában ez a kulcsok beillesztési sorrendje a térképen.
LinkedHashMap Methods
Az Object get(Object key) azt az értéket adja vissza, amelyre a megadott kulcs le van rendelve, vagy nullát, ha ez a leképezés nem tartalmaz leképezést a kulcshoz
void clear() eltávolítja az összes leképezést a térképről.
Boolean includeKey(objektumkulcs) igazat ad vissza, ha a megadott elem egy vagy több kulccsal van leképezve
boolean removeEldestEntry(Map.Entry legrégebbi) értéke igaz, ha a térkép eltávolítja a legrégebbi bejegyzést a térképről
Set<Map.Entry<K,V>> entrySet() a térképen található leképezések halmaznézetét adja vissza
void forEach(BiConsumer<? Super K,? Super V> művelet) végrehajtja az adott műveletet a térkép minden bejegyzéséhez, amíg az összes bejegyzést fel nem dolgozták, vagy a művelet kivételt nem tesz.
Az objektum getOrDefault(Object key, V defaultValue) azt az értéket adja vissza, amelyhez a megadott kulcs hozzá van rendelve. Ha a leképezés nem tartalmaz leképezést a kulcshoz, az alapértelmezett értéket adja vissza.
A Set<K> keySet() a térképen található kulcsok halmaznézetét adja vissza
boolean removeEldestEntry(Map.Entry<K,V> legrégebbi) igazat ad vissza, ha a térkép eltávolítja a legrégebbi bejegyzést
void csereAll(BiFunction<? super K,? super V,? extends V> function) minden bejegyzés értéket lecserél az adott függvény meghívásának eredményével, amíg az összes bejegyzés feldolgozásra nem kerül, vagy a függvény kivételt nem dob.
A Collection<v>values() a térképen található értékek gyűjteménynézetét adja vissza
LinkedHashMap példa
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);
}
}
Itt létrehozunk egy új LinkedHashMap-et, öt elem hozzáadásával, majd kinyomtatjuk iterátorral és klasszikus módon. Mint látható, a LinkedHashMap fenntartja a beillesztési sorrendet. Utána törölünk egy elemet a térképünkről, majd hozzáadunk egy újat, majd később - még egy elemet a kulccsal, ami már a térképen van. Lecseréli az ehhez a kulcshoz társított régi értéket. A program futtatásának eredménye:
A HashMap, a TreeMap és a LinkedHashMap a Map interfészek megvalósításai. A HashMap és a LinkedHashMap olyan adatstruktúrák, amelyek kivonatolja a kulcsokat. A TreeMap a kulcsok természetes sorrendjét használja a keresési fa rendszerezéséhez. Rendelés:
A HashMap nem tart fenn rendet.
A TreeMap a bejegyzéseket a kulcsok növekvő sorrendjében rendezi.
A LinkedHashMap fenntartja a beillesztési sorrendet.
Null billentyűk:
A HashMap és a LinkedHashMap lehetővé teszi egy nullkulcs használatát.
A LinkedHashMap nem engedélyezi a null kulcsokat, ha a kulcsok természetes sorrendet használnak, vagy a Comparator nem támogatja a null kulcsok összehasonlítását.
Vegyünk egy Java térképpéldát, amely tartalmazza mindhárom, ebben a cikkben ismertetett megvalósítást:
Amint látjuk, a HashMap-ben nem egyértelmű az elemek sorrendje, a treeMap-ben kulcsoktól függ, a LinkedHashMap-ban a beillesztési sorrendről van szó. Ha megpróbáljuk null kulcsot tenni a linkedHashMap-be, akkor NullPointerException-t kapunk, de a linkedHashMap1-ben, ahol a kulcsok a String, megtehetjük. A hash térkép a legjobb általános célú térképmegvalósítás. Maximális keresési sebességet, gyors tárolást és visszakeresési műveleteket biztosít, de ne feledje a kaotikus rendezést. A linkelt hash térkép örökli a HashMap előnyeit, és megrendelést kap a kulcsokra. Ugyanakkor tartalmazza a linkedList-et, ami viszonylag költséges a memória szempontjából. lassabb, mint a HashMap a keresésben, és egy kicsit lassabb a hozzáadáshoz/eltávolításhoz, mert fenntartja a linkelt listát. A fatérkép a kulcsokat növekvő sorrendben tárolja. Azonban, A tanultak megerősítése érdekében javasoljuk, hogy nézzen meg egy videóleckét a Java-tanfolyamról
GO TO FULL VERSION