HashMap: anong uri ng mapa ito?

Hi! Sa araling ito, kukuha tayo ng mas malapit na pagsusuri sa Java HashMap . Noong nakaraan, pinag-aralan namin ang mga istruktura ng data kung saan naka-imbak ang mga elemento bilang kanilang sarili. Sa isang array o isang ArrayList / LinkedList , nag-iimbak kami ng ilang bilang ng mga elemento. Ngunit paano kung magbago ng kaunti ang ating gawain? Isipin ang sumusunod na gawain: gumawa ng listahan ng 100 tao na nag-iimbak ng pangalan at numero ng pasaporte ng bawat tao. Sa prinsipyo, hindi ito napakahirap. Halimbawa, maaari mong ilagay ang dalawa sa isang string, at pagkatapos ay gumawa ng listahan ng mga string na ito: "Amelia Aguilar, 4211 717171". Ngunit ang solusyon na ito ay may dalawang disbentaha. Una, maaaring kailanganin natin ang kakayahang maghanap gamit ang numero ng pasaporte. At ito ay magiging problema dahil sa format na imbakan ng impormasyon na ito. Pangalawa, walang pumipigil sa atin na lumikha ng dalawang magkaibang tao na may parehong numero ng pasaporte. At ito ang pinakamalubhang pagkukulang ng aming solusyon. Hindi ito dapat pahintulutan: walang dalawang tao na may parehong numero ng pasaporte. Isang bagong istruktura ng data ang tumulong sa amin: Map. Kilala rin ito bilang isang "associative array", ngunit ang terminong ito ay madalang na ginagamit. Mas karaniwan, ito ay tinatawag na "diksyonaryo" o "mapa". :) Paano ito sa panimula ay naiiba kaysa sa mga istruktura ng data na aming napag-isipan dati? Higit sa lahat, sa katotohanan na ang data sa isang Map ay naka-store bilang key-value pairs. Anumang bagay ay maaaring magsilbi bilang mga susi at halaga: mga numero, string, o mga bagay ng iba pang mga klase. Ngayon, pag-aaralan natin ang pinakakaraniwang pagpapatupad ng klase ng Map : Java HashMap .

Kaya, ano ang kailangan nating malaman tungkol sa HashMap sa Java?

Napakadaling likhain:

public static void main(String[] args) {
   HashMap<Integer, String> passportsAndNames = new HashMap<>();
}

