Tipi generici
Un tipo generico è una classe o un'interfaccia generica parametrizzata su dei tipi.
Questo permette al compilatore di imporre la sicurezza dei tipi sulla classe o sull'interfaccia.
Considera questa interfaccia Container non generica:
class Container {
private Object object;
public void set(Object object) { this.object = object; }
public Object get() { return object; }
}
Poiché accetta e restituisce tipi Object, funziona con qualsiasi tipo non primitivo.
Tuttavia questo ha un costo, perché del codice potrebbe chiamare get aspettandosi degli Integer mentre altro codice chiama set aggiungendo delle String, cosa che produce un'eccezione a runtime.
Una classe generica e un'interfaccia generica hanno il formato seguente:
class ClassName<T1, T2, ..., Tn> { ... }
interface InterfaceName<T1, T2, ..., Tn> { ... }
La sezione dei parametri di tipo, delimitata dalle parentesi angolari (<>) che seguono il nome della classe o dell'interfaccia, specifica i parametri di tipo (detti anche variabili di tipo) T1, T2, ..., e Tn.
Questi possono essere usati all'interno del corpo della classe o dell'interfaccia per ottenere la sicurezza dei tipi generici.
Ecco la versione generica di Container:
class Container<E> {
private E object;
public void set(E object) { this.object = object; }
public E get() { return object; }
}
Quando la creiamo, dobbiamo dichiarare quale tipo contiene e il compilatore imporrà quel vincolo:
// empty <> can infer from context
Container<String> stringContainer = new Container<>();
// compiler knows this is a String, so it is allowed
stringContainer.set("Some string");
// no cast needed, compiler knows it is a String
String result = stringContainer.get();
// this causes a compiler error:
stringContainer.set(42);
Liste
In Java, le liste sono la collezione che rappresenta una sequenza ordinata.
A differenza degli array, una List può crescere in dimensione per contenere qualsiasi numero di elementi.
Una delle implementazioni standard è ArrayList, che si basa su un array ridimensionabile.
Un'altra implementazione standard è la classe LinkedList, che si basa su una lista doppiamente concatenata.
Le List possono essere vuote o contenere qualsiasi numero di elementi (duplicati inclusi).
Le List sono un'interfaccia generica tipizzata per indicare quale tipo di oggetti possono contenere.
Ad esempio:
List<String> emptyListOfStrings = List.of();
List<Integer> singleInteger = List.of(1);
List<Boolean> threeBooleans = List.of(true, false, true);
List<Object> listWithMultipleTypes = List.of("hello", 1, true);
Le List hanno vari metodi utili per aggiungere, rimuovere e ottenere elementi, e per verificare la presenza di un elemento:
List<Character> vowels = new ArrayList<>(List.of('a', 'e', 'i', 'o', 'i', 'e', 'a'));
int startingSize = vowels.size(); // 7
vowels.add('u'); // vowels is now ['a', 'e', 'i', 'o', 'i', 'e', 'a', 'u']
char a = vowels.get(0); // 'a'
boolean hadI = vowels.remove('i'); // true and vowels is now ['a', 'e', 'o', 'i', 'e', 'a', 'u']
boolean hasI = vowels.contains('i'); // true (still have one more left)
Esercizio di apprendimento
