¿Qué es Stream.sorted() en Java y cómo se utiliza?

Si, al igual que yo, eres fanático del orden, sobre todo al programar. Hoy te traigo una herramienta que te ayudará a ordenar tus listas de elementos de forma fácil y rápida. Stream.sorted() en Java es fundamental para que tu código permanezca organizado y sea legible. Voy a explicarte con ejemplos cómo usarlo para que también le saques el máximo provecho.

¿Qué es Stream.sorted() en Java?

La verdad no es nada del otro mundo, Stream.sorted() en Java es una operación intermedia que devuelve un Stream con los elementos ordenados. Sí, así de fácil.

De hecho, existen dos variantes de este método:

1. sorted(): Con este puedes ordenar los elementos en su orden natural (ascendente), siempre que sean instancias de la interfaz Comparable.
2. sorted(Comparator<? super T> comparator): Este te sirve para ordenar los elementos según un criterio definido por un Comparator.

Lo genial de Stream.sorted() en Java es que puedes usarlo para ordenar casi cualquier cosa: cadenas, números, objetos personalizados y más.

Voy a mostrarte cómo con estos ejemplos prácticos y fáciles que he preparado para ti.

¿Cómo se utiliza Stream.sorted() en Java? Ejemplos prácticos y fáciles

Ordena los números en orden ascendente

Lo que haremos aquí será ordenar los números en orden natural. Recuerda que este método funciona porque los números implementan la interfaz Comparable.

import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        Stream.of(5, 1, 4, 3, 2)
            .sorted()
            .forEach(System.out::println); // Imprime: 1 2 3 4 5
    }
}

Ordena las cadenas alfabéticamente

Ten en cuenta que las cadenas también implementan Comparable, por lo que se ordenan automáticamente en orden alfabético.

import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        Stream.of("zorro", "perro", "gato", "conejo")
            .sorted()
            .forEach(System.out::println); // Imprime: conejo gato perro zorro
    }
}

Ordena objetos personalizados con Comparator

Para este ejemplo quiero que imagines que tienes una clase Producto:

public class Producto {
    private String nombre;
    private double precio;

    public Producto(String nombre, double precio) {
        this.nombre = nombre;
        this.precio = precio;
    }

    public String getNombre() {
        return nombre;
    }

    public double getPrecio() {
        return precio;
    }

    @Override
    public String toString() {
        return nombre + " - $" + precio;
    }
}

Entonces, haz esto para ordenar una lista de productos por precio:

import java.util.*;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        Stream.of(
            new Producto("Laptop", 800),
            new Producto("Mouse", 20),
            new Producto("Teclado", 50),
            new Producto("Monitor", 150)
        )
        .sorted((p1, p2) -> Double.compare(p1.getPrecio(), p2.getPrecio()))
        .forEach(System.out::println);
    }
}

La salida te debe quedar así:
Mouse – $20
Teclado – $50
Monitor – $150
Laptop – $800

Ordena en orden descendente

Aquí te comparto un secreto no tan secreto: para invertir el orden, puedes usar un Comparator con la variante de Stream.sorted() que lo acepta:

import java.util.stream.Stream;
import java.util.Comparator;

public class Main {
    public static void main(String[] args) {
        Stream.of(3, 1, 4, 1, 5, 9)
            .sorted(Comparator.reverseOrder())
            .forEach(System.out::println); // Imprime: 9 5 4 3 1 1
    }
}

Filtra, transforma y ordena

Te sorprenderá saber que, cuando se trata de combinar operaciones en cadena, los Streams sacan todo su potencial. Me refiero a esto:

import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        Stream.of("Manzana", "Banana", "Cereza", "Durazno")
            .filter(fruta -> fruta.length() > 6)  // Filtra frutas con más de 6 letras
            .map(String::toLowerCase)             // Convierte a minúsculas
            .sorted()                             // Ordena alfabéticamente
            .forEach(System.out::println);        // Imprime los resultados
    }
}

Verás que la salida te queda así:
banana
cereza
durazno

Consejos para usar correctamente Stream.sorted() en Java

1. Evita modificar los elementos originales: No olvides que los Streams son inmutables por diseño. Así que mejor usa transformaciones seguras para no alterar tus datos base.
2. Elige el Comparator correcto: Recuerda definir un criterio claro de ordenamiento para evitar resultados inesperados.
3. Combina operaciones sabiamente: Te recomiendo usar filter() y map() para preparar los datos antes de ordenarlos.
4. Recuerda que los Streams son “lazy”: La operación no se ejecuta hasta que se aplica una terminal como forEach() o collect().

Espero que hayas aprendido que Stream.sorted() en Java es una herramienta poderosa para ordenar datos de forma flexible y concisa. Desde números y cadenas hasta objetos personalizados, este método te ayuda a organizar tu información como nunca antes lo has hecho, todo dentro del marco de la programación funcional.

¿Sientes que no aprendiste lo suficiente? Puede que necesites profundizar más en estos conceptos. De hecho, imagina lo que podrías aprender en nuestro Bootcamp de Java Full Stack. Con nosotros, dominarás Java desde cero hasta un nivel profesional, preparándote para entrar al mundo IT en tiempo récord. ¡Apúntate ahora y empieza a transformar tu futuro!