Mga sagot sa pinakasikat na tanong tungkol sa interface ng Map

Kamusta! Ngayon ay magbibigay kami ng mga sagot sa mga pinakakaraniwang tanong tungkol sa Mapa, ngunit una, tandaan natin kung ano ito. Ang mapa ay isang istraktura ng data na naglalaman ng isang hanay ng mga pares ng key-value. Ang istraktura ng data nito ay kahawig ng isang diksyunaryo, kung kaya't madalas itong tinatawag na iyon. Kasabay nito, ang Map ay isang interface , at sa karaniwang jdk naglalaman ito ng mga pangunahing pagpapatupad: Hashmap, LinkedHashMap, Hashtable, TreeMap. Ang pinaka ginagamit na pagpapatupad ay Hashmap, kaya gagamitin namin ito sa aming mga halimbawa. Ganito ang hitsura ng karaniwang paggawa at pagpuno ng isang mapa:

Map<Integer, String> map = new HashMap<>();
map.put(1, "string 1");
map.put(2, "string 2");
map.put(3, "string 3");

At ito ay kung paano makakuha ng mga halaga sa pamamagitan ng susi:

String string1 = map.get(1);
String string2 = map.get(2);
String string3 = map.get(3);

Kung malinaw ang lahat ng nasa itaas, magpatuloy tayo sa aming mga sagot sa mga sikat na tanong!

0. Paano umulit sa lahat ng halaga ng Map

Ang pag-ulit sa mga halaga ay ang pinakakaraniwang operasyong ginagawa mo gamit ang mga mapa. Lahat ng key-value pairs ay naka-store sa panloob na Map.Entry interface, at para makuha ang mga ito kailangan mong tawagan ang entrySet(). Nagbabalik ito ng isang Set ng mga pares na maaaring i-loop sa pamamagitan ng:

for(Map.Entry<Integer, String> entry: map.entrySet()) {
   // get key
   Integer key = entry.getKey();
   // get value
   String value = entry.getValue();
}

Или используя итератор:
Iterator<Map.Entry<Integer, String>> itr = map.entrySet().iterator();
while(itr.hasNext()) {
   Map.Entry<Integer, String> entry =  itr.next();
   // get key
   Integer key = entry.getKey();
   // get value
   String value = entry.getValue();
}

1. Paano i-convert ang Map sa List

Ang interface ng Mapa ay may 3 pamamaraan na nagbabalik ng isang listahan ng mga elemento:

• keySet() - nagbabalik ng Set ng mga key;
• values() - nagbabalik ng Koleksyon ng mga halaga;
• entrySet() - nagbabalik ng Set ng key-value sets.

Kung titingnan mo ang mga constructor ng class ArrayList, mapapansin mo na mayroong isang constructor na may argumento ng uri ng Collection. Dahil ang Set ay isang inapo ng Collection, ang mga resulta ng lahat ng mga pamamaraan sa itaas ay maipapasa sa constructor ng class ArrayList. Kaya gagawa kami ng mga bagong listahan at punan ang mga ito ng mga halaga mula sa Map:

// key list
List<Integer> keyList = new ArrayList<>(map.keySet());
// value list
List<String> valueList = new ArrayList<>(map.values());
// key-value list
List<Map.Entry<Integer, String>> entryList = new ArrayList<>(map.entrySet());

2. Paano pag-uri-uriin ang mga key ng mapa

Ang pag-uuri ng mga mapa ay medyo karaniwang operasyon din sa programming. Magagawa mo ito sa maraming paraan:

1. Ilagay ang Map.Entry sa isang listahan at ayusin ito gamit ang Comparator .

   Sa comparator ihahambing lamang namin ang mga susi ng mga pares:

   List> list = new ArrayList(map.entrySet());
   Collections.sort(list, new Comparator<Map.Entry<Integer, String>>() {
      @Override
      public int compare(Map.Entry<Integer, String> o1, Map.Entry<Integer, String> o2) {
          return o1.getKey() - o2.getKey();
      }
   });
   

   Kung naiintindihan mo ang mga lambdas, ang entry na ito ay maaaring makabuluhang paikliin:

   Collections.sort(list, Comparator.comparingInt(Map.Entry::getKey));

