Interface ng Mapa sa Java

Ano ang Java Map Interface

Ang interface ng Java Map ay bahagi ng framework ng Java Collection, ngunit hindi ito isang subtype ng interface ng Collection. Kaya kumikilos ito sa ibang paraan kumpara sa, sabihin nating, Mga Listahan, o iba pang Mga Bagay sa koleksyon. Ang bawat elemento ng Map<Key, Value> ay kumakatawan sa isang key-value pair. Parehong Key at value ang ilang bagay. Ang lahat ng mga susi sa isang partikular na mapa ay natatangi, habang ang mga halaga ay hindi, kaya maaari silang ma-duplicate. Maaari mong isipin ang Map sa Java tulad ng isang uri ng diksyunaryo o online-shop catalog, kung saan mahahanap mo ang anumang item gamit ang natatanging index nito. Ang susi ay isang natatanging identifier ng value sa isang Map. Halimbawa sa Map<String, Item> String ay isang ID ng ilang Item mula sa online shop. Ayon sa mga dokumentasyon Ang Map ay may mga susunod na Subinterfaces:

Bindings ;

ConcurrentMap<K,V> ;

ConcurrentNavigableMap<K,V> ;

LogicalMessageContext ;

MessageContext ;

NavigableMap<K,V> ;

SOAPMessageContext ;

SortedMap<K,V> .

At Nagpapatupad ng mga Klase:

AbstractMap
Mga Katangian
AuthProvider
ConcurrentHashMap
ConcurrentSkipListMap
EnumMap
HashMap
Hashtable
IdentityHashMap
LinkedHashMap
PrinterStateReasons
Ari-arian
Provider
Mga Pahiwatig sa Pag-render
SimpleBindings
TabularDataSupport
TreeMap
UIDefaults
WeakHashMap

Ang Java AbstractMap ay isang abstract na klase na nagpapatupad ng karamihan sa interface ng Map.
Ang Java HashMap ay isang istraktura ng data para sa pag-iimbak ng mga pares ng key-value gamit ang hash table.
Ang Java TreeMap ay isang istraktura ng data upang gumamit ng isang puno, ibig sabihin, pagpapakita na may mga pinagsunod-sunod na key.
WeakHashMap para gumamit ng hash table na may mahinang mga key, ipakita na may mga value na maaaring tanggalin ng garbage collector kung hindi na sila ginagamit.
Ang LinkedHashMap ay isang mapa na may pagkakasunud-sunod ng pagdaragdag ng mga elemento, nagbibigay-daan sa pag-ulit sa pagkakasunud-sunod ng pagpapasok.
Pinapalawak ng EnumMap ang klase ng AbstractMap para magamit sa mga enum key.

Gumagamit ang IdentityHashMap ng referential equivalence checking kapag naghahambing ng mga dokumento, nagmamapa gamit ang mga key kumpara gamit ang == operation sa halip na equals() method

Dito kami ay interesado sa pinakasikat na pagpapatupad ng Map Interface: HashMap, TreeMap at LinkedHashMap. Sa pamamagitan ng paraan, ang pagkakasunud-sunod ng mga elemento ng mapa ay nakasalalay sa mga partikular na pagpapatupad. Sabihin, ang TreeMap at LinkedHashMap ay may predictable na pagkakasunud-sunod ng mga elemento, habang ang HashMap ay wala.

Mga pamamaraan ng mapa

Ang mga pangunahing operasyon ng anumang Map ay ang pagpasok, pag-alis, at paghahanap ng mga elemento.

pampublikong Object put(Object key, Object value) ay naglalagay ng elemento sa mapa.
ipinapasok ng public void putAll(Map map) ang tinukoy na mapa sa loob ng mapa.
pampublikong Object remove(Object key) tinatanggal ang isang entry ayon sa tinukoy na key.
pampublikong Object get(Object key) ay nagbabalik ng halaga para sa tinukoy na key.
Ang public boolean containsKey(Object key) ay naghahanap ng tinukoy na key mula sa mapang ito
public Set keySet() ay nagbabalik ng Set view na naglalaman ng lahat ng key
public Set entrySet() ay nagbabalik ng Set view kasama ang lahat ng mga key at value.

