Nangungunang 9 na Tanong Tungkol sa Mapa sa Java

Alalahanin na ang isang Map ay structured data na binubuo ng isang set ng key-value pairs, at ang bawat key ay magagamit lang ng isang beses sa isang Map. Sinasaklaw ng paksang ito ang 9 na pangunahing tanong tungkol sa paggamit ng Map sa Java at ang mga ipinatupad nitong klase. Para sa pagiging simple, gagamit ako ng mga generalization sa mga halimbawa . Samakatuwid, isusulat ko nang simple ang Map, nang hindi tinukoy ang Map specifier. Ngunit maaari mong ipagpalagay na ang parehong mga halaga ng K at V ay maihahambing, na nangangahulugang ang K ay umaabot sa Maihahambing at ang V ay umaabot din sa Maihahambing .

0. Pag-convert ng isang Mapa sa isang Listahan

Sa Java, ang interface ng Map ay nag-aalok ng tatlong uri ng mga koleksyon: isang key set, isang value set, at isang key-value set. Ang lahat ng mga ito ay maaaring gawing Listahan gamit ang tagabuo o pamamaraan addAll(). Ang sumusunod na code snippet ay nagpapakita kung paano gumawa ng ArrayList mula sa isang Map.

// list of keys
List keyList = new ArrayList(Map.keySet());
//list of values
List valueList = new ArrayList(Map.valueSet());
//list key-value
List entryList = new ArrayList(Map.entrySet());

1. I-loop ang lahat ng value sa Map

Ang paglalakad sa bawat key-value pair ay ang pinakapangunahing, pangunahing pamamaraan para sa paglalakad sa isang Map. Sa Java, ang bawat pares ay nakaimbak sa isang Map field na tinatawag na Map.Entry . Map.entrySet()nagbabalik ng isang hanay ng mga key-values, kaya ang pinakamabisang paraan upang maulit ang lahat ng value ng isang Map ay:

for(Entry entry: Map.entrySet()) {
  //get the key
  K key = entry.getKey();
  //get value
  V value = entry.getValue();
}

Magagamit din namin ang Iterator, lalo na sa mga bersyon na mas bata sa JDK 1.5

Iterator itr = Map.entrySet().iterator();
while(itr.hasNext()) {
  Entry entry = itr.next();
  //get the key
  K key = entry.getKey();
  //get value
  V value = entry.getValue();
}

2. Pag-order ng Mapa sa pamamagitan ng Mga Susi

Ang pagsasaayos ng mga Mapa sa pamamagitan ng mga susi ay isa pang karaniwang ginagamit na pamamaraan. Ang unang paraan ay ang magdagdag ng Map.Entry sa listahan, at pag-uri-uriin gamit ang isang comparator na nag-uuri ayon sa mga halaga.

List list = new ArrayList(Map.entrySet());
Collections.sort(list, new Comparator() {

  @Override
  public int compare(Entry e1, Entry e2) {
    return e1.getKey().compareTo(e2.getKey());
  }
});

Isa pang paraan: gumamit ng SortedMap , na, bilang karagdagan, ay nag-aayos din ng mga susi nito sa pagkakasunud-sunod. Ngunit, ang lahat ng mga susi ay dapat na naglalaman ng Comparable o tinatanggap ng comparator. Isa sa mga ipinatupad na klase SortedMapay TreeMap . Ang constructor nito ay tumatanggap ng comparator. Ipinapakita ng sumusunod na code kung paano gawing Mapayos ang isang normal.

SortedMap sortedMap = new TreeMap(new Comparator() {

  @Override
  public int compare(K k1, K k2) {
    return k1.compareTo(k2);
  }

});
sortedMap.putAll(Map);

3. Order Map ayon sa Values

Ang pagdaragdag ng isang Map sa listahan at pagkatapos ay pag-uuri-uriin ito ay gumagana sa kasong ito, ngunit sa pagkakataong ito kailangan mong gamitin ang Entry.getValue(). Ang code sa ibaba ay halos kapareho ng dati.

List list = new ArrayList(Map.entrySet());
Collections.sort(list, new Comparator() {

  @Override
  public int compare(Entry e1, Entry e2) {
    return e1.getValue().compareTo(e2.getValue());
  }

});

Magagamit pa rin natin ito SortedMapsa kasong ito, ngunit kung ang mga halaga ay natatangi. Sa kasong ito, maaari mong gawing key-value ang key-value pair. Ang solusyon na ito ay may matinding limitasyon at hindi ko inirerekomenda.

4. Pagsisimula ng static/immutable na Map

Kapag gusto mong manatiling hindi nababago ang isang Map, isang magandang paraan ay ang kopyahin ito sa isang hindi nababagong Map. Ang defensive programming technique na ito ay tutulong sa iyo na lumikha ng isang Map na hindi lamang ligtas na gamitin, kundi pati na rin ang thread-safe. Upang simulan ang isang static/immutable na Map, maaari kaming gumamit ng initializer static(tingnan sa ibaba). Ang problema sa code na ito ay sa kabila ng pagdedeklara ng isang Map bilang static final, maaari pa rin namin itong gamitin pagkatapos ng pagsisimula, halimbawa Test.Map.put(3,"three");. Kaya hindi ito tunay na immutability. Para gumawa ng hindi nababagong Map gamit ang isang static na initializer, kailangan namin ng super anonymous na klase, na idaragdag namin sa immutable na Map sa huling hakbang sa pagsisimula. Mangyaring tingnan ang pangalawang bahagi ng code. Kapag ang isang UnsupportedOperationException ay itatapon kung tatakbo ka Test.Map.put(3,"three");.

