LE COLLECTION IN JAVA

Prima di parlare di collection parliamo di liste.

LE LISTE IN JAVA

Una lista è un elenco di oggetti.

Alcuni esempi di liste:

I programmi televisivi del giorno
Gli articoli presenti in un carrello elettronico
Le auto che attraversano il casello autostradale
Gli alunni di una classe universitaria
Le città di una nazione
Gli articoli di una costituzione
La lista della spesa

Esistono due tipi di liste:

Liste statiche

Hanno una lunghezza predefinita che non cambia nel tempo.

Liste dinamiche

Hanno una lunghezza ignota che può cambiare nel tempo.

Per gestire le liste, Java mette a disposizione due tipi di strutture dati:

Array: consentono di gestire le liste statiche

Collection: consentono di gestire le liste dinamiche

Degli Array ci siamo già occupati, in questo post vedremo le Collection.

COSA SONO LE MAPPE

Una mappa è una collezione di oggetti identificati da una chiave univoca. Lo scopo principale delle mappe è quello di gestire in maniera efficiente e veloce una serie di elementi.

Per gestire le mappe, Java mette a disposizione, una serie strumenti che consentono di gestire liste di oggetti dinamiche e non ordinate. Le map sono composte da:

• interfacce che definiscono i metodi utili per la manipolazione delle collezioni di oggetti
• classi implementano le interfacce

Le classi ed interfacce fanno parte del package java.util. Tra i metodi per la manipolazione delle mappe di oggetti troviamo quelli che consentono la ricerca rapida di elementi all’interno della mappa. L’interfaccia Map definisce tutti i metodi che devono essere implementati per la corretta gestione delle mappe. Le classi principali che implementano l’interfaccia Map sono:
HashMap – Hashtable – Properties – TreeMap

Quando lavoriamo con le liste (un elenco di contatti, un elenco di prodotti, etc.), capita spesso di non conoscere a priori il numero di elementi su cui lavorare. Per lavorare con le liste abbiamo a disposizione gli array. Tuttavia, se non conosciamo il numero di elementi, non possiamo inizializzare un array. Oltretutto gli array non possono cambiare la propria dimensione: il numero di elementi contenuti viene stabilito al momento dell’inizializzazione e rimane immutato. Per andare oltre questa limitazione degli array, Java mette a disposizione le collection, una serie strumenti che consentono di gestire liste di oggetti di
lunghezza variabile. Le collection sono composte da:

• interfacce che definiscono i metodi utili per la manipolazione delle collezioni di oggetti
• classi implementano le interfacce

Le classi ed interfacce collection fanno parte del package java.util. Tra i metodi per la manipolazione delle collezioni di oggetti troviamo ad esempio:

• metodi per la ricerca di elementi all’interno della collection
• metodi per l’ordinamento degli elementi all’interno della collection

LA CLASSE ARRAYLIST

La classe ArrayList è un array ridimensionabile, situato nel pacchetto java.util. La differenza tra un array e un ArrayList in Java è che la dimensione di un array non può essere modificata (se si desidera aggiungere o rimuovere elementi a/da un array, è necessario crearne uno nuovo). Mentre gli elementi possono essere aggiunti e rimossi da un ArrayList ogni volta che vuoi. Anche la sintassi è leggermente diversa. La classe ArrayList è l’implementazione dell’interfaccia List.

Costruttori

• ArrayList<E>() crea un’istanza della classe ArrayList vuota in cui non è specificata la capacità iniziale
• ArrayList<E>(int initialCapacity) crea un’istanza della classe ArrayList in cui è specificata la capacità iniziale
Il simbolo <E> indica che quando si crea una lista è possibile specificare anche il tipo di elementi che dovrà contenere.

Metodi

• Object get(int index) restituisce l’elemento che si trova alla posizione richiesta

• Object set(int index, Object obj) sostituisce l’elemento presente nella posizione specificata da index con il nuovo elemento rappresentato da obj

• boolean add(Object obj) aggiunge l’elemento rappresentato da obj dopo l’ultimo elemento. Il metodo restituisce sempre true.

