Notice: This page requires JavaScript to function properly.
Please enable JavaScript in your browser settings or update your browser.Impara Che cos'è una mappa? | Padronanza Delle Mappe in Java
Strutture Dati Java

bookChe cos'è una mappa?

Discuteremo dell'interfaccia Map in Java. L'interfaccia Map fa parte del framework Java Collections e definisce i metodi per lavorare con dati sotto forma di coppie chiave-valore.

Vediamo la definizione:

La principale implementazione di questa struttura dati in Java è HashMap, che implementa l'interfaccia Map. Esploriamo i metodi principali e i principi di funzionamento di questa implementazione.

Iniziamo con la dichiarazione e i metodi:

Main.java

Main.java

copy

              
1

            
Map<K, V> map = new HashMap<>();

Qui si osserva che nelle generics o parentesi angolari, sono specificati due valori:

  • Il valore K corrisponde al tipo di dato della chiave;
  • Il valore V corrisponde al tipo di dato del valore.

Pertanto, quando si dichiara questa struttura dati, si indicano i tipi di dato delle coppie chiave-valore.

Ora, si esaminano i metodi definiti nell'interfaccia Map.

Metodi

V put(K key, V value): associa il valore specificato alla chiave specificata in questa Map. Se la Map conteneva già una corrispondenza per la chiave, il vecchio valore viene sostituito.

Main.java

Main.java

copy

              
1234567891011121314

            
package com.example;

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println(map);
    }
}

V get(Object key): restituisce il valore a cui la chiave specificata è associata, oppure null se questa Map non contiene alcuna associazione per la chiave.

Qui si specifica la chiave per recuperare il valore corrispondente.

Recupero del valore con chiave 2:

Main.java

Main.java

copy

              
12345678910111213141516

            
package com.example;

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        String value = map.get(2);
        System.out.println("Value: " + value);
    }
}

  • boolean containsKey(Object key): restituisce true se la Map contiene un'associazione per la chiave specificata;

  • boolean containsValue(Object value): restituisce true se la Map contiene una o più chiavi associate al valore specificato.

Questi due metodi sono chiaramente correlati e aiutano a determinare se la Map specificata contiene le chiavi o i valori desiderati. Questi metodi sono utili da utilizzare come condizioni poiché restituiscono valori boolean.

Esempio:

Main.java

Main.java

copy

              
12345678910111213141516171819202122232425

            
package com.example;

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        if (map.containsKey(2)) {
            System.out.println("Value with key 2: " + map.get(2));
        } else {
            System.out.println("There is no value with key 2!");
        }

        if (map.containsValue("Four")) {
            System.out.println(map.get(4));
        } else {
            System.out.println("There is no key with value \"Four\"!");
        }
    }
}

Nell'esempio sopra, viene verificata la presenza di una chiave e la presenza di un valore nel Map. Se i valori vengono trovati, vengono visualizzati sulla console. Se tali valori non sono presenti, vengono mostrate delle notifiche che indicano la mancanza di tali dati.

  • boolean isEmpty(): restituisce true se questa Map non contiene associazioni chiave-valore;

  • V remove(Object key): rimuove l'associazione per la chiave specificata da questa Map, se presente, e restituisce il valore precedente.

Come in altre strutture dati, è possibile rimuovere elementi dalla Map.

Main.java

Main.java

copy

              
12345678910111213141516

            
package com.example;

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        String removedElement = map.remove(3);
        System.out.println("Removed value: " + removedElement + ".\nMap after the removal operation: " + map);
    }
}

Pertanto, è possibile rimuovere elementi tramite chiave.

Metodi di base per la gestione delle Map

Successivamente, sono presenti metodi già noti, che verranno elencati senza esempi. Tuttavia, rimangono anche alcuni metodi interessanti.

Iniziamo dalle basi:

  • void clear(): rimuove tutti gli elementi dalla Map;

  • int size(): restituisce il numero di associazioni chiave-valore presenti in questa Map;

  • void putAll(Map<? extends K, ? extends V> m): copia tutte le associazioni dalla Map specificata a questa Map.