2. Gamitin ang SortedMap, o mas tiyak, ang pagpapatupad nito TreeMap, na kumukuha ng Comparator sa constructor nito. Ang comparator na ito ay ilalapat sa mga key ng mapa, kaya ang mga key ay dapat na mga klase na nagpapatupad ng interface Comparable:

   SortedMap<Integer, String> sortedMap = new TreeMap<>(new Comparator<Integer>() {
      @Override
      public int compare(Integer o1, Integer o2) {
          return o1 - o2;
      }
   });

   At, siyempre, lahat ay maaaring muling isulat gamit ang mga lambdas:

   SortedMap<Integer, String> sortedMap = new TreeMap<>(Comparator.comparingInt(o -> o));

   Hindi tulad ng unang paraan, gamit ang SortedMap, palagi naming iimbak ang data sa pinagsunod-sunod na anyo.

3. Paano pagbukud-bukurin ang mga halaga ng mapa

Dito dapat kang gumamit ng isang diskarte na katulad ng una para sa mga susi - kumuha ng isang listahan ng mga halaga at pag-uri-uriin ang mga ito sa listahan:

List <Map.Entry<Integer, String>> valuesList = new ArrayList(map.entrySet());
Collections.sort(list, new Comparator<Map.Entry<Integer, String>>() {
   @Override
   public int compare(Map.Entry<Integer, String> o1, Map.Entry<Integer, String> o2) {
       return o1.getValue().compareTo(o2.getValue());
   }
});

At ang lambda para dito ay ganito ang hitsura:

Collections.sort(list, Comparator.comparing(Map.Entry::getValue));

4. Ano ang pagkakaiba ng HashMap, TreeMap, at Hashtable

Gaya ng nabanggit kanina, mayroong 3 pangunahing pagpapatupad ng interface ng Map. Ang bawat isa sa kanila ay may sariling mga katangian:

1. Pagkakasunud-sunod ng mga elemento. HashMapat Hashtablehindi ginagarantiya na ang mga item ay maiimbak sa pagkakasunud-sunod ng mga ito ay idinagdag. Bilang karagdagan, hindi nila ginagarantiya na ang pagkakasunud-sunod ng mga elemento ay hindi magbabago sa paglipas ng panahon. Sa turn, TreeMapginagarantiyahan nito ang pag-iimbak ng mga elemento sa pagkakasunud-sunod na idinagdag o alinsunod sa isang ibinigay na comparator.

2. Mga wastong halaga. HashMapnagbibigay-daan sa iyo na magkaroon ng isang susi at isang null na halaga, HashTablehindi. Ang TreeMap ay maaari lamang gumamit ng mga null value kung pinapayagan ito ng comparator. Nang hindi gumagamit ng comparator (sa pamamagitan ng pag-iimbak ng mga pares sa pagkakasunud-sunod na idinagdag sa mga ito), hindi pinapayagan ang null.

3. Pag-synchronize. Naka-synchronize lang HashTable, ang iba ay hindi. Kung ang mapa ay hindi maa-access ng iba't ibang mga thread, inirerekomendang gamitin ang HashMap sa halip na HashTable.

At isang pangkalahatang paghahambing ng mga pagpapatupad:

5. Paano gumawa ng bidirectional na mapa

Minsan kinakailangan na gumamit ng istraktura ng data kung saan ang parehong mga susi at mga halaga ay magiging natatangi, iyon ay, ang mapa ay maglalaman ng mga pares ng key-key. Nagbibigay-daan sa iyo ang istruktura ng data na ito na lumikha ng isang "baligtad na view/search" sa mapa. Ibig sabihin, makakahanap tayo ng susi ayon sa halaga nito. Ang istruktura ng data na ito ay tinatawag na bidirectional na mapa, na, sa kasamaang-palad, ay hindi sinusuportahan ng JDK. Ngunit, sa kabutihang palad, ang pagpapatupad nito ay matatagpuan sa Apache Common Collections o Guava library. Doon ito ay tinatawag na BidiMap at BiMap, ayon sa pagkakabanggit. Ang mga pagpapatupad na ito ay nagpapataw ng mga paghihigpit sa pagiging natatangi ng mga susi at halaga. Lumilikha ito ng isa-sa-isang relasyon.

6. Paano lumikha ng isang walang laman na Mapa

Mayroong dalawang paraan upang lumikha ng isang walang laman na mapa:

1. Normal na pagsisimula ng object:

   Map<Integer, String> emptyMap = new HashMap<>();

2. Paglikha ng hindi nababagong walang laman na mapa:

   Map<Integer, String> emptyMap =  Collections.emptyMap();

Kapag sinubukan naming magdagdag ng data sa naturang mapa, makakatanggap kami ng: UnsupportedOperationExceptionexception. Sa artikulong ito, tiningnan namin ang mga pinakakaraniwang tanong na maaaring mayroon ka kapag ginagamit ang interface ng Map.