Genéricos, expresiones lambda y flujos en Java

Un contenedor debe indicar qué contiene. Con un parámetro de tipo, una misma clase puede contener cadenas, números u objetos propios, y el compilador comprueba cada uso antes de que se ejecute el programa.

Da un parámetro de tipo a una clase

En class Box<T>, T es un parámetro de tipo: un nombre para un tipo que proporcionará quien utilice la clase. Úsalo para campos, parámetros de métodos y resultados.

class Box<T> {
    private T value;

    public Box(T value) { this.value = value; }
    public T get() { return value; }
    public void set(T value) { this.value = value; }
}

El nombre del constructor es Box, sin <T>. La declaración después del nombre de la clase introduce T para el cuerpo de la clase. Ahora crea una caja:

Box<String> b = new Box<>("tea");
String drink = b.get();
b.set("water");
System.out.println(drink);   // tea
System.out.println(b.get()); // water

String es el argumento de tipo. Para esta variable, get() devuelve un String y set acepta un String. No hay conversión explícita de tipo al leer. El intento de llamar a b.set(42) falla en la compilación: «tipos incompatibles: int no se puede convertir a String». El error señala la escritura incorrecta antes de que una lectura posterior pueda fallar.

¿Por qué no almacenar Object?

Un campo Object puede hacer referencia tanto a una cadena como a un entero. El código que necesita una cadena debe convertir explícitamente el tipo del objeto devuelto. Si se almacenó un entero, esa conversión lanza ClassCastException mientras se ejecuta el programa. Un Box<String> incorpora la relación deseada al tipo declarado.

El diamante <> en new Box<>("tea") pide al compilador que infiera los argumentos de tipo. Conserva las comprobaciones. Omitir por completo los corchetes angulares, como en new Box("tea"), utiliza un tipo sin parametrizar y pierde las comprobaciones relacionadas con el parámetro de tipo. Asignar una construcción sin parametrizar a una variable tipada produce advertencias de operación no comprobada; la variable tipada sigue haciendo cumplir su propio argumento declarado en llamadas posteriores.

Utiliza clases envoltorio y varios parámetros

Un argumento de tipo debe ser un tipo de referencia. Utiliza Box<Integer>, no Box<int>. Java empaqueta el literal 5 como un Integer al construir new Box<Integer>(5) y lo desempaqueta cuando la aritmética necesita un int. Si n contiene esa caja, int next = n.get() + 1; da 6.

Dos tipos independientes necesitan dos parámetros. Un Pair<K, V> puede tener un campo K first y un campo V second. Para un Pair<String, Integer>, sus métodos de acceso devuelven un String y un Integer. Los nombres habituales son T para un tipo, E para un elemento, K y V para una clave y un valor, y R para un resultado.

Pon parámetros de tipo en las interfaces

interface Container<T> {
    void put(T item);
    T take();
}

Una clase puede conservar la elección con class Shelf<T> implements Container<T>, o fijarla con class NameList implements Container<String>. List<E> y Comparable<T> utilizan la misma idea. Una clase genérica sigue siendo una sola clase: Box<String> y Box<Integer> describen usos distintos en tiempo de compilación, no dos declaraciones de clase. No pueden asignarse entre sí porque sus promesas sobre el tipo de elemento son distintas.

Algunas operaciones necesitan elegir un tipo para una llamada, no para todo el tiempo de vida de un objeto. Un método genérico introduce su propio parámetro de tipo y mantiene una relación entre su entrada y su resultado.

Declara el tipo antes del tipo de retorno

import java.util.List;

class Lists {
    public static <T> T last(List<T> list) {
        return list.get(list.size() - 1);
    }

    public static void main(String[] args) {
        int number = last(List.of(4, 8, 15));
        String word = Lists.<String>last(List.of("x", "y"));
        System.out.println(number); // 15
        System.out.println(word);   // y
    }
}

Lee la declaración por partes. static lo convierte en un método de clase. <T> introduce un parámetro de tipo que pertenece al método. El siguiente T es el tipo de retorno. List<T> indica que la lista de entrada y el resultado comparten el tipo de elemento.

Para la primera llamada, Java infiere T como Integer. El resultado puede desempaquetarse después en un int. En la segunda llamada, <String> es un argumento de tipo explícito de método, situado entre el punto y el nombre del método. Aquí Lists.last(...) inferiría el mismo tipo. Un argumento explícito necesita un receptor antes del punto: un nombre de clase para un método estático o un objeto como this para un método de instancia.

Este método espera una lista no vacía. En una lista vacía, size() - 1 es -1, así que get lanza IndexOutOfBoundsException. Los genéricos comprueban tipos; no demuestran que exista un índice.

Relaciona varios tipos

Un método genérico puede introducir varios parámetros. Dada una clase Pair<K, V> con un constructor y métodos de acceso, este método completo invierte los papeles:

static <K, V> Pair<V, K> swap(Pair<K, V> p) {
    return new Pair<>(p.getSecond(), p.getFirst());
}

Para un par de entrada ("Ada", 36) de tipo Pair<String, Integer>, el resultado es (36, "Ada") de tipo Pair<Integer, String>. La declaración de retorno conserva la relación; un tipo de retorno Object la ocultaría y obligaría a quien llama al método a realizar una conversión explícita de tipo.

Un método como <T> int countEqual(List<T> list, T target) también relaciona entradas. Su bucle puede comparar cada elemento con target mediante equals. Con ["a", "b", "a", "c", "a"] y "a", el recuento es 3. La inferencia puede elegir un supertipo común para los argumentos, así que repetir T no siempre obliga a que dos expresiones de argumento tengan tipos declarados idénticos.

Decide a quién pertenece el parámetro de tipo

Un Box<String> conserva su argumento de tipo para el uso de ese objeto. Lists.last elige un argumento de tipo de nuevo para cada llamada. Por tanto, una clase de utilidad ordinaria puede contener métodos estáticos genéricos sin ser genérica ella misma.

Un método estático dentro de Box<T> no puede utilizar el T de la clase: el método estático pertenece a la clase compartida, no a una caja concreta. Declara un parámetro independiente, por ejemplo static <E> Box<E> of(E value). Si una declaración de método comienza con static T first(...) sin un <T> del método, el compilador indica que no puede encontrar T en una clase ordinaria. Añade la declaración antes del tipo de retorno; cambiar el tipo de retorno a Object descartaría la relación útil.