Ano ang HashMap

Ano ang HashMap? Ito ang pinakasikat na pagpapatupad ng interface ng Map<Key,Value>. Ang istruktura ng data na ito ay batay sa prinsipyo ng hashing.

Ang pangunahing prinsipyo ng gawaing HashMap: hashing

Upang maunawaan kung ano ang isang hashmap at kung paano ito gumagana, pag-usapan muna natin ang tungkol sa mga function ng hashing at hash. Ang hash function ay isang function lamang sa isang mathematical sense. Kaya mayroong ilang halaga ng input (isang bagay, isang piraso ng data) at pinapalitan ito ng function gamit ang isang wastong panuntunan sa halaga ng output - isang hash. Kadalasan, ang hash ay isang hexadecimal na numero ng tamang haba. Maaaring iba ang mga panuntunan sa pag-convert ng mga proseso, ngunit napapailalim sila sa mga sumusunod na prinsipyo:

Ang isang partikular na input (object) ay may partikular na hash code.
Kung pantay ang dalawang bagay, pantay din ang kanilang mga hash code. Ang kabaligtaran ay hindi totoo.
Kung magkaiba ang mga hash code, tiyak na hindi pantay ang mga bagay.
Minsan ang iba't ibang mga bagay ay maaaring magkaroon ng parehong hash code. Ito ay isang hindi malamang na kaganapan, na pinangalanang "bangga" at isang mahusay na kalidad ng hash function ay dapat mabawasan ang posibilidad ng mga banggaan.

Sa Java, ang bawat bagay ay may hash code. Kinakalkula ito ng hashCode method ng Object class, parental class ng lahat ng Java Objects. Karaniwan, ina-override ng mga developer ang pamamaraang ito para sa kanilang sariling mga klase pati na rin ang mga katumbas na pamamaraang nauugnay dito.

HashMap: kung paano ito gumagana

Kaya ang Class HashMap<K,V> dahil ang bawat pagpapatupad ng Map ay binubuo ng mga susi at halaga. Nag-iimbak ito ng mga susi gamit ang mga prinsipyo ng hashing. Sa loob ng mga pares ng HashMap Key-value ay naka-imbak sa "mga bucket", ang mga bucket na ito ay magkasamang bumubuo ng isang "talahanayan", isang panloob na hanay ng mga naka-link na listahan at ang paunang sukat nito ay 16. Ang HashMap sa Java ay gumagamit ng hashcode ng key upang matukoy ang isang bucket kung saan dapat imapa ng key/value pair: Ang nakakalito na feature ng HashMap ay ang bawat cell (bucket) ng talahanayan [] ay nagpapanatili ng hindi lamang isang pares kundi ilang. Hindi sila naka-imbak bilang isang tahasang bagay (tulad ng LinkedList), ngunit bilang isang implicit na chain. Ang chain ay nilikha dahil sa ang katunayan na ang bawat pares ay nag-iimbak ng isang link sa susunod na pares. Ibig sabihin, lahat ng mga pares ng HashMap ay nakakalat sa 16 na chain. Kapag naglagay ka ng bagong pares sa talahanayan, isasaalang-alang ang hash ng key. Ang hash na ito ay hindi isang hashcode function na nakapaloob sa pangunahing bagay. Ito ay itinuturing na nasa hanay ng 0-15. Ang pares ay idinagdag sa chain ng mga pares na nakaimbak sa bucket na may hash index. Ang diskarte na ito ay nagbibigay sa amin ng acceleration ng paghahanap. Habang naghahanap ng isang pares sa pamamagitan ng susi, hindi na kailangang dumaan sa buong talahanayan. Ang hash ng key ay isinasaalang-alang at tanging ang chain na naka-imbak sa cell na may hash index ang sinusuri. Kung napakaraming pares sa HashMap, nagiging masyadong mahaba ang mga chain. Pagkatapos ang laki ng array ay tumataas, ang hash ng lahat ng naka-imbak na bagay ay muling kinalkula, at sila ay nakakalat sa mga bagong chain.