Ora, passiamo ai metodi che restituiscono una collezione con i valori (o le chiavi) della Map. In altre parole, si estrae dalla struttura dati una struttura chiave-valore che memorizza solo valori (o chiavi). Ad esempio, ArrayList<>.

Main.java

Main.java

copy

              
12345678910111213141516

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        Collection<String> list;
        list = map.values();
        System.out.println("Values" + list);
    }
}

Qui, è stata ottenuta una collezione di valori dalla Map. Ora, è possibile trasferire questa collezione in un ArrayList:

Main.java

Main.java

copy

              
123456789101112131415161718

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        Collection<String> collection;
        collection = map.values();
        System.out.println("Values" + collection);
        List<String> arrayList = new ArrayList<>(collection);
        System.out.println("ArrayList: " + arrayList);
    }
}

Abbiamo inizializzato un ArrayList utilizzando i valori provenienti dalla Map.

Esiste anche un metodo che restituisce le chiavi dalla Map. Tuttavia, queste chiavi verranno restituite sotto forma di una struttura chiamata Set. Non approfondiremo ora questa struttura dati; è importante menzionare che un Set è una struttura dati che contiene esclusivamente valori unici.

Vediamo questo metodo:

Set<K> keySet(): restituisce una vista Set delle chiavi contenute in questa Map.

Main.java

Main.java

copy

              
12345678910111213141516

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        Set<Integer> keys;
        keys = map.keySet();
        System.out.println("Keys: " + keys);
    }
}

Pertanto, è anche possibile recuperare un set di tutte le chiavi dal Map.

Bene, sembra che abbiamo terminato con i metodi. Ora diamo un'occhiata all'utilizzo del Map, oltre ad alcuni esempi pratici:

Utilizzo di Map

Una struttura come key-value ha molte applicazioni pratiche. Consideriamo la più semplice di queste strutture: un sistema di valutazione degli studenti.

Creiamo un Map dove la chiave è di tipo String, che rappresenta il nome dello studente, e il valore è di tipo Integer, che rappresenta il voto dello studente. In questo modo, è possibile assegnare voti agli studenti e recuperare facilmente il voto di uno studente specifico utilizzando la chiave:

Main.java

Main.java

copy

              
12345678910111213141516

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);
    }
}

Ora, immaginiamo di dover recuperare i voti di Mike e Alice, e poi confrontarli. Puoi facilmente ottenere questo risultato utilizzando i metodi che hai appreso sopra. Vediamo come implementarlo nel codice:

Main.java

Main.java

copy

              
123456789101112131415161718192021

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);

        Integer mikeGrade = studentsGrades.get("Mike");
        Integer aliceGrade = studentsGrades.get("Alice");

        System.out.println(mikeGrade.compareTo(aliceGrade) == -1 ? "Alice's grade is higher": "Mike's grade is higher");
    }
}

Sono stati utilizzati l'operatore ternario e il metodo compareTo() della classe wrapper Integer. Nel caso in cui non sia chiaro il funzionamento, può essere spiegato come segue:

Main.java

Main.java

copy

              
12345678910111213141516171819202122232425

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);

        Integer mikeGrade = studentsGrades.get("Mike");
        Integer aliceGrade = studentsGrades.get("Alice");

        if (mikeGrade.compareTo(aliceGrade) == -1) {
            System.out.println("Alice's grade is higher");
        } else {
            System.out.println("Mike's grade is higher");
        }
    }
}

Ora, consideriamo il caso in cui ci venga chiesto di raccogliere tutti gli studenti con un voto superiore a 7 (escludendo il 7). Questo diventa interessante, e ora ti spiegherò come farlo!

Iterazione attraverso la Map

L'iterazione sugli elementi in una Map in Java può essere effettuata utilizzando diversi metodi forniti dall'interfaccia Map e dalle sue implementazioni. Ecco diversi modi per iterare su una Map:

