Types génériques
Un type générique est une classe ou une interface générique qui est paramétrée par des types.
Cela permet au compilateur de garantir la sécurité de type sur la classe ou l'interface.
Prenons cette interface Container non générique :
class Container {
private Object object;
public void set(Object object) { this.object = object; }
public Object get() { return object; }
}
Comme elle accepte et renvoie des types Object, elle fonctionne avec n'importe quel type non primitif.
Cependant, cela a un coût, car du code peut appeler get en attendant des Integer alors qu'un autre appelle set en y ajoutant des String, ce qui finit par provoquer une exception à l'exécution.
Une classe générique et une interface générique ont les formats suivants :
class ClassName<T1, T2, ..., Tn> { ... }
interface InterfaceName<T1, T2, ..., Tn> { ... }
La section des paramètres de type, délimitée par des chevrons (<>), qui suit le nom de la classe ou de l'interface, indique les paramètres de type (aussi appelés variables de type) T1, T2, ..., et Tn.
On peut les utiliser dans le corps de la classe ou de l'interface pour obtenir la sécurité de type générique.
Voici la version générique de Container :
class Container<E> {
private E object;
public void set(E object) { this.object = object; }
public E get() { return object; }
}
Lorsqu'on le crée, il faut maintenant déclarer le type qu'il contient, et le compilateur fera respecter cette contrainte :
// 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);
Listes
Les listes sont la collection ordonnée d'éléments en Java.
Contrairement aux tableaux, une List peut grandir en taille pour accueillir n'importe quel nombre d'éléments.
L'une des implémentations standard est ArrayList, qui s'appuie sur un tableau que l'on peut redimensionner.
Une autre implémentation standard est la classe LinkedList, qui s'appuie sur une liste doublement chaînée.
Les Lists peuvent être vides ou contenir un nombre quelconque d'éléments (y compris des doublons).
Les Lists sont une interface générique typée pour indiquer le type d'objets qu'elles peuvent contenir.
Par exemple :
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);
Les Lists disposent de diverses méthodes utiles pour ajouter, supprimer ou récupérer un élément, et pour vérifier sa présence :
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)
Exercice d'apprentissage