Pahayag ng HashMap

Kung pupunta ka sa class na HashMap code makikita mo ang susunod na deklarasyon:

public class HashMap extends AbstractMap implements Map, Cloneable, Serializable

Kung saan ang K ay ang uri ng mga key na pinananatili ng mapa na ito at V - ang uri ng mga naka-map na halaga. Ito ay isang halimbawa ng deklarasyon ng HashMap na may Integer key at String value sa iyong code:

HashMap<Integer, String> myHashMap = new HashMap<Integer, String>();

Mga pamamaraan ng HashMap

Narito ang listahan ng mga pamamaraan ng HashMap.

Ang Object get(Object key) ay nagbabalik ng halaga para sa tinukoy na key;
Ang Object put(Key k, Value v) ay naglalagay ng key value mapping sa mapa;
Object remove(Object key) inaalis ang pagmamapa para sa tinukoy na key mula sa mapang ito kung naroroon;
inaalis ng void clear() ang lahat ng pares ng key-value mula sa HashMap;
Ang Object clone() ay nagbabalik ng mababaw na kopya ng halimbawang ito ng HashMap nang hindi kine-clone ang mga key at value;
Ang boolean containsKey(Object key) ay nagbabalik ng true kung ang tinukoy na key ay matatagpuan sa mapa, false kung hindi;
Ang boolean containsValue(Object Value) ay nagbabalik ng true kung ang tinukoy na key ay matatagpuan sa mapa, false kung hindi;
Ang boolean isEmpty() ay nagbabalik ng true kung ang mapa ay walang laman, false kung hindi;
Ibinabalik ng Set keySet() ang Set ng mga key na kinuha mula sa mapa;
int size() ay nagbabalik ng dami ng key-value mapping;
Ang collection values() ay nagbabalik ng koleksyon ng mga value ng mapa;
Object remove(Object key) inaalis ang key-value pair para sa tinukoy na key;
kinokopya ng void putAll(Map m) ang lahat ng elemento ng mapa sa kabilang mapa.

Halimbawa ng Java HashMap

Gumawa tayo ng isang programa na may Halimbawa ng Java HashMap upang ipakita kung paano ito gumagana:

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

   }
}

Ang resulta ng pagpapatakbo ng programa:

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

Ang TreeMap sa Java ay nagpapatupad din ng Map<Key,Value> na interface, ngunit ito ay batay sa istraktura ng data ng Red-Black tree. Ang Puno ay binubuo ng "mga node" at mga linya na nag-uugnay sa mga node - mga sanga. Ang "ugat" na node ay nasa tuktok ng puno. Mula sa ugat, maaaring mayroong mga sanga at node. Ito ay isang hierarchical na istraktura, maaari mong isipin ang mga node na ito bilang "mga anak" ng ugat. Ang child node ay maaaring magkaroon ng sarili nitong mga anak - lower node. Ang mga node na walang mga bata ay tinatawag na "end-nodes" o "mga dahon". Ang binary tree ay isang puno, kung saan ang bawat node ay may zero, isa , o dalawang bata. Ang binary search tree ay isang istraktura, kung saan ang bawat panloob na node ay nag-iimbak ng isang susi, at kung minsan ay isang nauugnay na halaga, at may dalawang natatanging sub-puno ("kaliwa" at "kanan"). Ang self-balancing binary search tree ay isang node-based na binary search tree na awtomatikong pinapanatili ang taas nito (maximum na bilang ng mga antas sa ibaba ng ugat) sa harap ng mga arbitrary na pagpapasok at pagtanggal ng item. Ang pulang-itim na puno ay isang balanseng binary tree na may mga katangian:

Ang bawat node ay alinman sa pula o itim
Laging itim ang ugat
Ang bawat dahon ay isang NIL (uri ng walang laman, null) na node at ito ay itim
Kung pula ang isang node, tiyak na itim ang mga anak nito.
Ang bawat simpleng landas mula sa isang node hanggang sa isang descendant na dahon ay naglalaman ng parehong bilang ng mga itim na node.

Mga tampok ng TreeMap