Iterazione sulle chiavi (keySet()): il metodo keySet() restituisce un set di tutte le chiavi presenti nella Map. È possibile utilizzare questo set per iterare sulle chiavi e recuperare i valori corrispondenti.

Main.java

Main.java

copy

              
12345678910111213141516

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Key1", 1);
        map.put("Key2", 2);

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

Iterazione sui valori (values()): il metodo values() restituisce una collezione di tutti i valori presenti nella Map. Questa collezione può essere utilizzata per scorrere i valori.

Main.java

Main.java

copy

              
123456789101112131415

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Key1", 1);
        map.put("Key2", 2);

        for (Integer value : map.values()) {
            System.out.println("Value: " + value);
        }
    }
}

Iterazione sulle coppie chiave-valore (entrySet()): il metodo entrySet() restituisce un set di oggetti Map.Entry che rappresentano le coppie chiave-valore. Questo consente di iterare direttamente sulle coppie.

Main.java

Main.java

copy

              
1234567891011121314151617

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Key1", 1);
        map.put("Key2", 2);

        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println("Key: " + key + ", Value: " + value);
        }
    }
}

Approfondiamo ulteriormente questo aspetto. Inizialmente, potrebbe sembrare estremamente complesso da comprendere, ma non è necessario entrare nei dettagli di come funziona, poiché la sintassi è sempre la stessa.

Map.Entry<K, V> entry : map.entrySet()

Utilizzando l'oggetto entry, è possibile accedere contemporaneamente sia alla chiave che al valore nella Map. Ora, risolviamo il compito precedentemente indicato utilizzando l'entry set: recuperare tutti gli studenti con un voto superiore a 7. Per questo, utilizzeremo un controllo tramite entry.getValue(), e quando troveremo studenti idonei, recupereremo le loro chiavi in un ArrayList pre-creato:

Main.java

Main.java

copy

              
1234567891011121314151617181920212223242526

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);
        
        List<String> studentsWithGradeHigherThanSeven = new ArrayList<>();
        
        for (Map.Entry<String, Integer> entry : studentsGrades.entrySet()) {
            if (entry.getValue() > 7) {
                studentsWithGradeHigherThanSeven.add(entry.getKey());
            }
        
        }
        System.out.println(studentsWithGradeHigherThanSeven);
    }
}

Pertanto, è possibile iterare attraverso la Map e trovare l'elenco desiderato di studenti che hanno superato l'esame!

L'entry set è uno strumento molto utile poiché consente vari modi di iterare sulla Map utilizzando un ciclo, avendo accesso sia alla chiave che al valore.

Nel prossimo capitolo, approfondiremo il funzionamento interno di HashMap, che abbiamo utilizzato così attivamente in questo capitolo!

1. Quale interfaccia in Java rappresenta una collezione di coppie chiave-valore?

2. Come si itera su tutte le chiavi in una Map utilizzando un ciclo for-each?

3. Qual è lo scopo del metodo values() in una Map?

4. Quale metodo viene utilizzato per verificare se una chiave specifica è presente in una Map?

5. Quale metodo viene utilizzato per rimuovere una coppia chiave-valore da una Map in Java?

question mark

Quale interfaccia in Java rappresenta una collezione di coppie chiave-valore?

Select the correct answer

question mark

Come si itera su tutte le chiavi in una Map utilizzando un ciclo for-each?

Select the correct answer

question mark

Qual è lo scopo del metodo values() in una Map?

Select the correct answer

question mark

Quale metodo viene utilizzato per verificare se una chiave specifica è presente in una Map?

Select the correct answer

question mark

Quale metodo viene utilizzato per rimuovere una coppia chiave-valore da una Map in Java?

Select the correct answer

Tutto è chiaro?

Come possiamo migliorarlo?

Grazie per i tuoi commenti!

Sezione 3. Capitolo 1

Chieda ad AI

expand

Chieda ad AI

ChatGPT