Un T sin restricciones solo admite las operaciones disponibles en Object. Las cotas añaden una garantía útil. Los comodines permiten que un parámetro acepte una familia de tipos genéricos sin suponer que todos sus tipos de elemento son idénticos.

Exige las operaciones que necesitas

static <T extends Comparable<T>> T largest(List<T> list) {
    T best = list.get(0);
    for (T x : list) {
        if (x.compareTo(best) > 0) {
            best = x;
        }
    }
    return best;
}

La cota indica que un T puede compararse con otro T. Partiendo de 3, la llamada largest(List.of(3, 11, 7)) sustituye el mejor valor por 11 y después lo deja sin cambios para 7. Devuelve 11. Para ["pear", "apple", "plum"], la palabra mayor es "plum" en orden natural. Una lista vacía falla en get(0).

extends también introduce cotas para interfaces. <T extends Number> permite utilizar doubleValue(). Las cotas múltiples utilizan &, con una clase primero si la hay: <T extends Number & Comparable<T>>.

Por qué List no es List

Integer extiende Number, pero List<Integer> no es un subtipo de List<Number>. Los tipos genéricos son invariantes. Si se permitiera esa asignación, el código que utiliza la referencia List<Number> podría añadir un Double; el propietario original lo leería entonces como un Integer. Un parámetro List<Number> sí acepta implementaciones como ArrayList<Number>, pero rechaza List<Integer>.

Lee con extends; añade con super

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

static void addOneToThree(List<? super Integer> target) {
    target.add(1);
    target.add(2);
    target.add(3);
}

? extends Number significa un tipo desconocido que es Number o un subtipo. sum acepta listas de enteros, números de doble precisión o números. Lee cada elemento como un Number. sum(List.of(1.5, 2.5)) da 4,0. No puede añadir 3: el tipo de elemento desconocido podría ser Double. Las reglas de tipos permiten añadir null, aunque una lista concreta puede rechazarlo en tiempo de ejecución.

? super Integer significa Integer o un supertipo. El segundo método puede añadir enteros a una List<Integer>, List<Number> o List<Object> modificable. Una lectura mediante ese parámetro solo tiene tipo Object: los elementos existentes podrían ser otros números u objetos.

La regla para recordarlo es productor extends, consumidor super. Describe la dirección de transferencia de los elementos, no si toda la colección es inmutable. Por ejemplo, puede seguir siendo posible eliminar elementos mediante una vista con extends.

Utiliza un parámetro con nombre cuando un tipo deba conectar varias posiciones, especialmente una entrada y un tipo de retorno. Utiliza un comodín cuando solo importe una variedad de entradas aceptadas. Collections.copy lee de List<? extends T> y escribe en List<? super T>; su destino debe tener ya suficientes posiciones que sustituir.

Los genéricos proporcionan al compilador más información que una comprobación ordinaria de clase en tiempo de ejecución. Comprender qué queda después de la compilación explica las advertencias sobre tipos sin parametrizar y varias operaciones que Java rechaza.

Qué elimina el borrado de tipos

Java comprueba los argumentos de tipo y después borra los parámetros de tipo sustituyéndolos por sus cotas. Un T sin cota se convierte en Object; un T extends Number se convierte en Number. El compilador inserta conversiones explícitas de tipo donde son necesarias al leer valores. Hay una sola clase Box en tiempo de ejecución, así que esto imprime true:

System.out.println(
    new Box<String>("a").getClass()
    == new Box<Integer>(1).getClass()
);

La declaración de Box puede ser la clase genérica con un campo de valor, un constructor y un método de acceso. Ambas construcciones tienen la misma clase en tiempo de ejecución, aunque sus usos declarados tienen comprobaciones distintas en tiempo de compilación.

Operaciones que necesitan un tipo conocido en tiempo de ejecución

Dentro de una clase genérica, new T() no compila. Java no sabe qué constructor tiene el tipo de quien llama. Acepta una fábrica para crear el valor:

import java.util.ArrayList;
import java.util.List;
import java.util.function.Supplier;

class Factory {
    static <T> T create(Supplier<T> factory) {
        return factory.get();
    }

    public static void main(String[] args) {
        List<String> words = create(ArrayList::new);
        words.add("ready");
        System.out.println(words); // [ready]
    }
}

El proveedor aporta el comportamiento de creación. new T[10] y new List<Integer>[2] también se rechazan como creación de arreglos genéricos. Almacena una secuencia en ArrayList<T> cuando no necesites el comportamiento de un arreglo.

Para un Object obj, obj instanceof List<String> no puede comprobar de forma segura el argumento de elemento. Utiliza obj instanceof List<?> para comprobar si es una lista y después trata sus elementos como desconocidos. Esa comprobación no establece que el tipo de elemento sea una cadena.

Miembros estáticos compartidos y sobrecargas tras el borrado

Un campo como static T shared no puede utilizar el T de la clase que lo contiene. Todas las parametrizaciones comparten el miembro estático. Un método estático puede introducir su propio <E>, independiente del parámetro de la clase.

Dos métodos sobrecargados print(Set<String> s) y print(Set<Integer> s) no pueden coexistir en una clase. Ambos se borran hasta quedar como un método que acepta Set, lo que deja un conflicto de nombres. Da nombres distintos a las operaciones o diseña un método que maneje el comportamiento común.

Sigue una advertencia de operación no comprobada hasta la lectura incorrecta

List raw = new ArrayList();
raw.add("text");
raw.add(42);
for (Object value : raw) {
    String text = (String) value;
    System.out.println(text);
}

Esto imprime text y después la conversión explícita de 42 lanza ClassCastException. La declaración sin parametrizar puede generar un diagnóstico de tipo sin parametrizar; las adiciones generan advertencias de llamada no comprobada porque se han eludido las comprobaciones genéricas. Sustituirla por List<String> traslada el fallo a add(42) en tiempo de compilación. Una advertencia de operación no comprobada señala una garantía perdida y un riesgo de fallo de ejecución. Corrige el uso sin parametrizar o la conversión insegura en lugar de suponer que una lectura posterior será segura.