public class Test {

  private static final Map Map;
  static {
    Map = new HashMap();
    Map.put(1, "one");
    Map.put(2, "two");
  }
}
public class Test {

  private static final Map Map;
  static {
    Map aMap = new HashMap();
    aMap.put(1, "one");
    aMap.put(2, "two");
    Map = Collections.unmodifiableMap(aMap);
  }
}

Sinusuportahan din ng library ng Guava ang iba't ibang paraan upang simulan ang mga static at hindi nababagong koleksyon. Upang matuto nang higit pa tungkol sa mga benepisyo ng hindi nababagong mga koleksyon ng utility ng Guava, tingnan ang seksyong Mga Hindi nababagong Koleksyon sa Guava How-to .

5. Pagkakaiba sa pagitan ng HashMap, TreeMap, at Hashtable

Mayroong tatlong pangunahing pagpapatupad ng Map interface sa Java: HashMap , TreeMap , at Hashtable . Ang mga pangunahing pagkakaiba ay ang mga sumusunod:

• Pagkakasunod-sunod ng pagpasa . Hindi ginagarantiya ng HashMap at HashTable ang pag-order ng Map; sa partikular, hindi nila ginagarantiya na ang order ay mananatiling pareho sa paglipas ng panahon. Ngunit TreeMapito ay mag-order ng lahat ng mga halaga sa "natural na pagkakasunud-sunod" ng mga susi o ng isang comparator.
• Wastong mga pares ng key-value. HashMapnagbibigay-daan sa iyo na magkaroon ng null key at null value. HashTableay hindi pinapayagan ang isang null key o null na halaga. Kung TreeMapginamit ang natural na pagkakasunud-sunod o hindi pinapayagan ng comparator ang isang null key, isang pagbubukod ang itatapon.
• Pag-synchronize . Naka-synchronize lang HashTable, ang iba ay hindi. Ngunit, "kung hindi kailangan ang pagpapatupad ng thread-safe, inirerekomendang gamitin ang " HashMapsa halip HashTable.

Mas detalyadong paghahambing

.                       | HashMap | HashTable | TreeMap
-------------------------------------------------------

Упорядочивание          |нет      |нет        | да
null в ключ-meaning    | да-да   | нет-нет   | нет-да
синхронизировано        | нет     | да        | нет
производительность      | O(1)    | O(1)      | O(log n)
воплощение              | корзины | корзины   | красно-чёрное дерево

Magbasa pa tungkol sa relasyong HashMap vs. TreeMap vs. Hashtable vs. LinkedHashMap .

6. Mapa na may reverse search/view

Minsan, kailangan namin ng isang hanay ng mga pares ng key-key, na nangangahulugang ang mga halaga ay kasing kakaiba ng mga susi (isang one-to-one pattern). Binibigyang-daan ka ng pagkakapare-parehong ito na lumikha ng isang "baligtad na view/search" sa Map. Ibig sabihin, makakahanap tayo ng susi ayon sa halaga nito. Ang istruktura ng data na ito ay tinatawag na bidirectional na Map , na sa kasamaang-palad ay hindi sinusuportahan ng JDK. Parehong nag-aalok ang Apache Common Collections at Guava ng mga pagpapatupad ng bidirectional na Map na tinatawag na BidiMap at BiMap, ayon sa pagkakabanggit. Parehong nagpapakilala ng hadlang na nagpapatupad ng 1:1 na pagmamapa sa pagitan ng mga key at value.

7. Mababaw na kopya ng Mapa

Halos lahat, kung hindi man lahat, ang Maps sa Java ay naglalaman ng copy constructor para sa isa pang Map. Ngunit ang pamamaraan ng pagkopya ay hindi naka-synchronize. Ibig sabihin kapag ang isang thread ay kinopya ang isang Map, maaaring baguhin ng isa pang thread ang istraktura nito. Upang maiwasan ang biglaang pag-desynchronize ng kopya, dapat gamitin ang isa sa mga ito sa ganitong kaso Collections.synchronizedMap().

Map copiedMap = Collections.synchronizedMap(Map);

Ang isa pang kawili-wiling paraan upang makopya nang mababaw ay ang paggamit ng clone(). Ngunit HINDI ito inirerekomenda kahit na ng lumikha ng balangkas ng mga koleksyon ng Java, si Joshua Bloch. Sa debateng " Copy Constructor vs. Cloning ", kinuha niya ang posisyon: Quote: "Madalas akong nagbibigay ng pampublikong clone na paraan sa mga kongkretong klase dahil inaasahan ng mga tao na naroroon sila. ... nakakahiya na nasira ang Cloning, ngunit ito nangyari. ... Ang pag-clone ay isang mahinang punto, at sa palagay ko ay dapat bigyan ng babala ang mga tao tungkol sa mga limitasyon nito." Para sa kadahilanang ito, hindi ko man lang ipinapakita sa iyo kung paano gamitin ang paraan clone()upang kopyahin ang Map

8. Gumawa ng walang laman na Mapa

Kung Maphindi nababago, gamitin ang:

Map = Collections.emptyMap();

O, gumamit ng anumang iba pang sagisag. Halimbawa:

Map = new HashMap();

WAKAS