Chieda pure quello che desidera o provi una delle domande suggerite per iniziare la nostra conversazione

Suggested prompts:

Can you explain more about how HashMap handles collisions?

What are some other implementations of the Map interface besides HashMap?

Can you provide more practical examples of using Map in Java?

bookChe cos'è una mappa?

Scorri per mostrare il menu

Discuteremo dell'interfaccia Map in Java. L'interfaccia Map fa parte del framework Java Collections e definisce i metodi per lavorare con dati sotto forma di coppie chiave-valore.

Vediamo la definizione:

La principale implementazione di questa struttura dati in Java è HashMap, che implementa l'interfaccia Map. Esploriamo i metodi principali e i principi di funzionamento di questa implementazione.

Iniziamo con la dichiarazione e i metodi:

Main.java

Main.java

copy

              
1

            
Map<K, V> map = new HashMap<>();

Qui si osserva che nelle generics o parentesi angolari, sono specificati due valori:

  • Il valore K corrisponde al tipo di dato della chiave;
  • Il valore V corrisponde al tipo di dato del valore.

Pertanto, quando si dichiara questa struttura dati, si indicano i tipi di dato delle coppie chiave-valore.

Ora, si esaminano i metodi definiti nell'interfaccia Map.

Metodi

V put(K key, V value): associa il valore specificato alla chiave specificata in questa Map. Se la Map conteneva già una corrispondenza per la chiave, il vecchio valore viene sostituito.

Main.java

Main.java

copy

              
1234567891011121314

            
package com.example;

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println(map);
    }
}

V get(Object key): restituisce il valore a cui la chiave specificata è associata, oppure null se questa Map non contiene alcuna associazione per la chiave.

Qui si specifica la chiave per recuperare il valore corrispondente.

Recupero del valore con chiave 2:

Main.java

Main.java

copy

              
12345678910111213141516

            
package com.example;

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        String value = map.get(2);
        System.out.println("Value: " + value);
    }
}

  • boolean containsKey(Object key): restituisce true se la Map contiene un'associazione per la chiave specificata;

  • boolean containsValue(Object value): restituisce true se la Map contiene una o più chiavi associate al valore specificato.

Questi due metodi sono chiaramente correlati e aiutano a determinare se la Map specificata contiene le chiavi o i valori desiderati. Questi metodi sono utili da utilizzare come condizioni poiché restituiscono valori boolean.

Esempio:

Main.java

Main.java

copy

              
12345678910111213141516171819202122232425

            
package com.example;

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        if (map.containsKey(2)) {
            System.out.println("Value with key 2: " + map.get(2));
        } else {
            System.out.println("There is no value with key 2!");
        }

        if (map.containsValue("Four")) {
            System.out.println(map.get(4));
        } else {
            System.out.println("There is no key with value \"Four\"!");
        }
    }
}

Nell'esempio sopra, viene verificata la presenza di una chiave e la presenza di un valore nel Map. Se i valori vengono trovati, vengono visualizzati sulla console. Se tali valori non sono presenti, vengono mostrate delle notifiche che indicano la mancanza di tali dati.

  • boolean isEmpty(): restituisce true se questa Map non contiene associazioni chiave-valore;

  • V remove(Object key): rimuove l'associazione per la chiave specificata da questa Map, se presente, e restituisce il valore precedente.

Come in altre strutture dati, è possibile rimuovere elementi dalla Map.

Main.java

Main.java

copy

              
12345678910111213141516

            
package com.example;

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        String removedElement = map.remove(3);
        System.out.println("Removed value: " + removedElement + ".\nMap after the removal operation: " + map);
    }
}

Pertanto, è possibile rimuovere elementi tramite chiave.

Metodi di base per la gestione delle Map

Successivamente, sono presenti metodi già noti, che verranno elencati senza esempi. Tuttavia, rimangono anche alcuni metodi interessanti.