Un método puede aceptar una regla como argumento. Una expresión lambda escribe esa regla donde se utiliza, mientras que una interfaz funcional indica a Java qué entradas recibe la regla y qué devuelve.

Ajustarse a un método abstracto

Una interfaz funcional tiene un método abstracto que implementar. Las declaraciones que coinciden con métodos públicos de instancia de Object, como equals(Object), no cuentan. Los métodos predeterminados y estáticos no añaden trabajo abstracto. Comparator<T> y Runnable son interfaces funcionales.

@FunctionalInterface
interface Operation {
    int apply(int a, int b);
}

class Combine {
    static int combine(int a, int b, Operation op) {
        return op.apply(a, b);
    }

    public static void main(String[] args) {
        Operation add = (a, b) -> a + b;
        System.out.println(add.apply(3, 4)); // 7
        System.out.println(combine(3, 4, (x, y) -> x * y)); // 12
    }
}

La interfaz proporciona el nombre de método apply, los dos tipos de parámetro int y el tipo de resultado int. La expresión lambda proporciona los nombres de los parámetros y el cuerpo. Crea una implementación utilizable mediante Operation; no llama a apply hasta que el programa lo invoca.

combine siempre pasa sus dos números a op. Quien llama cambia el comportamiento al proporcionar una suma o una multiplicación. Así es también como sort recibe una regla de ordenación y filter recibe una condición.

Lee la sintaxis

Una expresión lambda tiene parámetros, -> y después una expresión o un bloque. Un solo parámetro inferido puede omitir los paréntesis: w -> w.length() > 5. Ningún parámetro requiere (), y dos o más requieren paréntesis, como en (a, b) -> a * b. Se permiten tipos explícitos: (int a, int b) -> a + b.

Un cuerpo de expresión devuelve su resultado automáticamente. Un bloque que produce un valor debe devolverlo:

Operation max = (a, b) -> {
    if (a > b) {
        return a;
    }
    return b;
};
System.out.println(max.apply(3, 9)); // 9

Cada ruta por este bloque devuelve un int. Añadir llaves alrededor de a + b sin return no crea un bloque válido que devuelva un valor.

Deja que el destino aporte el significado

El tipo de destino es la interfaz funcional esperada en una asignación, un argumento o una posición de retorno. El texto x -> x * 2 puede corresponder a Function<Integer, Integer> o a UnaryOperator<Integer>. Sus tipos de parámetro y resultado proceden de ese destino. Object o = () -> 1; falla porque Object no proporciona ningún método funcional.

@FunctionalInterface pide al compilador que compruebe la definición de la interfaz. Es una protección útil si alguien añade después un segundo método abstracto distinto. Sin la anotación, esa interfaz puede seguir declarándose, pero una expresión lambda no puede implementar sus dos requisitos independientes.

Una expresión lambda también puede entrar en conflicto con nombres locales. Si el método que la contiene ya declara int a, no puede declarar un parámetro lambda llamado a en ese ámbito. Elige otro nombre de parámetro. En comparación con una clase anónima que implementa Comparator<String>, una expresión lambda elimina la declaración repetida de clase y método; el cálculo de ordenación sigue teniendo que cumplir el contrato del comparador.

Java ya da nombre a las formas habituales de comportamiento. Elige una interfaz según el número de entradas y el tipo de resultado, y después llama a su método funcional para ejecutar el comportamiento.

Elige una forma de entrada y salida

Estas interfaces están en java.util.function. Para cadenas, w -> w.length() > 5 corresponde a un predicado, String::length corresponde a una función que devuelve Integer y System.out::println corresponde a un consumidor. Un proveedor como () -> new ArrayList<String>() crea una lista nueva cada vez que se ejecuta get(). Una condición utilizada por filter necesita Predicate<T>, aunque una Function<T, Boolean> también podría calcular un valor booleano en otro código.

UnaryOperator<T> es una función de T al mismo T. BinaryOperator<T> combina dos valores de tipo T en un T. BiFunction<T, U, R>, BiPredicate<T, U> y BiConsumer<T, U> reciben dos entradas. Las formas para tipos primitivos evitan el empaquetado: IntPredicate.test(int), IntBinaryOperator.applyAsInt(int, int) y ToIntFunction<T>.applyAsInt(T).

Combina reglas en un orden determinado

import java.util.function.Function;
import java.util.function.Predicate;

class Rules {
    public static void main(String[] args) {
        Predicate<String> isLong = w -> w.length() > 5;
        Predicate<String> longB = isLong.and(w -> w.startsWith("b"));
        System.out.println(longB.test("banana")); // true
        System.out.println(isLong.negate().test("kiwi")); // true

        Function<Integer, Integer> twice = x -> x * 2;
        Function<Integer, Integer> inc = x -> x + 1;
        System.out.println(twice.andThen(inc).apply(5)); // 11
        System.out.println(twice.compose(inc).apply(5)); // 12
    }
}

and requiere ambas condiciones, or requiere al menos una y negate invierte la respuesta. Predicate.not(p) también niega un predicado. andThen ejecuta primero el receptor; compose ejecuta primero su argumento. Aquí la primera cadena calcula 10 y después 11, mientras que la segunda calcula 6 y después 12.

Pasa una regla a un método

static <T> List<T> keep(List<T> list, Predicate<T> test) {
    List<T> kept = new ArrayList<>();
    for (T x : list) {
        if (test.test(x)) kept.add(x);
    }
    return kept;
}

keep(List.of(4, 9, 12, 15), n -> n % 3 == 0) da [9, 12, 15]. T permite reutilizar el método con distintos tipos de elemento; el predicado permite reutilizar el comportamiento de selección.

Para una lista modificable [3, 8, 1, 10, 6], removeIf(n -> n < 5) deja [8, 10, 6]. Después, replaceAll(n -> n * 2) da [16, 20, 12]. Estos métodos modifican la lista; forEach acepta un consumidor para acciones como imprimir. Copia el resultado de List.of(...) en un ArrayList antes de utilizar operaciones que lo modifiquen.

