1. Isang hanay ng mga pares ng key-value.
Sa Java, isa pang kawili-wiling koleksyon (malawak na pagsasalita) ay Map
. Minsan ang istruktura ng data na ito ay tinatawag ding diksyunaryo.
Ito ay katulad ng Set
koleksyon, ngunit nag-iimbak ito ng isang set ng "mga pares" ng mga elemento sa halip na isang hanay ng mga elemento, Ang bawat pares sa isang ay Map
binubuo ng dalawang elemento: isang "susi" at isang "halaga".
Sabihin nating gusto mong iimbak ng iyong programa ang mga pangalan ng empleyado at ang kanilang mga suweldo, o ang mga pangalan ng iyong mga katrabaho at ang kanilang mga edad. Pagkatapos ay kakailanganin mo ng isang talahanayan tulad nito:
Pangalan | Edad |
---|---|
Elon | 21 |
Jeff | 22 |
Bill | 48 |
Warren | ? |
Ang bawat row ay naglalaman ng ilang value. Ire-refer namin ang pangalan bilang key ng pares , at ang edad bilang value ng pares .
Ang buong hanay ng mga pares na ito ay ang aming mapa ( Map
).
Ang susi ng isang pares ay maaaring anuman maliban sa null
. Ang mga susi ay dapat na natatangi: ang isang mapa ay hindi maaaring maglaman ng dalawang magkaparehong mga susi.
2. HashMap
klase
Ang HashMap
klase ay ang pinakasikat na uri ng Map
koleksyon. Sa isang banda, ito ay halos kapareho sa HashSet at mayroong lahat ng mga pamamaraan nito. Sa kabilang banda, ito ay tulad ng isang listahan ( ArrayList
) na maaaring gumamit ng mga salita (o anumang bagay) bilang mga indeks nito.
Maaari kang lumikha ng isang HashMap
gamit ang isang pahayag na tulad nito:
HashMap<KeyType, ValueType> name = new HashMap<KeyType, ValueType>();
Nasaan KeyType
ang uri ng mga susi sa mga nakaimbak na pares, at ValueType
ang uri ng mga halaga sa mga pares na nakaimbak sa HashMap
koleksyon.
Ang HashMap
klase ay may mga pamamaraan tulad nito:
Pamamaraan | Paglalarawan |
---|---|
|
Idinaragdag ang ( key , value ) pares sa koleksyon |
|
Ibinabalik ang value na nauugnay sa isang key. |
|
Sinusuri kung mayroong susi sa koleksyon |
|
Sinusuri ang pagkakaroon ng isang halaga sa koleksyon |
|
Nag-aalis ng elemento sa koleksyon |
|
Nililinis ang koleksyon, inaalis ang lahat ng elemento |
|
Ibinabalik ang bilang ng mga pares ng key-value sa koleksyon |
|
Ibinabalik ang hanay ng mga susi sa koleksyon |
|
Nagbabalik ng set na naglalaman ng mga elemento ng koleksyon |
|
Nagbabalik ng set ( Set ) ng lahat ng pares ( Map.Entry ) sa koleksyon. |
Pagdaragdag ng mga elemento sa aHashMap
Ang mga elemento ay idinaragdag sa isang mapa bilang mga pares gamit ang put()
pamamaraan. Ang susi ay ipinasa bilang ang unang argumento, at ang halaga ay ipinasa bilang ang pangalawa.
HashMap<String, Integer> map = new HashMap<String, Integer>();
map.put("Elon", 21);
map.put("Jeff", 22);
map.put("Bill", 48);
map.put("Warren", null);
Kapag nagdadagdag ng key-value pair, kung ang key ay mayroon na sa koleksyon, ang lumang value ay papalitan ng bagong value.
Ang gawi na ito ay gumagawa ng isang HashMap
tulad ng isang array o isang listahan na ang mga indeks ay mga salita ( String
) sa halip na mga numero.
Halos anumang uri ay maaaring ang KeyType o ValueType. Mayroong ilang maliit na karagdagang kinakailangan para sa KeyType, at matututuhan mo ang tungkol sa mga ito kapag pinag-aralan mo ang mga koleksyon nang mas detalyado sa paghahanap ng Mga Koleksyon ng Java.
3. Mga subset ng a HashMap
: ang hanay ng mga key
Sabihin nating gusto lang nating ipakita ang lahat ng mga entry sa isang HashMap
sa screen. Paano natin ito gagawin? Upang gawin ito, kailangan nating malaman kung paano dumaan sa lahat ng mga entry sa HashMap
. Magagawa ito sa maraming paraan.
Ang pinakamadaling paraan ay ang pag-ikot sa mga susi
HashMap
ang mga entry ay hindi binibilang nang sunud-sunod, kaya ang loop na may counter ay hindi gagana dito. Ngunit makakakuha tayo ng isang hanay ng mga susi gamit ang keySet()
pamamaraan, at alam mo na kung paano umulit sa isang set:
Code | Paglalarawan |
---|---|
|
I-loop ang mga key ng map Kunin ang value na nauugnay sa key |
Ang keySet()
pamamaraan ay nagbabalik ng isang hanay ng mga susi. Magagamit mo ang set na ito sa dalawang paraan:
Compact notation | Mahabang notasyon |
---|---|
|
|
4. Pag-looping sa mga pares ng key-value
Mayroon ding mas kumplikadong paraan: maaari mong ibahin ang Map
anyo ng isang set ng key-value pairs , at pagkatapos ay i-loop ang mga elemento ng set, gaya ng natutunan na natin.
Ang HashMap
koleksyon ay may helper class na nag-iimbak ng key-value pair. Ito ay mukhang humigit-kumulang na ganito:
class Entry<KeyType, ValueType>
{
private KeyType key;
private ValueType value;
public KeyType getKey()
{
return this.key;
}
public ValueType getValue()
{
return this.value;
}
}
Ang resulta ng pagtawag sa entrySet()
pamamaraan sa isang bagay ay magiging isang :HashMap<KeyType, ValueType>
Set<Entry<KeyType, ValueType>>
Set<Entry<KeyType, ValueType>> name = map.entrySet();
Narito mayroon kaming generic na Set
klase na may isang uri ng parameter, na siya namang isang generic na uri ( Entry
) na may dalawang uri ng mga parameter.
Napakadali para sa isang baguhan na malito tungkol dito. Ngunit sa sandaling malaman mo ito, maaari kang magsulat ng code tulad ng:
HashMap<String, Integer> map = new HashMap<String, Integer>();
map.put("Elon", 21);
map.put("Jeff", 22);
map.put("Bill", 48);
map.put("Warren", null);
Set<Map.Entry<String, Integer>> entries = map.entrySet();
for(Map.Entry<String, Integer> pair: entries)
{
String key = pair.getKey();
Integer value = pair.getValue();
System.out.println(key + " --> " + value);
}
Iyon ay sinabi, ang code na ito ay maaaring gawing simple ng kaunti:
Una, maaari mong laktawan ang paglikha ng isang hiwalay na variable para sa entries
at sa halip ay tawagan ang entrySet()
pamamaraan nang direkta sa loob ng for
loop:
for(Map.Entry<String, Integer> pair: map.entrySet())
{
String key = pair.getKey();
Integer value = pair.getValue();
System.out.println(key + " --> " + value);
}
Pangalawa, maaari mong gamitin ang kamakailang ipinakilalang var
operator para awtomatikong mahinuha ang uri ng key-value pair :
for(var pair: map.entrySet())
{
String key = pair.getKey();
Integer value = pair.getValue();
System.out.println(key + " --> " + value);
}
Hindi masama, eh?
5. Paghahambing ng ArrayList
atHashMap
Ang isang HashMap
malakas na kahawig ng isang ArrayList
na nagpapahintulot sa mga string (o iba pang mga uri) na magamit bilang mga index (ang mga susi).
Kung gagamitin mo Integer
para sa mga susi sa isang HashMap
, ito ay magiging mas katulad ng isang ArrayList
. Ihambing natin:
Code na may ArrayList<String> | Code na may HashMap<Integer, String> |
---|---|
|
|
GO TO FULL VERSION