Iniziamo dalle basi:

  • void clear(): rimuove tutti gli elementi dalla Map;

  • int size(): restituisce il numero di associazioni chiave-valore presenti in questa Map;

  • void putAll(Map<? extends K, ? extends V> m): copia tutte le associazioni dalla Map specificata a questa Map.

Ora, passiamo ai metodi che restituiscono una collezione con i valori (o le chiavi) della Map. In altre parole, si estrae dalla struttura dati una struttura chiave-valore che memorizza solo valori (o chiavi). Ad esempio, ArrayList<>.

Main.java

Main.java

copy

              
12345678910111213141516

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        Collection<String> list;
        list = map.values();
        System.out.println("Values" + list);
    }
}

Qui, è stata ottenuta una collezione di valori dalla Map. Ora, è possibile trasferire questa collezione in un ArrayList:

Main.java

Main.java

copy

              
123456789101112131415161718

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        Collection<String> collection;
        collection = map.values();
        System.out.println("Values" + collection);
        List<String> arrayList = new ArrayList<>(collection);
        System.out.println("ArrayList: " + arrayList);
    }
}

Abbiamo inizializzato un ArrayList utilizzando i valori provenienti dalla Map.

Esiste anche un metodo che restituisce le chiavi dalla Map. Tuttavia, queste chiavi verranno restituite sotto forma di una struttura chiamata Set. Non approfondiremo ora questa struttura dati; è importante menzionare che un Set è una struttura dati che contiene esclusivamente valori unici.

Vediamo questo metodo:

Set<K> keySet(): restituisce una vista Set delle chiavi contenute in questa Map.

Main.java

Main.java

copy

              
12345678910111213141516

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        Set<Integer> keys;
        keys = map.keySet();
        System.out.println("Keys: " + keys);
    }
}

Pertanto, è anche possibile recuperare un set di tutte le chiavi dal Map.

Bene, sembra che abbiamo terminato con i metodi. Ora diamo un'occhiata all'utilizzo del Map, oltre ad alcuni esempi pratici:

Utilizzo di Map

Una struttura come key-value ha molte applicazioni pratiche. Consideriamo la più semplice di queste strutture: un sistema di valutazione degli studenti.

Creiamo un Map dove la chiave è di tipo String, che rappresenta il nome dello studente, e il valore è di tipo Integer, che rappresenta il voto dello studente. In questo modo, è possibile assegnare voti agli studenti e recuperare facilmente il voto di uno studente specifico utilizzando la chiave:

Main.java

Main.java

copy

              
12345678910111213141516

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);
    }
}

Ora, immaginiamo di dover recuperare i voti di Mike e Alice, e poi confrontarli. Puoi facilmente ottenere questo risultato utilizzando i metodi che hai appreso sopra. Vediamo come implementarlo nel codice:

Main.java

Main.java

copy

              
123456789101112131415161718192021

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);

        Integer mikeGrade = studentsGrades.get("Mike");
        Integer aliceGrade = studentsGrades.get("Alice");

        System.out.println(mikeGrade.compareTo(aliceGrade) == -1 ? "Alice's grade is higher": "Mike's grade is higher");
    }
}

Sono stati utilizzati l'operatore ternario e il metodo compareTo() della classe wrapper Integer. Nel caso in cui non sia chiaro il funzionamento, può essere spiegato come segue:

Main.java

Main.java

copy

              
12345678910111213141516171819202122232425

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);

        Integer mikeGrade = studentsGrades.get("Mike");
        Integer aliceGrade = studentsGrades.get("Alice");

        if (mikeGrade.compareTo(aliceGrade) == -1) {
            System.out.println("Alice's grade is higher");
        } else {
            System.out.println("Mike's grade is higher");
        }
    }
}

Ora, consideriamo il caso in cui ci venga chiesto di raccogliere tutti gli studenti con un voto superiore a 7 (escludendo il 7). Questo diventa interessante, e ora ti spiegherò come farlo!

Iterazione attraverso la Map

