Tingnan ang tsart sa paghahambing na ipinakita sa ibaba upang malaman ang ilang higit pang mga pagkakaiba sa pagitan ng HashMap at Hashtable.

1. Tsart ng paghahambing
2. Kahulugan
3. Pangunahing Pagkakaiba
4. Pagkakatulad
5. Konklusyon

Tsart ng paghahambing

Kahulugan ng HashMap

Ang HashMap ay isang klase na nagpapatupad ng Map interface at pinalawak ang AbstractMap ang klase ay gumagamit ng hash table. Ang object ng HashMap ay tumutukoy sa isang koleksyon / set ng ipares kung saan ang bawat key ay nai-map sa isang partikular na halaga. Ang mga susi sa isang koleksyon ay dapat na natatangi dahil ginagamit ang mga ito upang makuha ang halaga. Sa kabilang banda, ang mga halaga sa isang koleksyon ay maaaring doblehin. Ang pagpapahayag ng klase ng HashMap at mga tagabuo ng HashMapclass ay ang sumusunod:

Ang K ay kumakatawan sa susi, at ang V ay kumakatawan sa halaga * / klase HashMap / * Mga tagapagtayo ng klase ng HashMap * / HashMap () HashMap (Map <? Umaabot K,? Umaabot V> m) HashMap (int kapasidad) HashMap (int kapasidad, float fillRatio)

Ang unang tagapagtayo ay isang default na tagapagtayo na nagsisimula sa isang walang laman na bagay ng HashMap na may isang default na kapasidad ng 16 at default na ratio ng punong 0.75. Ang pangalawang tagabuo ay paunang-una ang hash map na may halaga ng m. Ang ikatlong tagabuo ay lumilikha ng isang mapa ng hash na may paunang kapasidad na nauugnay sa halaga na ibinigay sa argumentong "kapasidad". Ang pang-apat na konstruksyon ay nag-uumpisa sa hash map na may isang kapasidad at isang punong ratio na ibinigay sa mga parameter. alamin natin ngayon kung paano pakainin ang mga entry sa isang mapa ng hash.

Hashmap hm = bagong Hashmap (); hm.put ("Ajay", 275); hm.put ("Vijay", 250); hm.put ("Jonny", 150); hm.put ("Jordan", 200); System.out.ln (hm); / * output * / {Vijay = 250, Jonny = 150, Ajay = 275, Jordan = 200}

Sa itaas na code, makikita mo na lumikha ako ng isang walang laman na bagay na HashMap hm na may default na paunang kapasidad at default na ratio ng punan. Pagkatapos ay ipinasok ko ang apat na mga entry sa mapa ng hash gamit ang met (K, V) na pamamaraan na naglalagay ng mapa sa susi. Maaari mong obserbahan na ang mga entry ay hindi nai-edit sa isang pagkakasunud-sunod na pinapakain mo ang mga ito dahil hindi maayos ang insertion. Ngayon, isaalang-alang ang isang kaso na mayroon ka nang isang entry sa hash map at pagkatapos na subukan mong ipasok ang ilagay (K1, V5), sinubukan mong i-mapa ang parehong key na may ibang halaga. Kung gayon ang papalit na pamamaraan ay papalitan ang lumang halaga ng V1 sa bagong halaga V2 at ibabalik ang lumang halagaV1, kung hindi man, kung hindi natin subukan na palitan ang halaga ng isang key pagkatapos ay ibabalik ang pamamaraan ng Null para sa key na iyon.

Kahulugan ng Hashtable

Ang Hashtable ay isang klase na nagpapalawak ng Diksyonaryo klase na kung saan ay isang pamana ng legacy at muling nag-iisa upang maipatupad ang Map interface. Ginagamit ng Hashtable ang talahanayan ng hash bilang istraktura ng data nito. Ang Hashtable ay katulad ng HashMap dahil dito din ang object ng Hashtable ay tumutukoy sa koleksyon ng mga entry kung saan ang bawat entry ay isang pares ng . Ang lahat ng mga susi sa isang koleksyon ay dapat na natatangi sa kabilang banda, maaaring madoble ang mga halaga. Ang mga susi ay partikular na ginagamit upang makuha ang halaga ng hash code na nagpapasya sa index, kung saan ang pares ay maiimbak sa isang talahanayan ng hash. Sa isang hash table, ni isang susi o isang halaga ay hindi maaaring bumalik sa Null pointer. Tingnan natin ang pagpapahayag ng klase ng Hashtable at mga tagabuo ng hashtable na klase.

/ * K tinukoy ang susi at tinukoy ng V ang halaga na nauugnay sa susi * / klase ng Hashtable / * Mga tagapagtayo ng Hashtable * / Hashtable () Hashtable (laki ng int) Hashtable (laki ng laki, float fillRatio) Hashtable (Map <? umaabot K,? umaabot ng V> m)