• void add(int index, Object obj) inserisce l’elemento rappresentato da obj nella posizione specificata da index e sposta tutti gli altri elementi che si trovano dalla posizione index in poi, facendoli avanzare di una posizione.

• int size() restituisce il numero di elementi presenti nella lista

Object remove(int index) rimuove l’elemento presente nella posizione specificata da index e sposta tutti gli altri elementi che si trovano dopo quello rimosso, facendoli arretrare di una posizione

• int indexOf(Object elem) restituisce la prima posizione nella lista dell’elemento elem, -1 se l’elemento non esiste

• String toString() restituisce una stringa contenente l’elenco degli elementi presenti nella lista

• void clear() elimina tutti gli elementi presenti nella lista, svuotandola completamente

• T[] toArray(T[] a) restituisce un array contenente tutti gli elementi della Lista

• boolean isEmpty() restituisce true se la lista è vuota, false se la lista contiene almeno un elemento

package it.corso.java.liste;
import java.util.*;

public class MyArrayList {

    public static void myTestMethodArrayList(){
        ArrayList<String> cars = new ArrayList<String>();
        cars.add("Volvo");
        cars.add("BMW");
        cars.add("Ford");
        cars.add("Mazda");
        System.out.println(cars);
        String ele = cars.get(0);
        System.out.println(ele);
        cars.set(0,"Fiat");
        //ITERAZIONE CON UN CICLO FOR
        for(String s : cars)
            System.out.println(s);
        System.out.println("La dimensione di cars é: " + cars.size());
        int posizione = cars.indexOf("Mazda");
        System.out.println(posizione);
        //ITERAZIONE CON L'INTERFACCIA ITERATOR
        Iterator<String> iterator = cars.iterator();
        while(iterator.hasNext())
            System.out.println(iterator.next());
    }
}

LA CLASSE LINKEDLIST

La classe LinkedList è una collezione che può contenere molti oggetti dello stesso tipo, proprio come ArrayList. La classe LinkedList ha tutti gli stessi metodi della classe ArrayList perché entrambi implementano l’interfaccia List. Ciò significa che puoi aggiungere elementi, modificare elementi, rimuovere elementi e cancellare l’elenco allo stesso modo. Tuttavia, la classe ArrayList e la classe LinkedList sono costruite in modo molto diverso.

COME FUNZIONA LA CLASSE ARRAYLIST

La classe ArrayList ha un array regolare al suo interno. Quando un elemento viene aggiunto, viene inserito nell’array. Se l’array non è abbastanza grande, viene creato un nuovo array più grande per sostituire quello vecchio e quello vecchio viene rimosso.

COME FUNZIONA LA CLASSE LINKEDLIST

Il LinkedList memorizza i suoi elementi in “contenitori”. L’elenco ha un collegamento al primo contenitore e ogni contenitore ha un collegamento al contenitore successivo e precedente. Per aggiungere un elemento all’elenco, l’elemento viene inserito in un nuovo contenitore e tale contenitore viene collegato a uno degli altri contenitori nell’elenco.

In molti casi, ArrayList è più efficiente in quanto è comune avere bisogno di accedere a elementi casuali nell’elenco, ma LinkedList fornisce diversi metodi per eseguire determinate operazioni in modo molto veloce: La figura illustra questi metodi.

LA CLASSE HASHMAP

Una HashMap memorizza gli elementi in coppie “chiave/valore” e puoi accedervi tramite un indice di un altro tipo (ad esempio una stringa). Un oggetto viene utilizzato come chiave (indice) per un altro oggetto (valore). Può memorizzare diversi tipi: chiavi stringa e valori interi, o lo stesso tipo, come: chiavi stringa e valori stringa. Chiavi e valori in una HashMap sono in realtà oggetti. Per utilizzare altri tipi, come int, è necessario specificare una classe Wrapper equivalente: Integer. Per altri tipi primitivi, usa: Boolean per boolean, Character per char, Double per double, ecc. La classe HashMap è un’implementazione dell’interfaccia Map.

Costruttori principali

HashMap<K,V>() crea un’istanza della classe HashMap vuota in cui non è specificata la capacità iniziale
HashMap<K,V>(int initialCapacity) crea un’istanza della classe HashMap in cui è specificata la capacità iniziale