Para mapas, forEach((key, value) -> ...) recibe un BiConsumer. merge(word, 1, Integer::sum) almacena 1 para una palabra nueva e incrementa un recuento existente. computeIfAbsent(key, k -> new ArrayList<>()) crea un valor para una clave ausente o asociada a null y devuelve el valor resultante. Estos métodos mantienen juntas la búsqueda y la regla de actualización.

Una expresión lambda puede utilizar información del método que la contiene. Cuando su cuerpo solo llama a un método existente, una referencia a método suele expresar el mismo comportamiento de forma más directa.

Captura una variable local

int limit = 10;
Predicate<Integer> small = n -> n < limit;
System.out.println(small.test(7)); // true

La expresión lambda captura limit. Una variable local capturada debe ser final o efectivamente final: se le asigna un valor una vez y nunca se reasigna. Añadir limit = 20; en cualquier lugar después de esa primera asignación hace que la captura no compile, incluso si la reasignación aparece antes de la expresión lambda.

La regla se aplica a la variable local, no a todo el estado de su objeto. Esto compila:

StringBuilder log = new StringBuilder();
Runnable action = () -> log.append("ran");
action.run();
System.out.println(log); // ran

log sigue haciendo referencia al mismo constructor de cadenas. También se permite actualizar un campo del objeto que contiene la expresión, pero los cambios ocultos pueden dificultar el seguimiento del comportamiento.

Intentar numbers.forEach(n -> total += n) con una variable local int total = 0 falla porque cambia la variable capturada. Utiliza un bucle cuando la tarea sea una actualización, o calcula un resultado directamente con numbers.stream().mapToInt(n -> n).sum().

Lee las cuatro formas de referencia

Una referencia a método utiliza ::, sin lista de argumentos. La interfaz funcional de destino proporciona las entradas y el resultado esperado.

En la referencia vinculada, el receptor ya está fijado: el PrintStream al que hace referencia System.out. En la referencia sin receptor vinculado, el primer argumento funcional se convierte en el receptor. Así, String::compareToIgnoreCase equivale a (a, b) -> a.compareToIgnoreCase(b): la primera cadena es el receptor y la segunda es el argumento del método.

Ajusta la referencia a un destino

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

class References {
    public static void main(String[] args) {
        Function<String, Integer> parse = Integer::parseInt;
        Function<String, Integer> length = String::length;
        Supplier<List<String>> fresh = ArrayList::new;
        System.out.println(parse.apply("42")); // 42
        System.out.println(length.apply("stream")); // 6
        System.out.println(fresh.get()); // []
    }
}

Una referencia a constructor también puede recibir argumentos. Student::new corresponde a una Function<String, Student> cuando un constructor compatible recibe un String. El destino determina qué constructor sobrecargado se selecciona.

Student::getName hace referencia a un método de acceso de instancia sobre cada estudiante proporcionado; no requiere un método de acceso estático. Escribe una expresión lambda cuando haya trabajo adicional, como en s -> s.getPoints() * 2 o w -> w.length() > 5. Escribir String::length() no es válido: la referencia nombra el comportamiento sin invocarlo en ese punto.

El orden natural de un objeto no siempre es el que necesita una tarea. Un Comparator<T> independiente te permite ordenar los mismos objetos según distintas reglas sin modificar su clase.

Lee el signo de compare

compare(a, b) devuelve un número negativo cuando a va primero, cero cuando ambos ocupan la misma posición y un número positivo cuando a va después de b. Solo importa el signo. Un comparador no devuelve un valor booleano.

Comparable<T> pertenece a la clase y proporciona su orden natural mediante compareTo. Un comparador es un valor independiente que se pasa a un método de ordenación. Las cadenas tienen un orden natural de caracteres, pero un comparador puede ordenarlas por longitud.

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

class SortWords {
    public static void main(String[] args) {
        List<String> words = new ArrayList<>(List.of("ccc", "a", "bb"));
        Comparator<String> byLength =
            (a, b) -> Integer.compare(a.length(), b.length());
        words.sort(byLength);
        System.out.println(words); // [a, bb, ccc]
    }
}

El comparador extrae las longitudes y compara los números. words.sort modifica la lista modificable y devuelve void; no devuelve una lista nueva. Ordenar un resultado de List.of(...) lanza UnsupportedOperationException, así que el ejemplo primero crea una copia ArrayList.

Compara números de forma segura

Utiliza Integer.compare o Double.compare. La resta puede invertir el signo por desbordamiento: 2_000_000_000 - (-2_000_000_000) se evalúa como −294 967 296 en un int. Esto coloca incorrectamente el número mayor primero en orden ascendente. Integer.compare(2_000_000_000, -2_000_000_000) devuelve correctamente 1.

Convertir explícitamente una diferencia de números de doble precisión a int también pierde información. (int) (1.2 - 0.7) es 0, aunque el primer valor es mayor. Double.compare(1.2, 0.7) indica un resultado positivo.

Mantén la consistencia del orden

Invertir las entradas debe invertir el signo de la comparación. Si a va antes que b y b antes que c, a debe ir antes que c. Los valores cuya comparación da cero deben ocupar la misma posición con respecto a cualquier otro valor. Incumplir estas reglas puede producir un orden incorrecto o hacer que la ordenación lance IllegalArgumentException con «¡El método de comparación incumple su contrato general!». Devolver solo 0 o 1 no puede expresar ambas direcciones.

Las ordenaciones de listas y las ordenaciones de arreglos de objetos basadas en comparadores de Java son estables: los elementos empatados conservan su orden original. Para los estudiantes Ada 85, Ben 72, Chen 85, Dara 90 y Eli 64, ordenar por puntos ascendentes da Eli, Ben, Ada, Chen, Dara. Ada sigue antes que Chen porque empatan y Ada aparecía primero.

Los ejemplos de estudiantes utilizan esta clase y una lista modificable:

class Student {
    private final String name;
    private final String group;
    private final int points;

    Student(String name, String group, int points) {
        this.name = name;
        this.group = group;
        this.points = points;
    }
    String getName() { return name; }
    String getGroup() { return group; }
    int getPoints() { return points; }
}

List<Student> students = new ArrayList<>(List.of(
    new Student("Ada", "A", 85), new Student("Ben", "B", 72),
    new Student("Chen", "A", 85), new Student("Dara", "B", 90),
    new Student("Eli", "A", 64)));