Gumagamit ang TreeMap ng istraktura ng data ng puno upang iimbak ang mga susi bilang mga node at pag-uri-uriin ang mga susi gamit ang algorithm ng Red-Black Tree. Kaya, pinapanatili ng TreeMap ang mga entry nito na pinagsunod-sunod ayon sa natural na pagkakasunud-sunod ng mga susi nito. Para sa mga numero natural ay pataas na pagkakasunud-sunod, para sa mga string - alpabetikong pagkakasunud-sunod. Maaari kang gumamit ng comparator kung kailangan mong baguhin ang logic ng pag-order. Ang pag-uuri ng mga bagay sa natural na paraan ay isang malaking bentahe ng TreeMap, pati na rin ang paghahanap ng ilang mga bagay gamit ang iba't ibang mga filter at kundisyon.

Mga pamamaraan ng TreeMap

Ang Object get(Object key) ay nagbabalik ng halaga ng kaukulang key;
Ang Object put(Object key, Object value) ay naglalagay ng pagmamapa sa isang mapa;
Object remove(Object key) inaalis ang pagmamapa para sa key na ito kung ang TreeMap ay naglalaman nito;
Ang boolean containsKey(Object key) ay nagbabalik ng true kung ang mapang ito ay naglalaman ng pagmamapa para sa tinukoy na key;
Ang boolean containsValue(Object value) ay nagbabalik ng true kung ang TreeMap ay nagmamapa ng isa o higit pang mga key sa tinukoy na halaga;
Ibinabalik ng Object firstKey() ang unang key na kasalukuyang nasa pinagsunod-sunod na mapa;
Ibinabalik ng Object lastKey() ang huling key na kasalukuyang nasa pinagsunod-sunod na mapa;
void putAll(Map map) kinokopya ang lahat ng mappings mula sa tinukoy na mapa papunta sa mapa;
Ang set entrySet() ay nagbabalik ng set view ng mga mappings
int size() ay nagbabalik ng dami ng key-value mappings
Ang collection values() ay nagbabalik ng collection view ng mga value
Ang Object clone() ay nagbabalik ng mababaw na kopya ng TreeMap
inaalis ng void clear() ang lahat ng mga pagmamapa mula sa TreeMap
Ang SortedMap headMap(Object key_value) ay nagbabalik ng view ng bahagi ng mapa na mas mababa kaysa sa parameter key_value
Ang Set keySet() ay nagbabalik ng Set view ng mga key na nakapaloob sa treemap
Ang SortedMap subMap(K fromKey, K toKey) ay nagbabalik ng view ng bahagi ng mapang ito na ang mga key ay mula sa Key, inclusive, hanggang toKey, exclusive
Ibinabalik ng Object firstKey() ang unang key mula sa TreeMap.

Halimbawa ng TreeMap

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

Ang resulta ng pagpapatakbo ng programa:

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

Ang LinkedHashMap ay isang istraktura ng data na pinagsasama ang mga naka-link na listahan at hash na mga mapa. Sa katunayan, pinalawak ng LinkedHashMap ang klase ng HashMap at ipinapatupad ang interface ng Map, ngunit ano ang tungkol sa mga naka-link na listahan? Ang deklarasyon ng LinkedHashMap:

Map <Integer, String> linkedHashMap = new LinkedHashMap <Integer, String>();

Ang bagong linkedHashMap na ito ay nagmamana ng mga katangian mula sa HashMap (tulad ng talahanayan, loadFactor, threshold, laki, entrySet), ay nakakakuha din ng dalawang espesyal na katangian:

ang header ay ang pinuno ng isang dobleng naka-link na listahan. Sa panahon ng pagsisimula, ipinapahiwatig nito ang sarili nito
Ang accessOrder ay nagpapahiwatig kung paano makakuha ng access sa mga elemento gamit ang iterator. Kung totoo, sa pagkakasunud-sunod ng huling pag-access. Kung mali, ang pag-access ay nasa pagkakasunud-sunod na ipinasok ang mga elemento.

Tinutukoy ng naka-link na listahang ito ang pag-order ng pag-ulit. Karaniwan, ito ay ang pagkakasunud-sunod ng pagpasok ng mga susi sa mapa.

