Collections e Generics

1. Collections Framework

Il Collections Framework di Java è una libreria progettata per gestire e manipolare gruppi di oggetti in modo efficiente. Fornisce diverse interfacce e implementazioni che consentono di lavorare con insiemi, liste e mappe.

Interfacce Principali

List

Una collezione ordinata che consente duplicati. Gli elementi sono indicizzati.


import java.util.ArrayList;
import java.util.LinkedList;

public class ListeEsempio {
    public static void main(String[] args) {
        // ArrayList
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("Java");
        arrayList.add("Python");
        arrayList.add("C++");

        System.out.println("ArrayList: " + arrayList);

        // LinkedList
        LinkedList<String> linkedList = new LinkedList<>(arrayList);
        linkedList.addFirst("JavaScript");

        System.out.println("LinkedList: " + linkedList);
    }
}

Set

Una collezione che non consente duplicati.


import java.util.HashSet;
import java.util.TreeSet;

public class SetEsempio {
    public static void main(String[] args) {
        // HashSet
        HashSet<Integer> hashSet = new HashSet<>();
        hashSet.add(10);
        hashSet.add(20);
        hashSet.add(10); // Ignorato, duplicato

        System.out.println("HashSet: " + hashSet);

        // TreeSet
        TreeSet<Integer> treeSet = new TreeSet<>(hashSet);
        treeSet.add(15);

        System.out.println("TreeSet (ordinato): " + treeSet);
    }
}

Map

Una struttura dati per memorizzare coppie chiave-valore.


import java.util.HashMap;
import java.util.TreeMap;

public class MapEsempio {
    public static void main(String[] args) {
        // HashMap
        HashMap<Integer, String> hashMap = new HashMap<>();
        hashMap.put(1, "Uno");
        hashMap.put(2, "Due");
        hashMap.put(3, "Tre");

        System.out.println("HashMap: " + hashMap);

        // TreeMap
        TreeMap<Integer, String> treeMap = new TreeMap<>(hashMap);
        treeMap.put(0, "Zero");

        System.out.println("TreeMap (ordinato): " + treeMap);
    }
}

Iteratori e il Ciclo foreach

Gli iteratori e il ciclo foreach semplificano l'iterazione su collezioni:


import java.util.ArrayList;

public class IteratoreEsempio {
    public static void main(String[] args) {
        ArrayList<String> lista = new ArrayList<>();
        lista.add("Java");
        lista.add("Python");
        lista.add("C++");

        // Iteratore
        for (String linguaggio : lista) {
            System.out.println(linguaggio);
        }
    }
}

2. Generics

I Generics sono una funzionalità che consente di scrivere codice riutilizzabile e sicuro, evitando errori di tipo a runtime. Grazie ai generics, è possibile specificare un tipo per le collezioni e altre strutture dati.

Wildcard

Le wildcard (?) sono utili per lavorare con tipi generici sconosciuti.

? extends

Consente di accettare una classe o sue sottoclassi.


import java.util.ArrayList;

public class WildcardExtends {
    public static void stampaNumeri(ArrayList<? extends Number> lista) {
        for (Number numero : lista) {
            System.out.println(numero);
        }
    }

    public static void main(String[] args) {
        ArrayList<Integer> interi = new ArrayList<>();
        interi.add(10);
        interi.add(20);

        stampaNumeri(interi);
    }
}

? super

Consente di accettare una classe o sue superclassi.


import java.util.ArrayList;

public class WildcardSuper {
    public static void aggiungiNumero(ArrayList<? super Integer> lista) {
        lista.add(10);
        lista.add(20);
    }

    public static void main(String[] args) {
        ArrayList<Number> numeri = new ArrayList<>();
        aggiungiNumero(numeri);

        System.out.println(numeri);
    }
}

Metodi e Classi Generiche

Metodo Generico


public class MetodoGenerico {
    public static <T> void stampaArray(T[] array) {
        for (T elemento : array) {
            System.out.println(elemento);
        }
    }

    public static void main(String[] args) {
        String[] nomi = {"Java", "Python", "C++"};
        stampaArray(nomi);
    }
}

Classe Generica


public class ClasseGenerica<T> {
    private T valore;

    public ClasseGenerica(T valore) {
        this.valore = valore;
    }

    public T getValore() {
        return valore;
    }

    public void setValore(T valore) {
        this.valore = valore;
    }

    public static void main(String[] args) {
        ClasseGenerica<String> esempio = new ClasseGenerica<>("Generics in Java");
        System.out.println(esempio.getValore());
    }
}