students.sort(Comparator.comparingInt(Student::getPoints));
students.forEach(s -> System.out.println(s.getName()));
// Eli, Ben, Ada, Chen, Dara, each on a separate line

Elige cómo ordenar

list.sort(cmp) y Collections.sort(list, cmp) modifican una lista modificable. list.sort(null) solicita el orden natural. Arrays.sort(array, cmp) acepta un arreglo de objetos como Integer[]; un int[] no tiene una sobrecarga que acepte un comparador.

El orden natural de cadenas compara unidades de código UTF-16. Las mayúsculas A–Z preceden a las minúsculas a–z, así que ["banana", "Cherry", "apple"] se convierte en [Cherry, apple, banana]. String.CASE_INSENSITIVE_ORDER da [apple, banana, Cherry] para esas palabras. Elige la regla de texto explícitamente cuando las mayúsculas y minúsculas no deban decidir el orden.

Un orden con varias claves se lee mejor como una secuencia de decisiones: compara la clave principal y después compara una segunda clave solo si la primera empata. Los métodos de construcción de comparadores expresan esas decisiones directamente.

Extrae una clave y resuelve empates

Para un Student con getName(), getGroup() y getPoints(), Comparator.comparing(Student::getName) ordena por nombre. comparingInt(Student::getPoints) extrae un int sin empaquetarlo.

Comparator<Student> ranking =
    Comparator.comparingInt(Student::getPoints)
        .reversed()
        .thenComparing(Student::getName);

Esto coloca primero los puntos más altos y después ordena los nombres de forma ascendente cuando los puntos son iguales. Para Ada (A, 85), Ben (B, 72), Chen (A, 85), Dara (B, 90), Eli (A, 64), da Dara, Ada, Chen, Ben, Eli. La comparación de nombres solo se ejecuta cuando hay un empate en puntos.

Coloca reversed en el nivel adecuado

reversed() invierte todo lo construido antes. Invertir la clasificación después de thenComparing también invertiría los nombres dentro de cada empate de puntuación. Para ordenar los grupos de forma ascendente y los puntos de forma descendente dentro de cada grupo, invierte solo el comparador de puntos:

Comparator<Student> byGroup =
    Comparator.comparing(Student::getGroup)
        .thenComparing(
            Comparator.comparingInt(Student::getPoints).reversed());

El resultado es Ada, Chen, Eli, Dara, Ben: el grupo A precede a B; dentro de A, 85 precede a 64. Poner .reversed() al final invertiría tanto el orden de los grupos como el de los puntos respecto a la cadena anterior.

Elige reglas para texto y valores nulos

Comparator.naturalOrder() sigue Comparable; reverseOrder() lo invierte. Proporciona un comparador de claves cuando una clave necesite un manejo especial, como en Comparator.comparing(Student::getName, String.CASE_INSENSITIVE_ORDER).

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

class SortNullable {
    public static void main(String[] args) {
        List<String> words = new ArrayList<>();
        words.add("b");
        words.add(null);
        words.add("a");
        words.sort(Comparator.nullsFirst(Comparator.naturalOrder()));
        System.out.println(words); // [null, a, b]
    }
}

Envuelve la comparación en el nivel donde aparece null. nullsLast alrededor de todo el comparador de estudiantes maneja objetos de estudiante nulos. Un extractor de nombres que devuelve null necesita un comparador que admita valores nulos para la propia clave de nombre. Los comparadores de orden natural y los comparadores de claves ordinarios no manejan automáticamente las claves nulas.

Ordena entradas de mapa y resuelve la inferencia

Un HashMap no garantiza un orden de encuentro. Procesa sus entradas como flujo y elige un orden explícitamente:

stock.entrySet().stream()
    .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
    .forEach(System.out::println);

Para rice=12, oats=3 y flour=7, esto imprime rice=12, flour=7, oats=3, en líneas separadas. Ordena las entradas del flujo sin reorganizar stock. Añade thenComparing(Map.Entry.comparingByKey()) si los valores empatados necesitan un orden predecible por clave.

El <String, Integer> explícito ayuda a la inferencia en la llamada encadenada. Del mismo modo, Comparator.comparing(s -> s.getName()).reversed() puede inferir s como Object. Utiliza Student::getName o (Student s) -> s.getName() para proporcionar el tipo que falta. Un comparador con nombre puede reutilizarse para ordenar listas, en sorted, min y max de flujos, o en un mapa o conjunto ordenado.

Un flujo describe cómo procesar una secuencia de valores. Lee de una fuente, pasa los elementos por operaciones intermedias y termina con una operación terminal que produce un resultado o realiza una acción.

Identifica las tres partes

import java.util.List;

class CountPasses {
    public static void main(String[] args) {
        List<Integer> points = List.of(72, 45, 90, 58, 81);
        long passed = points.stream()
            .filter(p -> p >= 60)
            .count();
        System.out.println(passed); // 3
        System.out.println(points); // [72, 45, 90, 58, 81]
    }
}

points.stream() es la fuente. filter es una operación intermedia: devuelve otro flujo. count es la operación terminal: devuelve un long. Los valores 72, 90 y 81 superan el filtro. La lectura mediante el flujo no ha eliminado 45 ni 58 de points.

Elige una fuente

Las colecciones ofrecen stream(). Un mapa ofrece flujos mediante entrySet(), keySet() o values(). Arrays.stream(array) crea un flujo de elementos de un arreglo; un int[] produce un IntStream. Stream.of("a", "b", "c") proporciona los valores enumerados.

IntStream.range(1, 5) contiene 1, 2, 3, 4, con el extremo final excluido. rangeClosed(1, 5) incluye 5 y suma 15. Stream.iterate(1, n -> n * 2) no tiene un extremo fijo; .limit(5).toList() recopila [1, 2, 4, 8, 16]. Un resultado acotado es esencial al consumir esa secuencia infinita.

Sigue la ejecución diferida

Las operaciones intermedias son diferidas. Escribir simplemente names.stream().map(String::toUpperCase); no realiza las transformaciones. Una operación terminal inicia el procesamiento y los elementos se consumen solo cuando se necesitan.