Dito kami gumagawa ng diksyunaryo na nag-iimbak ng mga elemento bilang mga pares na "number-string". Ang numero ay magsisilbing susi, at ang string bilang ang halaga. Tinukoy din namin ang uri ng key (Integer) at ang uri ng halaga (String). Bakit? Una, palaging kakaiba ang isang HashMap key. Ito ay ganap na nababagay sa amin, dahil maaari naming gamitin ang numero ng pasaporte bilang susi at maiwasan ang mga duplicate. Ang halaga ay isang string na may buong pangalan (maaaring magkapareho ang pangalan ng iba't ibang tao; wala tayong dapat ipag-alala). Ang pagdaragdag ng bagong pares sa HashMap ay ganito ang hitsura:

public class Main {

   public static void main(String[] args) {
       HashMap<Integer, String> passportsAndNames = new HashMap<>();

       passportsAndNames.put (212133, "Bridget Logan");
       passportsAndNames.put (162348, "Ivan the Great");
       passportsAndNames.put(8082771, "Donald John Trump");
       System.out.println(passportsAndNames);
   }
}

Ginagamit namin ang paraan na put() para dito. Bilang karagdagan, in-override ng HashMap ang toString() na paraan, upang maipakita ito sa console. Ang output ay magiging ganito: {212133=Bridget Logan, 8082771=Donald John Trump, 162348=Ivan the Great} Ngayon, i-verify natin kung ang mga susi ay talagang kakaiba? Subukan nating magdagdag ng bagong elemento na may susi na nagamit na sa mapa:

public static void main(String[] args) {
   HashMap<Integer, String> passportsAndNames = new HashMap<>();

   passportsAndNames.put (212133, "Bridget Logan");
   passportsAndNames.put (162348, "Ivan the Great");
   passportsAndNames.put(8082771, "Donald John Trump");
   passportsAndNames.put(162348, "Albert Kent");// This key has already been used
   System.out.println(passportsAndNames);
}

Output: {212133=Bridget Logan, 8082771=Donald John Trump, 162348=Albert Kent} Gaya ng nakikita mo, ang dating value na nauugnay sa key na 162348 ay na-overwrite. Ginagamit namin ang terminong "susi" para sa isang dahilan. Ang mga halaga sa isang HashMap ay ina-access gamit ang susi, ngunit hindi ang kabaligtaran. Ang susi ay hindi maaaring makuha gamit ang isang halaga, dahil ang mga halaga ay maaaring hindi natatangi. Malinaw itong makikita kapag kumukuha o nag-aalis ng elemento mula sa HashMap :

public static void main(String[] args) {
   HashMap<Integer, String> passportsAndNames = new HashMap<>();

   passportsAndNames.put (212133, "Bridget Logan");
   passportsAndNames.put (162348, "Ivan the Great");
   passportsAndNames.put(8082771, "Donald John Trump");

   String lidiaName = passportsAndNames.get(212133);
   System.out.println(lidiaName);

   passportsAndNames.remove(162348);
   System.out.println(passportsAndNames);
}

Upang makakuha ng isang halaga o mag-alis ng isang pares mula sa diksyunaryo, dapat nating ipasa sa get() at alisin() ang natatanging key na tumutugma sa halaga. Hindi tulad ng mga array at listahan, ang isang HashMap sa Java ay walang mga numeric na indeks: ang mga halaga ay ina-access gamit ang key. Output ng console: Bridget Logan {212133=Bridget Logan, 8082771=Donald John Trump} Hinahayaan tayo ng mga klase ng ArrayList at LinkedList na suriin kung naglalaman ang listahan ng anumang partikular na elemento. Hinahayaan kami ng Java HashMap na gawin ito. Higit pa rito, magagawa natin ito para sa parehong miyembro ng pares: Ito ang containsKey() (nagsusuri para sa isang key) at containsValue()(pagsusuri para sa isang halaga) mga pamamaraan ay para sa.

public static void main(String[] args) {
   HashMap<Integer, String> passportsAndNames = new HashMap<>();

   passportsAndNames.put (212133, "Bridget Logan");
   passportsAndNames.put (162348, "Ivan the Great");
   passportsAndNames.put(8082771, "Donald John Trump");

   System.out.println(passportsAndNames.containsKey(11111));
   System.out.println(passportsAndNames.containsValue("Donald John Trump"));
}

Output: false true Ang isa pang maginhawang feature ng HashMap sa Java ay ang katotohanang makakakuha ka ng hiwalay na listahan ng lahat ng key at lahat ng value. Ito ay nagagawa gamit ang keySet() at values() na mga pamamaraan:

public class Main {

   public static void main(String[] args) {
       HashMap<Integer, String> passportsAndNames = new HashMap<>();

       passportsAndNames.put (212133, "Bridget Logan");
       passportsAndNames.put (162348, "Ivan the Great");
       passportsAndNames.put(8082771, "Donald John Trump");

       Set keys = passportsAndNames.keySet();
       System.out.println("Keys: " + keys);

       ArrayList<String> values = new ArrayList<>(passportsAndNames.values());
       System.out.println("Values: " + values);
   }
}

Ang mga susi ay kinukuha sa isang Set , na hindi pa namin saklaw. Ito ay espesyal dahil hindi ito maaaring maglaman ng mga umuulit na elemento. Ngayon ang pangunahing bagay ay tandaan na ang listahan ng lahat ng mga susi ay maaaring makuha mula sa isang HashMap sa isang hiwalay na koleksyon. Sa halimbawa, na-save namin ang mga halaga sa isang ordinaryong ArrayList . Output ng console: Mga Susi: [212133, 8082771, 162348] Mga Halaga: [Bridget Logan, Donald John Trump, Ivan the Great] Ang laki() at malinaw() na mga pamamaraan ay eksaktong parehong bagay tulad ng sa mga nakaraang istrukturang napag-usapan natin: ang una ay nagbabalik ng bilang ng mga elemento na kasalukuyang nasa diksyunaryo, ang pangalawa ay nag-aalis ng lahat ng mga elemento.

public static void main(String[] args) {
   HashMap<Integer, String> passportsAndNames = new HashMap<>();

   passportsAndNames.put (212133, "Bridget Logan");
   passportsAndNames.put (162348, "Ivan the Great");
   passportsAndNames.put(8082771, "Donald John Trump");

   System.out.println(passportsAndNames.size());
   passportsAndNames.clear();
   System.out.println(passportsAndNames);
}

Output: 3 {} Upang tingnan kung mayroong kahit isang elemento sa aming HashMap , maaari naming gamitin ang isEmpty() na paraan:

public static void main(String[] args) {
   HashMap<Integer, String> passportsAndNames = new HashMap<>();

   passportsAndNames.put (212133, "Bridget Logan");
   passportsAndNames.put (162348, "Ivan the Great");
   passportsAndNames.put(8082771, "Donald John Trump");

   if (!passportsAndNames.isEmpty()) {

       System.out.println(passportsAndNames);
   }
}

Output: {212133=Bridget Logan, 8082771=Donald John Trump, 162348=Ivan the Great} Ngayon ay maglalabas lang kami sa console pagkatapos ng paunang pagsusuri. :) Ang isa pang kawili-wiling punto ay ang dalawang Mapa ay maaaring pagsamahin sa isa. Nagawa ito gamit ang putAll() na pamamaraan. Tinatawag namin ito sa unang HashMap , ipasa ang pangalawa bilang argumento, at ang mga elemento mula sa pangalawa ay idinagdag sa una:

public static void main(String[] args) {
   HashMap<Integer, String> passportsAndNames = new HashMap<>();
   HashMap<Integer, String> passportsAndNames2 = new HashMap<>();

   passportsAndNames.put (212133, "Bridget Logan");
   passportsAndNames.put (162348, "Ivan the Great");
   passportsAndNames.put(8082771, "Donald John Trump");

   passportsAndNames2.put(917352, "Clifford Patrick");
   passportsAndNames2.put(925648, "Mitchell Salgado");

   passportsAndNames.putAll(passportsAndNames2);
   System.out.println(passportsAndNames);
}

Output: {917352=Clifford Patrick, 212133=Bridget Logan, 8082771=Donald John Trump, 925648=Mitchell Salgado, 162348=Ivan the Great} Ang lahat ng mga pares sa passportsAndNames2 ay nakopya sa passportsAndNames . Ngayon isaalang-alang ang isang mas kumplikadong halimbawa. Sa partikular, ang pag-ulit sa isang HashMap sa isang loop.

for (Map.Entry<Integer, String> entry: passportsAndNames.entrySet()) {
   System.out.println(entry);
}

Ang klase ng Map.Entry ay tumutukoy sa key-value pair sa loob ng diksyunaryo. Ang entrySet() na paraan ay nagbabalik ng isang listahan ng lahat ng mga pares sa aming HashMap . Dahil ang aming mapa ay binubuo ng mga pares ng Map.Entry na ito , umuulit kami sa mga pares, hindi magkakahiwalay na key o value. Output: 212133=Bridget Logan 8082771=Donald John Trump 162348=Ivan the Great Gayundin, huwag kalimutang pag-aralan ang opisyal na dokumentasyon ng Oracle para sa HashMap .