Genéricos en Java: ejemplo ejecutable

Sin genéricos, una lista puede contener cualquier objeto y el compilador solo sabe que lo que recuperas es un Object, así que necesitas un cast explícito que ensucia el código y puede fallar en tiempo de ejecución. Los genéricos permiten expresar que usarás un tipo concreto y dejan que el compilador garantice que es correcto. Al declarar List<Integer>, el ejemplo lee el primer elemento sin ningún cast.

Los métodos genéricos se escriben con una única declaración y se pueden llamar con argumentos de distintos tipos. Llevan un parámetro de tipo, como <T>, antes del tipo de retorno, y pueden tener varios, como <T, G>. En el ejemplo, arrayALista convierte un array en una lista, y una segunda versión recibe además una función que transforma cada elemento de tipo T en uno de tipo G.

Los parámetros de tipo pueden acotarse, y los comodines (?) representan un tipo desconocido. Una colección de Object no es el supertipo de cualquier colección: List<Object> no es el supertipo de List<String>. Para aceptar un tipo y todos sus subtipos se usa un comodín de límite superior, como List<? extends Number>, que es lo que hace el método sumar del ejemplo para aceptar listas de enteros y de decimales.

Ejecuta el programa y prueba a llamar a sumar con una List<String>: el compilador lo rechazará, que es precisamente la garantía que dan los genéricos.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Function;

public class Main {
  static <T> List<T> arrayALista(T[] a) {
    return new ArrayList<>(Arrays.asList(a));
  }

  static <T, G> List<G> arrayALista(T[] a, Function<T, G> mapper) {
    return Arrays.stream(a).map(mapper).toList();
  }

  static double sumar(List<? extends Number> numeros) {
    double total = 0;
    for (Number n : numeros) {
      total += n.doubleValue();
    }
    return total;
  }

  public static void main(String[] args) {
    List<Integer> lista = new ArrayList<>();
    lista.add(1);
    Integer i = lista.iterator().next(); // sin cast: el compilador conoce el tipo
    System.out.println("Primer elemento: " + i);

    System.out.println(arrayALista(new String[] {"a", "b"}));
    System.out.println(arrayALista(new String[] {"1", "2"}, Integer::parseInt));
    System.out.println("Suma: " + sumar(List.of(1, 2, 3)));
    System.out.println("Suma decimales: " + sumar(List.of(1.5, 2.5)));
  }
}
Ejecutar en el playground