Sa itaas na code, ang unang tagabuo ay isang default na tagapagtayo na lumilikha ng isang walang laman na bagay ng isang klase ng Hashtable, ang laki ng default na ito ay 11 at ang default na ratio ng fill ay 0.75. Ang ikalawang tagabuo ay lumilikha ng isang talahanayan ng hash na may sukat na nauugnay sa halaga na ibinigay sa "laki" ng parameter. Ang ikatlong tagapagtayo ay lumilikha ng isang talahanayan ng hash na may sukat at isang ratio ng punan na ibinigay sa parameter. Ang pang-apat na tagabuo ay paunang-una ang hash table na may halaga m. Alamin natin ngayon kung paano ipasok ang pares sa hash table.

Hashtable ht = bagong Hashtable (); ht.put (bagong hashCode (2), 275); ht.put (bagong hashCode (12), 250); ht.put (bagong hashCode (16), 150); ht.put (bagong hashCode (8), 200); System.out.ln (ht); / * output * / {12 = 250, 16 = 150,2y = 275, 8 = 200}

Sa itaas na code, gumawa ako ng isang walang laman na bagay ng Hashtable at ipinasok ang apat na mga entry gamit ang ilagay () na pamamaraan. Sa loob ng paraan ng pagtawag ay tinawag ko ang hashCode () na nakikipagkuwenta at ibabalik ang halaga ng hash code na kikilos bilang halaga ng index para sa pagpasok ng object. Tulad ng nakikita mo ay hindi ko nabanggit ang laki ng hash table kaya sa default ay magiging 11. Dito rin, ang pagpasok ng order ay hindi napanatili at samakatuwid, kapag ang mga entry sa ed ay hindi lumitaw sa pagkakasunud-sunod ay pinapakain ito.

1. Nagpapatupad ang HashMap Map interface at nagpapalawak ng isang abstract na klase, AbstractMap samantalang, ang Hashtable ay nagpapalawak ng abstract na klase Diksyonaryo, na kung saan ay din ng isang klase ng Pamana, nang maglaon ay muling nagtrabaho upang maipatupad Map interface.
2. Ang bagay na HashMap ay hindi naka-synchronise i.e. maraming mga thread ay maaaring gumana sa parehong oras at sa gayon, ito ay object na hindi ligtas ang thread. Sa kabilang banda, ang mga bagay ng Hashtable naka-synchronize kung ang isang thread ay nais na gumana sa isang bagay ng Hashtable kailangan itong makakuha ng isang lock sa bagay na iyon upang walang ibang sinulid na ma-access ang bagay na iyon at samakatuwid, ligtas ang thread.
3. Sa HashMap key maaaring bumalik Isang beses lang Null, at ang halaga ay maaaring bumalik Null nang maraming beses. Sa kabilang banda, ang isang susi ay hindi maaaring bumalik sa Null dahil ginamit ito upang makuha ang halaga ng hash code na ginagamit bilang isang indeks upang maimbak ang pares at ni isang halaga ay maaaring bumalik Null.
4. Ang default na kapasidad ng isang talahanayan ng hash sa klase ng HashMap ay 16 samantalang, ang default na kapasidad ng isang talahanayan ng hash sa Hashtable ay 11.
5. Ang Iterator maaaring maglakad ng mga entry sa Hashmap. Sa kabilang banda, ang Hashtable ay hindi direktang sumusuporta sa Iterator at samakatuwid, sa pangkalahatan Enumerator ay ginagamit para sa paglalakbay sa mga entry sa Hashtable.

Pagkakatulad:

• Ang HashMap at Hashtable ay parehong gumagamit ng data na istraktura ng hash table.
• Parehong ipinatutupad ang HashMap at Hashtable Map interface
• Ang pagkakasunud-sunod ng pagsingit ay hindi mapangalagaan sa parehong HashMap at Hashtable at batay sa hash code na nakuha gamit ang mga susi.
• Sa HashMap at Hashtable, dapat na ang mga Susi natatangi samantalang, ang mga halaga ay maaaring nadoble.
• Parehong maaaring maglaman ng HashMap at Hashtable heterogenous na mga bagay para sa parehong mga susi at halaga.
• Ang HashMap at Hashtable, parehong nagpapatupad Serializable at Ma-cloneable mga interface ngunit hindi, random na pag-access.
• Parehong may default na ratio ng fill ang HashMap at Hashtable 0.75.
• Parehong pinakamahusay ang HashMap at Hashtable para sa pagkuha o naghahanap operasyon.

Konklusyon:

Ang HashMap ay mas mahusay sa pagganap dahil ang mga bagay nito ay hindi ma-synchronise at maraming mga thread ay maaaring gumana sa parehong oras at sa gayon, mas mabilis ito kaysa sa Hashtable.