Tipos genéricos
Un tipo genérico es una clase o interfaz genérica que está parametrizada sobre tipos.
Esto permite que el compilador garantice la seguridad de tipos en la clase o interfaz.
Considera esta interfaz Container, que no es genérica:
class Container {
private Object object;
public void set(Object object) { this.object = object; }
public Object get() { return object; }
}
Como acepta y devuelve tipos Object, funciona con cualquier tipo no primitivo.
Sin embargo, esto tiene un costo, porque es posible que parte del código llame a get esperando Integers, mientras que otra parte llama a set agregando Strings, lo que produce una excepción en tiempo de ejecución.
Una clase genérica y una interfaz genérica tienen los siguientes formatos:
class ClassName<T1, T2, ..., Tn> { ... }
interface InterfaceName<T1, T2, ..., Tn> { ... }
La sección de parámetros de tipo, delimitada por paréntesis angulares (<>), que sigue al nombre de la clase o interfaz, especifica los parámetros de tipo (también llamados variables de tipo) T1, T2, ..., y Tn.
Estos se pueden usar dentro del cuerpo de la clase o de la interfaz para obtener seguridad de tipos genéricos.
Aquí está la versión genérica de Container:
class Container<E> {
private E object;
public void set(E object) { this.object = object; }
public E get() { return object; }
}
Cuando lo creamos, tenemos que declarar qué tipo contiene y el compilador hará cumplir esa restricción:
// 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);
Listas
Las listas son la colección de secuencia ordenada en Java.
A diferencia de los arrays, una List puede crecer en tamaño para admitir cualquier cantidad de elementos.
Una implementación estándar es ArrayList, que se basa en un array redimensionable.
Otra implementación estándar es la clase LinkedList, que se basa en una lista doblemente enlazada.
Las List pueden estar vacías o contener cualquier cantidad de elementos (incluidos los duplicados).
Las List son una interfaz genérica parametrizada para indicar qué tipo de objetos pueden contener.
Por ejemplo:
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);
Las List tienen varios métodos útiles para agregar, eliminar, obtener y comprobar si un elemento está presente:
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)
Ejercicio de aprendizaje