Mga Paraan ng LinkedHashMap

Ibinabalik ng Object get(Object key) ang halaga kung saan nakamapa ang tinukoy na key, o null kung walang mapping para sa key ang mapang ito.
inaalis ng void clear() ang lahat ng mga pagmamapa mula sa mapa.
Ang boolean containsKey(Object key) ay nagbabalik ng true kung ang tinukoy na elemento ay nakamapa ng isa o higit pang mga key
Ang boolean removeEldestEntry(Map.Entry eldest) ay nagbabalik ng true kung aalisin ng mapa ang pinakamatanda nitong entry mula sa mapa
Ang Set<Map.Entry<K,V>> entrySet() ay nagbabalik ng Set view ng mga mapping na nilalaman sa mapa na ito
isinagawa ng void forEach(BiConsumer<? super K,? super V> action) ang ibinigay na aksyon para sa bawat entry sa mapang ito hanggang sa maproseso ang lahat ng entry o maghagis ng exception ang aksyon.
Ibinabalik ng Object getOrDefault(Object key, V defaultValue) ang halaga kung saan naka-map ang tinukoy na key. Kung ang mapa ay hindi naglalaman ng pagmamapa para sa key ay nagbabalik ng defaultValue.
Ang Set<K> keySet() ay nagbabalik ng Set view ng mga key na nakapaloob sa mapa
Ang boolean removeEldestEntry(Map.Entry<K,V> eldest) ay nagbabalik ng true kung dapat alisin ng mapang ito ang pinakamatanda nitong entry
void replaceAll(BiFunction<? super K,? super V,? extends V> function) pinapalitan ang bawat entry value na may resulta ng pag-invoke ng ibinigay na function sa entry na iyon hanggang sa maproseso ang lahat ng entry o maghagis ng exception ang function.
Ang Collection<v>values() ay nagbabalik ng Collection view ng mga value na nakapaloob sa mapa

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

Dito kami gumawa ng bagong LinkedHashMap, nagdaragdag ng limang elemento, pagkatapos ay i-print ito gamit ang iterator at sa klasikal na paraan. Gaya ng nakikita mo, pinapanatili ng LinkedHashMap ang pagkakasunud-sunod ng pagpapasok. Pagkatapos nito, tatanggalin namin ang isang elemento mula sa aming Map, pagkatapos ay idagdag ang bago at mamaya - isa pang elemento na may susi, na nasa mapa na. Pinapalitan nito ang lumang value na naka-map sa key na ito. Ang resulta ng pagpapatakbo ng programa:

key: 7 value: Johnny
key: 12 value: Rick
key: 1 value: Kyle
key: 5 value: Percy
key: 85 value: Sebastian
{7=Johnny, 12=Rick, 1=Kyle, 5=Percy, 85=Sebastian}
{7=Johnny, 12=Rick, 1=Kyle, 5=Percy, 85=Sebastian, 21=Ivy}
{7=Johnny, 1=Kyle, 5=Percy, 85=Sebastian, 21=Ivy}
{7=Johnny, 1=Kyle, 5=Percy, 85=Sebastian, 21=Ivy, 12=Ronny}
{7=Johnny, 1=Stan, 5=Percy, 85=Sebastian, 21=Ivy, 12=Ronny}

HashMap, TreeMap, LinkedHashMap Paghahambing

Ang HashMap, TreeMap, at LinkedHashMap ay ang mga pagpapatupad ng mga interface ng Map. Ang HashMap at LinkedHashMap ay mga istruktura ng data na nagha-hash ng mga key. Ginagamit ng TreeMap ang natural na pagkakasunud-sunod ng mga susi nito sa pag-aayos ng isang search tree. Order:

Ang HashMap ay hindi nagpapanatili ng anumang pagkakasunud-sunod.
Pinag-uuri-uri ng TreeMap ang mga entry sa pataas na pagkakasunud-sunod ng mga key.
Pinapanatili ng LinkedHashMap ang insertion order.

Null key:

Ang HashMap at LinkedHashMap ay nagbibigay-daan sa pagkakaroon ng isang null key.
Hindi pinapayagan ng LinkedHashMap ang mga null key kung sakaling ang mga key ay gumagamit ng natural na pagkakasunud-sunod o hindi sinusuportahan ng Comparator ang paghahambing sa mga null ley.

Magkaroon tayo ng halimbawa ng mapa ng Java na kinabibilangan ng lahat ng tatlong pagpapatupad na nasuri sa artikulong ito:

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

public class CompMapImpl {


    public static void main(String[] args) {
        HashMap<Integer, String> hashMap = new HashMap<>();
        TreeMap<Integer, String> treeMap = new TreeMap<>();
        LinkedHashMap<Integer, String> linkedHashMap = new LinkedHashMap<>();
        hashMap.put(5, "Ivy");
        hashMap.put(null, "Joker");
        hashMap.put(1, "First");
        hashMap.put(2, "Kyle");
        hashMap.put(-2, "Paul");
        hashMap.put(3, "Sandy");


        treeMap.put(5, "Ivy");
        //treeMap.put(null,"Joker");
        treeMap.put(1, "First");
        treeMap.put(2, "Kyle");
        treeMap.put(-2, "Paul");
        treeMap.put(3, "Sandy");

        linkedHashMap.put(5, "Ivy");
        linkedHashMap.put(null, "Joker");
        linkedHashMap.put(1, "First");
        linkedHashMap.put(2, "Kyle");
        linkedHashMap.put(-2, "Paul");
        linkedHashMap.put(3, "Sandy");
        System.out.println("HashMap");
        System.out.println(hashMap);
        System.out.println("TreeMap");
        System.out.println(treeMap);
        System.out.println("LinkedHashMap");
        System.out.println(linkedHashMap);


        LinkedHashMap<String, String> linkedHashMap1= new LinkedHashMap<> ();
        linkedHashMap1.put(null, "Andy");
        System.out.println(linkedHashMap1);
    }
}

Narito ang resulta ng pagpapatakbo ng program na ito:

HashMap
{null=Joker, 1=First, -2=Paul, 2=Kyle, 3=Sandy, 5=Ivy}
TreeMap
{-2=Paul, 1=First, 2=Kyle, 3=Sandy, 5=Ivy}
LinkedHashMap
{5=Ivy, null=Joker, 1=First, 2=Kyle, -2=Paul, 3=Sandy}
{null=Andy}

Tulad ng nakikita natin, ang pagkakasunud-sunod ng mga elemento sa HashMap ay hindi halata, sa treeMap ito ay nakasalalay sa mga susi, sa LinkedHashMap ito ay tungkol sa pagkakasunud-sunod ng pagpasok. Kung susubukan naming ilagay ang null key sa linkedHashMap, makakakuha kami ng NullPointerException, ngunit sa linkedHashMap1, kung saan ang mga key ay String, magagawa namin ito. Ang hash map ay ang pinakamahusay na pangkalahatang layunin na pagpapatupad ng mapa. Nagbibigay ito ng maximum na bilis ng paghahanap, mabilis na pag-iimbak, at mga operasyon sa pagkuha, ngunit dapat mong tandaan ang tungkol sa magulong pag-order nito. Ang isang naka-link na hash map ay nagmamana ng mga pakinabang ng HashMap at nakakakuha ng order para sa mga susi. Gayunpaman, naglalaman ito ng linkedList, na medyo mahal sa mga tuntunin ng memorya. ito ay mas mabagal kaysa sa HashMap sa paghahanap at medyo mabagal para sa pagdaragdag/pag-alis dahil sa pagpapanatili ng naka-link na listahan. Ang isang tree map ay nag-iimbak ng mga susi na pinagsunod-sunod sa pataas na pagkakasunud-sunod. gayunpaman, Upang palakasin ang iyong natutunan, iminumungkahi naming manood ka ng isang video lesson mula sa aming Java Course

Higit pang pagbabasa:
Paano i-update ang halaga ng isang umiiral na key sa HashMap HashMap getOrDefault na pamamaraan sa Java KeySet method sa java.util.Map