String first = java.util.stream.Stream.of("one", "two", "three", "four")
    .filter(w -> w.length() > 3)
    .map(String::toUpperCase)
    .findFirst()
    .orElse("none");
System.out.println(first); // THREE

Las dos primeras palabras no superan el filtro. "three" lo supera, se convierte en "THREE" y satisface findFirst. La última palabra no es necesaria. Esto es cortocircuito: la respuesta se conoce antes de leer toda la fuente.

sorted necesita toda la entrada antes de poder emitir el primer valor ordenado. Algunas otras operaciones con estado, como distinct secuencial, pueden emitir valores a medida que llega la entrada. La posición de una operación en la cadena afecta a la cantidad de trabajo necesaria.

Crea un flujo nuevo para otro resultado

Después de una operación terminal, el flujo queda consumido. Reutilizar ese flujo suele lanzar IllegalStateException con «el flujo ya se ha utilizado o cerrado». Vuelve a llamar a points.stream() para otra secuencia de procesamiento. Una colección es almacenamiento reutilizable; un flujo es una ruta de procesamiento.

Crear un flujo no copia sus elementos. Mantén la fuente sin cambios mientras la procesas. map produce valores transformados; no los escribe de nuevo en la lista. Para modificar una lista de forma intencionada, métodos como replaceAll y removeIf expresan esa tarea directamente. Utiliza una operación por línea para que el orden de procesamiento y el tipo de resultado sigan siendo visibles.

Sigue tanto los valores como su tipo después de cada operación: una expresión lambda posterior recibe el elemento actual del flujo, no el objeto original de la fuente.

Selecciona antes de transformar

filter conserva los elementos que cumplen un predicado. map sustituye cada elemento por un valor calculado. Dados estudiantes con métodos de acceso al nombre y a los puntos, la selección por puntos debe realizarse antes de transformar los elementos en nombres:

List<String> names = students.stream()
    .filter(s -> s.getPoints() >= 80)
    .map(Student::getName)
    .sorted()
    .toList();

Para Ada 85, Ben 72, Chen 85, Dara 90 y Eli 64, esto produce [Ada, Chen, Dara]. Antes de map, el tipo de elemento es Student. Después, el tipo es String, por lo que ya no está disponible un método de acceso a los puntos.

Pasa a un flujo de tipos primitivos

Stream<Integer> contiene referencias a objetos envoltorio y no tiene método sum(). mapToInt(Integer::intValue) produce un IntStream, que proporciona operaciones numéricas. Del mismo modo, mapToInt(String::length) mide cadenas como longitudes primitivas.

import java.util.List;
import java.util.stream.IntStream;

class Windows {
    public static void main(String[] args) {
        List<Integer> window = IntStream.rangeClosed(1, 10)
            .skip(2)
            .limit(3)
            .boxed()
            .toList();
        System.out.println(window); // [3, 4, 5]
    }
}

skip(2) elimina 1 y 2 del flujo. limit(3) conserva los tres valores siguientes. Invertir esas llamadas deja solo 3. boxed() vuelve a Stream<Integer> para que los elementos puedan recopilarse como objetos. mapToObj crea otros objetos a partir de valores primitivos; los flujos de long y double tienen operaciones de conversión correspondientes.

Elimina duplicados y elige un orden

distinct utiliza la igualdad de objetos. ["map", "filter", "map", "sorted", "filter"] se convierte en [map, filter, sorted], y después sorted() da [filter, map, sorted]. Para tus propias clases, implementa equals y hashCode de forma consistente si los valores de campo coincidentes deben contar como duplicados.

sorted() utiliza el orden natural. Proporciona un comparador para otro orden o para objetos sin orden natural. La ordenación de un flujo ordenado es estable. Ordenar los cinco estudiantes por puntos descendentes y después tomar dos selecciona a Dara y Ada: Ada precede a Chen en la lista original con su puntuación empatada. Llamar a limit(2) antes de ordenar examinaría solo los dos primeros estudiantes originales.

Aplana secuencias anidadas

List<Integer> all = List.of(
        List.of(1, 2), List.of(3), List.of(4, 5, 6))
    .stream()
    .flatMap(List::stream)
    .toList();
System.out.println(all); // [1, 2, 3, 4, 5, 6]

Cada lista interna se convierte en un flujo, y flatMap une sus elementos en un solo flujo. Sustituir aquí flatMap por map da un Stream<Stream<Integer>>: un objeto de flujo por cada lista interna, sin aplanarla.

peek pasa un valor sin modificarlo y puede imprimirlo para depurar. Su acción solo se ejecuta para los elementos realmente recorridos, y una implementación puede omitir una etapa innecesaria, por ejemplo al optimizar count. No lo utilices para realizar trabajo necesario. Para obtener un único valor máximo, utiliza max(comparator) en lugar de ordenar todos los elementos y tomar uno.

Elige la operación terminal según el resultado que necesites: un recuento, un número, un valor de verdad, un elemento o una combinación general. La entrada vacía importa siempre que no se pueda elegir un valor de resultado.

Calcula un número

count() devuelve un long. sum() de un flujo de tipos primitivos devuelve un número del tipo primitivo del flujo. Para los puntos [72, 45, 90, 58, 81], filtrar para obtener al menos 60 y después sumar da 243. La media de esos tres valores es 81,0.

import java.util.List;

class PointResults {
    public static void main(String[] args) {
        List<Integer> points = List.of(72, 45, 90, 58, 81);
        int sum = points.stream().filter(p -> p >= 60)
            .mapToInt(Integer::intValue).sum();
        double average = points.stream().filter(p -> p >= 60)
            .mapToInt(Integer::intValue).average().orElse(0.0);
        System.out.println(sum);     // 243
        System.out.println(average); // 81.0
    }
}

La segunda secuencia de procesamiento utiliza un flujo nuevo. Una suma vacía es 0, pero una media vacía no tiene valor. average() devuelve OptionalDouble, y orElse(0.0) proporciona un valor alternativo elegido. Ese valor predeterminado es una decisión del programa, no la media matemática de un conjunto vacío.

Una suma int puede desbordarse. Sumar dos valores de 2 000 000 000 produce −294 967 296 como int. Amplía el tipo antes de sumar: mapToInt(...).asLongStream().sum() da 4 000 000 000 como long.

