Risposte alle domande più frequenti sull'interfaccia della mappa

Ciao! Oggi daremo le risposte alle domande più comuni su Map, ma prima ricordiamo di cosa si tratta. Una mappa è una struttura dati che contiene un insieme di coppie chiave-valore. La sua struttura dati ricorda un dizionario, motivo per cui viene spesso chiamato così. Allo stesso tempo Map è un'interfaccia e nello standard jdk contiene le principali implementazioni: Hashmap, LinkedHashMap, Hashtable, TreeMap. L'implementazione più utilizzata è Hashmap, quindi la useremo nei nostri esempi. Ecco come appaiono la creazione e il riempimento standard di una mappa:

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

Ed ecco come ottenere i valori per chiave:

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

Se tutto quanto sopra è chiaro, procediamo con le nostre risposte alle domande più frequenti!

0. Come scorrere tutti i valori della mappa

L'iterazione sui valori è l'operazione più comune eseguita con le mappe. Tutte le coppie chiave-valore vengono archiviate nell'interfaccia interna Map.Entry e per ottenerle è necessario chiamare il file entrySet(). Restituisce un insieme di coppie che possono essere ripetute in loop:

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. Come convertire la mappa in elenco

L'interfaccia Map ha 3 metodi che restituiscono un elenco di elementi:

• keySet() - restituisce un set di chiavi;
• valori() - restituisce una raccolta di valori;
• entrySet() - restituisce un insieme di insiemi di valori-chiave.

Se guardi i costruttori della classe ArrayList, noterai che esiste un costruttore con un argomento di tipo Collection. Poiché Set è un discendente di Collection, i risultati di tutti i metodi sopra indicati possono essere passati al costruttore della classe ArrayList. Quindi creeremo nuove liste e le riempiremo con valori da 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. Come ordinare le chiavi della mappa

Anche l'ordinamento delle mappe è un'operazione abbastanza comune nella programmazione. Puoi farlo in diversi modi:

1. Inserisci Map.Entry in un elenco e ordinalo utilizzando Comparator .

   Nel comparatore confronteremo solo le chiavi delle coppie:

   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();
      }
   });
   

   Se comprendi lambda, questa voce può essere notevolmente abbreviata:

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

2. Utilizzare SortedMap, o più precisamente, la sua implementazione TreeMap, che accetta un Comparator nel suo costruttore. Questo comparatore verrà applicato alle chiavi della mappa, quindi le chiavi devono essere classi che implementano l'interfaccia Comparable:

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

   E, naturalmente, tutto può essere riscritto utilizzando lambda:

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

   A differenza del primo metodo, utilizzando SortedMap, memorizzeremo sempre i dati in forma ordinata.

3. Come ordinare i valori della mappa

Qui dovresti utilizzare un approccio simile al primo per le chiavi: ottieni un elenco di valori e ordinali nell'elenco:

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());
   }
});

E il lambda per questo assomiglia a questo:

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

4. Qual è la differenza tra HashMap, TreeMap e Hashtable

Come accennato in precedenza, esistono 3 implementazioni principali dell'interfaccia Mappa. Ognuno di essi ha le sue caratteristiche:

1. Ordine degli elementi. HashMape Hashtablenon garantiscono che gli articoli verranno archiviati nell'ordine in cui sono stati aggiunti. Inoltre, non garantiscono che l’ordine degli elementi non cambierà nel tempo. A sua volta, TreeMapgarantisce la memorizzazione degli elementi nell'ordine in cui sono stati aggiunti o secondo un determinato comparatore.

2. Valori validi. HashMapti permette di avere una chiave e un valore nullo, HashTableno. TreeMap può utilizzare valori nulli solo se il comparatore lo consente. Senza utilizzare un comparatore (memorizzando le coppie nell'ordine in cui sono state aggiunte), non è consentito il valore null.

3. Sincronizzazione. Solo HashTablesincronizzato, il resto no. Se non sarà possibile accedere alla mappa da thread diversi, si consiglia di utilizzare HashMap anziché HashTable.

E un confronto generale delle implementazioni:

5. Come creare una mappa bidirezionale

A volte diventa necessario utilizzare una struttura dati in cui sia le chiavi che i valori saranno univoci, ovvero la mappa conterrà coppie chiave-chiave. Questa struttura dati consente di creare una “vista/ricerca invertita” sulla mappa. Cioè possiamo trovare una chiave in base al suo valore. Questa struttura dati è chiamata mappa bidirezionale, che purtroppo non è supportata dal JDK. Ma, fortunatamente, la sua implementazione può essere trovata nelle raccolte Apache Common o nelle librerie Guava. Lì si chiama rispettivamente BidiMap e BiMap. Queste implementazioni impongono restrizioni sull'unicità di chiavi e valori. Questo crea una relazione uno a uno.

6. Come creare una mappa vuota

Esistono due modi per creare una mappa vuota:

1. Inizializzazione normale dell'oggetto:

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

2. Creazione di una mappa vuota immutabile:

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

Quando proviamo ad aggiungere dati a tale mappa, riceveremo: UnsupportedOperationExceptioneccezione. In questo articolo abbiamo esaminato le domande più comuni che potresti avere quando utilizzi l'interfaccia della mappa.