Il simbolo <K,V> indica che quando si crea una mappa è possibile specificare anche il tipo di elemento che dovranno contenere la chiave (K) ed il valore (V).

Metodi

Object get (Object key) restituisce l’elemento associato alla chiave key
Object put(Object key, Object value) aggiunge l’elemento value alla mappa associandolo alla chiave key. Se la mappa contiene già la chiave key, il vecchio elemento viene sostituito con il nuovo. Il metodo ritorna null se la chiave non è presente, oppure il precedente oggetto associato a key

Object remove(Object key) rimuove l’elemento associato a key. Il metodo ritorna l’elemento che era associato a key prima della rimozione
int size() restituisce il numero di elementi presenti nella mappa
boolean containsKey(Object key) restituisce true se la mappa contiene un elemento associato alla chiave cercata, false altrimenti
void clear() elimina tutti gli elementi presenti nella mappa, svuotandola completamente
Set<Object> keySet() restituisce un oggetto di tipo Set contenente tutte le chiavi presenti nella mappa
boolean isEmpty() restituisce true se la mappa è vuota, false se la mappa contiene almeno un elemento

package it.corso.java.liste;
import java.util.Arrays;
import java.util.HashMap;

public class MyHashMap {

    public static void myTestMethodHashMap() {
        // Create a HashMap object called capitalCities
        HashMap<String, String> capitalCities = new HashMap<String, String>();

        // Add keys and values (Country, City)
        capitalCities.put("England", "London");
        capitalCities.put("Germany", "Berlin");
        capitalCities.put("Norway", "Oslo");
        capitalCities.put("USA", "Washington DC");
        System.out.println(capitalCities);
        System.out.println(capitalCities.get("England"));
        // Print keys
        for (String i : capitalCities.keySet()) {
            System.out.println(i);

        }
        // Print values
        for (String i : capitalCities.values()) {
            System.out.println(i);
        }
        // Print keys and values
        for (String i : capitalCities.keySet()) {
            System.out.println("key: " + i + " value: " + capitalCities.get(i));
        }
        HashMap<String, Integer> people = new HashMap<String, Integer>();


        // Add keys and values (Name, Age)
        people.put("John", 32);
        people.put("Steve", 30);
        people.put("Angie", 33);

        for (String i : people.keySet()) {
            System.out.println("key: " + i + " value: " + people.get(i));
        }
    }
}

HASHSET

Un HashSet è una raccolta di elementi in cui ogni elemento è unico e si trova nel pacchetto java.util:

JAVA ITERATOR

Un Iterator è un oggetto che può essere utilizzato per scorrere raccolte, come ArrayList e HashSet. Si chiama “iteratore” perché “iterare” è il termine tecnico per il ciclo.

L’interfaccia Iterator<E> si trova nel package java.util ed è un’interfaccia che consente di generare classi per l’iterazione degli elementi di una Collection.

L’interfaccia definisce 3 metodi:

hasNext() ritorna true fino a quando ci sono elementi della lista da scorrere
next() ritorna l’elemento successivo
remove() rimuove dalla lista l’ultimo elemento ritornato.

Il metodo remove() deve essere usato solo durante un ciclo sugli elementi, altrimenti Java genera l’eccezione ConcurrentModificationException quando accediamo al successivo accesso alla lista. Le interfacce Collection, List, Set e le relative classi che le implementano (ad esempio ArrayList) contengono il metodo iterator() che ritorna un oggetto di tipo Iterator<E>. Attraverso il metodo iterator() è possibile ciclare tutti gli elementi di una lista.

LINK AI POST PRECEDENTI

IL LINGUAGGIO JAVA

LINK AL CODICE SU GITHUB

GITHUB

ESECUZIONE DEL CODICE DI ESEMPIO

Scaricare il codice da GITHUB, lanciare il file JAR con il seguente comando in Visual Studio Code, posizionandosi nella directory contenente il JAR.

java -jar –enable-preview CorsoJava.jar

Oppure mettere in esecuzione il main che si trova nel file CorsoJava.java.