Maneja un valor o ninguno

Un Optional<T> contiene un valor o ningún valor. min, max, findFirst, findAny y la reducción sin elemento neutro de un flujo de objetos devuelven valores opcionales. points.stream().max(Integer::compare) da Optional[90]; imprimir el contenedor incluye el texto que envuelve el valor.

Utiliza orElse para un valor alternativo, orElseGet para un proveedor alternativo, ifPresent para una acción o map para transformar un valor presente. Filtrar para encontrar un estudiante con más de 95 puntos, transformar la primera coincidencia en un nombre y aplicar orElse("nobody") da "nobody" para los datos de los cinco estudiantes. Llamar a get() o orElseThrow() sobre un valor opcional vacío lanza NoSuchElementException.

Haz una pregunta verdadera o falsa

anyMatch pregunta si al menos un valor cumple la condición, allMatch si todos la cumplen y noneMatch si ninguno la cumple. Pueden detenerse en cuanto se conoce la respuesta. Con una entrada vacía, anyMatch es falso, mientras que allMatch y noneMatch son verdaderos: no hay ningún valor que incumpla ninguna de las dos afirmaciones universales.

Combina con un elemento neutro

Stream.of(3, 5, 7).reduce(0, Integer::sum) acumula 0, 3, 8, 15. Para la multiplicación, empieza con 1 y utiliza (a, b) -> a * b para obtener 105. Un elemento neutro deja un valor sin cambios bajo la operación; 10 no es un elemento neutro de la suma y desplazaría incorrectamente el total a 25. El acumulador debe ser asociativo para que la agrupación no cambie el resultado.

Sin elemento neutro, reduce(Integer::max) da Optional[7] y un valor opcional vacío para una entrada vacía. forEach, en cambio, realiza una acción y devuelve void; es adecuado para imprimir. Utiliza una reducción o recopilación cuando la tarea sea producir un valor de resultado.

Un recolector convierte un flujo en una estructura de resultado útil. Decide qué debe admitir el resultado: duplicados, orden, cambios posteriores o claves de mapa duplicadas. Los distintos recolectores ofrecen garantías diferentes.

Elige una lista o un conjunto

stream.toList() devuelve una lista no modificable en orden de encuentro. Añadir o eliminar elementos lanza UnsupportedOperationException. collect(Collectors.toList()) también recopila una lista, pero no garantiza una implementación concreta ni que sea modificable. Para una lista que vayas a modificar, solicítala explícitamente:

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

class Gather {
    public static void main(String[] args) {
        List<String> words = Stream.of("a", "b", "a")
            .collect(Collectors.toCollection(ArrayList::new));
        words.add("c");
        System.out.println(words); // [a, b, a, c]
        System.out.println(Stream.of("a", "b", "a")
            .collect(Collectors.toSet()).size()); // 2
    }
}

toSet elimina duplicados y no garantiza ningún orden. toCollection(TreeSet::new) solicita un conjunto ordenado. Una lista conserva elementos duplicados; elige un conjunto cuando el resultado represente valores distintos.

Une texto

Collectors.joining(", ") une cadenas con un separador, sin un separador final. Su forma de tres argumentos también añade un prefijo y un sufijo:

String names = Stream.of("Ada", "Chen", "Dara")
    .collect(Collectors.joining(", ", "[", "]"));
System.out.println(names); // [Ada, Chen, Dara]

Los elementos deben ser valores CharSequence, normalmente cadenas. Transforma estudiantes con Student::getName o números con String::valueOf antes de unirlos. La unión devuelve una cadena, no una lista que simplemente se imprime de forma similar.

Elige claves y valores de mapa

Collectors.toMap(keyFunction, valueFunction) calcula una entrada a partir de cada elemento. Con los cinco estudiantes Ada (A, 85), Ben (B, 72), Chen (A, 85), Dara (B, 90), Eli (A, 64), asociar nombres con puntos da cinco entradas como Ada=85 y Eli=64.

Las claves de grupo son diferentes: varios estudiantes tienen el mismo grupo. toMap(Student::getGroup, Student::getPoints) con dos argumentos lanza IllegalStateException cuando se repite una clave, incluso si ambos valores son 85. Un mapa necesita un único valor resultante por clave, y esta forma no proporciona ninguna regla para elegirlo.

Proporciona un tercer argumento para combinar duplicados:

Map<String, Integer> totals = students.stream()
    .collect(Collectors.toMap(
        Student::getGroup, Student::getPoints, Integer::sum));

El grupo A recibe 85 + 85 + 64 = 234; el grupo B recibe 72 + 90 = 162. Sustituir Integer::sum por Math::max conserva la puntuación más alta por grupo, A=85 y B=90. Utiliza la regla que responda a la tarea, no un primer valor arbitrario.

toMap no garantiza ningún orden concreto del mapa. Un cuarto argumento puede solicitar uno, por ejemplo TreeMap::new para claves ordenadas. toMap(Student::getName, Student::getPoints, (a, b) -> a, TreeMap::new) conserva el primer valor cuando hay nombres duplicados y ordena por nombre. Un recolector también evita crear una lista externa y modificarla en forEach; el resultado lo construye la operación diseñada para recopilarlo.

Un resultado agrupado responde a una pregunta para cada clave. Una partición responde a una pregunta de sí o no con dos grupos. Un recolector posterior determina qué almacena cada grupo.

Agrupa por una clave calculada

groupingBy(classifier) produce un mapa que asocia cada clave encontrada con una lista de sus elementos. Agrupar ["fig", "kiwi", "pear", "plum", "apple", "mango", "banana"] por longitud de palabra asigna a la longitud 4 la lista [kiwi, pear, plum]. Las longitudes ausentes no tienen entrada; buscarlas devuelve null, así que utiliza getOrDefault(key, List.of()) cuando sea útil una lista vacía.

import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.stream.Collectors;

class WordGroups {
    public static void main(String[] args) {
        List<String> words = List.of(
            "fig", "kiwi", "pear", "plum", "apple", "mango", "banana");
        Map<Integer, Long> counts = words.stream()
            .collect(Collectors.groupingBy(
                String::length, TreeMap::new, Collectors.counting()));
        System.out.println(counts); // {3=1, 4=3, 5=2, 6=1}
    }
}

