Ipinapakilala ang koleksyon ng HashMap

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 Setkoleksyon, 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 Mapbinubuo 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:

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. HashMapklase

Ang HashMapklase ay ang pinakasikat na uri ng Mapkoleksyon. 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 HashMapgamit ang isang pahayag na tulad nito:

HashMap<KeyType, ValueType> name = new HashMap<KeyType, ValueType>();

Nasaan KeyTypeang uri ng mga susi sa mga nakaimbak na pares, at ValueTypeang uri ng mga halaga sa mga pares na nakaimbak sa HashMapkoleksyon.

Ang HashMapklase ay may mga pamamaraan tulad nito:

void put(KeyType key, ValueType value)

ValueType get(KeyType key)

boolean containsKey(KeyType key)

boolean containsValue(ValueType value)

ValueType remove(KeyType key)

void clear()

int size()

Set<KeyType> keySet()

Collection<ValueType> values()

Set<Map.Entry<KeyType, ValueType>> entrySet()

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 HashMaptulad ng isang array o isang listahan na ang mga indeks ay mga salita ( String) sa halip na mga numero.

3. Mga subset ng a HashMap: ang hanay ng mga key

Sabihin nating gusto lang nating ipakita ang lahat ng mga entry sa isang HashMapsa 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

HashMapang 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:

HashMap<String, Integer> map = new HashMap<String, Integer>();
map.put("Elon", 21);
map.put("Jeff", 22);
map.put("Bill", 48);
map.put("Warren", null);

for (String key: map.keySet())
{
   Integer value = map.get(key);
   System.out.println(key + " --> " + value);
}

Ang keySet()pamamaraan ay nagbabalik ng isang hanay ng mga susi. Magagamit mo ang set na ito sa dalawang paraan:

for (String key: map.keySet())
{
   Integer value = map.get(key);
   System.out.println(key + " --> " + value);
}

Set<String> keys = map.keySet();

for (String key: keys)
{
   Integer value = map.get(key);
   System.out.println(key + " --> " + value);
}

4. Pag-looping sa mga pares ng key-value

Mayroon ding mas kumplikadong paraan: maaari mong ibahin ang Mapanyo ng isang set ng key-value pairs , at pagkatapos ay i-loop ang mga elemento ng set, gaya ng natutunan na natin.

Ang HashMapkoleksyon 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 Setklase 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 entriesat sa halip ay tawagan ang entrySet()pamamaraan nang direkta sa loob ng forloop:

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 varoperator 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 ArrayListatHashMap

Ang isang HashMapmalakas na kahawig ng isang ArrayListna nagpapahintulot sa mga string (o iba pang mga uri) na magamit bilang mga index (ang mga susi).

Kung gagamitin mo Integerpara sa mga susi sa isang HashMap, ito ay magiging mas katulad ng isang ArrayList. Ihambing natin:

ArrayList<String> list = new ArrayList<String>();

list.add("Greetings");
list.add("Hello");

String s = list.get(0);
list.set(0, s + "!");

for (String item: list)
{
   System.out.println(item);
}

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

map.put(0, "Greetings");
map.put(1, "Hello");

String s = map.get(0);
map.put(0, s + "!");

for (String item: map.values())
{
   System.out.println(item);
}