L'iterazione sugli elementi in una Map in Java può essere effettuata utilizzando diversi metodi forniti dall'interfaccia Map e dalle sue implementazioni. Ecco diversi modi per iterare su una Map:

Iterazione sulle chiavi (keySet()): il metodo keySet() restituisce un set di tutte le chiavi presenti nella Map. È possibile utilizzare questo set per iterare sulle chiavi e recuperare i valori corrispondenti.

Main.java

Main.java

copy

              
12345678910111213141516

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Key1", 1);
        map.put("Key2", 2);

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

Iterazione sui valori (values()): il metodo values() restituisce una collezione di tutti i valori presenti nella Map. Questa collezione può essere utilizzata per scorrere i valori.

Main.java

Main.java

copy

              
123456789101112131415

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Key1", 1);
        map.put("Key2", 2);

        for (Integer value : map.values()) {
            System.out.println("Value: " + value);
        }
    }
}

Iterazione sulle coppie chiave-valore (entrySet()): il metodo entrySet() restituisce un set di oggetti Map.Entry che rappresentano le coppie chiave-valore. Questo consente di iterare direttamente sulle coppie.

Main.java

Main.java

copy

              
1234567891011121314151617

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Key1", 1);
        map.put("Key2", 2);

        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println("Key: " + key + ", Value: " + value);
        }
    }
}

Approfondiamo ulteriormente questo aspetto. Inizialmente, potrebbe sembrare estremamente complesso da comprendere, ma non è necessario entrare nei dettagli di come funziona, poiché la sintassi è sempre la stessa.

Map.Entry<K, V> entry : map.entrySet()

Utilizzando l'oggetto entry, è possibile accedere contemporaneamente sia alla chiave che al valore nella Map. Ora, risolviamo il compito precedentemente indicato utilizzando l'entry set: recuperare tutti gli studenti con un voto superiore a 7. Per questo, utilizzeremo un controllo tramite entry.getValue(), e quando troveremo studenti idonei, recupereremo le loro chiavi in un ArrayList pre-creato:

Main.java

Main.java

copy

              
1234567891011121314151617181920212223242526

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);
        
        List<String> studentsWithGradeHigherThanSeven = new ArrayList<>();
        
        for (Map.Entry<String, Integer> entry : studentsGrades.entrySet()) {
            if (entry.getValue() > 7) {
                studentsWithGradeHigherThanSeven.add(entry.getKey());
            }
        
        }
        System.out.println(studentsWithGradeHigherThanSeven);
    }
}

Pertanto, è possibile iterare attraverso la Map e trovare l'elenco desiderato di studenti che hanno superato l'esame!

L'entry set è uno strumento molto utile poiché consente vari modi di iterare sulla Map utilizzando un ciclo, avendo accesso sia alla chiave che al valore.

Nel prossimo capitolo, approfondiremo il funzionamento interno di HashMap, che abbiamo utilizzato così attivamente in questo capitolo!

1. Quale interfaccia in Java rappresenta una collezione di coppie chiave-valore?

2. Come si itera su tutte le chiavi in una Map utilizzando un ciclo for-each?

3. Qual è lo scopo del metodo values() in una Map?

4. Quale metodo viene utilizzato per verificare se una chiave specifica è presente in una Map?

5. Quale metodo viene utilizzato per rimuovere una coppia chiave-valore da una Map in Java?

question mark

Quale interfaccia in Java rappresenta una collezione di coppie chiave-valore?

Select the correct answer

question mark

Come si itera su tutte le chiavi in una Map utilizzando un ciclo for-each?

Select the correct answer

question mark

Qual è lo scopo del metodo values() in una Map?

Select the correct answer

question mark

Quale metodo viene utilizzato per verificare se una chiave specifica è presente in una Map?

Select the correct answer

question mark

Quale metodo viene utilizzato per rimuovere una coppia chiave-valore da una Map in Java?

Select the correct answer

Tutto è chiaro?

Come possiamo migliorarlo?

Grazie per i tuoi commenti!

Sezione 3. Capitolo 1
some-alt