La función clasificadora elige claves enteras. TreeMap::new ordena esas claves. counting() sustituye la lista de cada grupo por su tamaño como un Long. El tipo de resultado es, por tanto, Map<Integer, Long>, no un mapa de enteros a enteros.

Cambia lo que almacena un grupo

Con los estudiantes Ada (A, 85), Ben (B, 72), Chen (A, 85), Dara (B, 90), Eli (A, 64), agrupar por Student::getGroup ofrece estas posibilidades:

Un recolector posterior trabaja dentro de cada grupo. Para A, la media es 234 dividido entre 3, o 78,0; la media de B es 81,0. maxBy y minBy almacenan un Optional que contiene el valor extremo de cada grupo. groupingBy simple no garantiza un tipo de mapa ni un orden de claves concretos; su forma con fábrica de mapas permite elegirlos explícitamente.

Divide en dos respuestas

Map<Boolean, List<String>> partition = students.stream()
    .collect(Collectors.partitioningBy(
        s -> s.getPoints() >= 80,
        Collectors.mapping(Student::getName, Collectors.toList())));

La lista verdadera es [Ada, Chen, Dara] y la lista falsa es [Ben, Eli]. Ambas claves booleanas están presentes, aunque uno de los lados no tenga estudiantes. Con counting() como recolector posterior, los lados vacíos contienen 0 como un Long. En cambio, groupingBy con una función clasificadora booleana solo crea las claves que aparecen.

Procesa el mapa que has creado

Un resultado agrupado es un mapa ordinario. Recórrelo con forEach((group, value) -> ...) o procesa sus entradas como flujo. Para las medias A=78,0 y B=81,0, averages.entrySet().stream().max(Map.Entry.comparingByValue()) devuelve un Optional<Map.Entry<String, Double>> que contiene B=81,0. El valor opcional envuelve la entrada ganadora; no es el valor simple 81,0. Un paso independiente puede transformar esa entrada en su clave o valor y manejar un mapa vacío.

Una tarea completa de datos suele tener dos etapas: resumir la entrada y después consultar el resumen. Elige flujos cuando estas etapas se lean de forma natural como operaciones estándar, y bucles cuando el control explícito haga el trabajo más claro.

Calcula la media de las lecturas y selecciona ciudades

Supón que un Reading tiene getCity() y getCelsius(). Las lecturas son Oslo 4,5, Lima 19,0, Oslo 6,0, Cairo 27,5 y Lima 21,0, en grados Celsius.

class Reading {
    private final String city;
    private final double celsius;
    Reading(String city, double celsius) {
        this.city = city;
        this.celsius = celsius;
    }
    String getCity() { return city; }
    double getCelsius() { return celsius; }
}

Crea la lista de entrada antes de cualquiera de las dos implementaciones:

List<Reading> readings = List.of(
    new Reading("Oslo", 4.5), new Reading("Lima", 19.0),
    new Reading("Oslo", 6.0), new Reading("Cairo", 27.5),
    new Reading("Lima", 21.0));

Map<String, Double> averages = readings.stream()
    .collect(Collectors.groupingBy(
        Reading::getCity,
        TreeMap::new,
        Collectors.averagingDouble(Reading::getCelsius)));

List<String> warmCities = averages.entrySet().stream()
    .filter(e -> e.getValue() > 15)
    .map(Map.Entry::getKey)
    .toList();

El primer resultado es {Cairo=27.5, Lima=20.0, Oslo=5.25}. La media de Oslo es (4.5 + 6.0) / 2, o 5,25. La de Lima es 20,0. El segundo resultado es [Cairo, Lima]; el TreeMap proporciona un orden ascendente de ciudades. Filtra las medias después de agrupar: filtrar primero las lecturas individuales responde a una pregunta distinta.

Para la lectura individual más alta, utiliza readings.stream().max(Comparator.comparingDouble(Reading::getCelsius)). Devuelve un valor opcional que contiene la lectura de Cairo, no necesariamente la ciudad con la media más alta. Estas tareas pueden tener respuestas diferentes con otros datos.

Expresa el mismo cálculo con bucles

Map<String, List<Double>> byCity = new TreeMap<>();
for (Reading r : readings) {
    byCity.computeIfAbsent(r.getCity(), k -> new ArrayList<>())
        .add(r.getCelsius());
}
Map<String, Double> averages = new TreeMap<>();
for (Map.Entry<String, List<Double>> e : byCity.entrySet()) {
    double sum = 0;
    for (double value : e.getValue()) sum += value;
    averages.put(e.getKey(), sum / e.getValue().size());
}
System.out.println(averages);
// {Cairo=27.5, Lima=20.0, Oslo=5.25}

Estas son implementaciones alternativas del mismo resultado; cada grupo no está vacío porque una lectura lo creó. El flujo expresa la agrupación y la media en un solo recolector. Los bucles muestran las listas intermedias y la suma.

Mantén predecible el comportamiento del procesamiento

Una expresión lambda de una secuencia de procesamiento debe calcular a partir de su entrada sin modificar el estado externo. Para los puntos [72, 45, 90, 58, 81], filter(p -> p >= 60).toList() produce directamente [72, 90, 81]. Añadir elementos a una lista externa dentro de forEach oculta esa tarea de construcción del resultado en una acción.

No modifiques una fuente ArrayList dentro de su secuencia de procesamiento: añadir elementos desde un forEach puede lanzar ConcurrentModificationException. Primero recopila los elementos nuevos por separado y después añádelos cuando termine el procesamiento. Las reglas de tipos de Java pueden permitir la mutación mediante una referencia final capturada; eso no hace que la mutación sea adecuada dentro de un flujo.

Elige el flujo de control más claro

Utiliza un bucle cuando necesites índices adyacentes, una condición de parada complicada o varias actualizaciones coordinadas. Utiliza flujos para una selección, transformación y recopilación fáciles de leer. La sintaxis de flujos por sí sola no garantiza velocidad. Da nombre a un predicado o comparador largo y divide una cadena larga en un resultado intermedio significativo. Para depurar, inspecciona con peek o recopila una etapa en una lista e imprímela; continúa desde un flujo nuevo de esa lista en lugar de reutilizar una secuencia consumida.