Aprende Organización de Elementos en Orden con el Método sorted()

En la API Stream de Java, el método sorted() permite ordenar los elementos de un stream de manera eficiente. La ordenación es una operación fundamental porque simplifica el procesamiento de datos, facilitando la organización de los elementos en el orden deseado.

Ordenación por orden natural

El método sorted() está sobrecargado y tiene dos versiones. Comencemos con la primera:

Stream<T> sorted();

Esta versión ordena los elementos según su orden natural. Para utilizar este método, los elementos deben implementar la interfaz Comparable, lo que les permite ser comparados y ordenados automáticamente.

Ejemplo práctico

Imagine una fábrica con varias piezas, cada una con un peso único. El objetivo es ordenar estas piezas en orden ascendente según su peso utilizando la interfaz Comparable.

Main.java


              12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849
            
package com.example;

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        // List of factory parts
        List<Part> parts = Arrays.asList(
                new Part("Wheel", 10),
                new Part("Engine", 250),
                new Part("Brake", 15),
                new Part("Chassis", 80)
        );

        // Sorting parts by weight in ascending order
        parts.stream()
                .sorted()  // Sorting by natural order
                .forEach(System.out::println);
    }
}

class Part implements Comparable<Part> {
    private String partName;
    private int weight;

    public Part(String partName, int weight) {
        this.partName = partName;
        this.weight = weight;
    }

    public String getPartName() {
        return partName;
    }

    public int getWeight() {
        return weight;
    }

    @Override
    public int compareTo(Part other) {
        return Integer.compare(this.weight, other.weight);  // Sorting by weight
    }

    @Override
    public String toString() {
        return partName + ": " + weight + "kg";
    }
}

Aquí, la clase Part implementa la interfaz Comparable<Part>. El método compareTo() ordena las partes por weight utilizando Integer.compare(this.weight, other.weight).

En la clase principal, el método sorted() ordena el stream de partes en orden ascendente según su weight.

Ordenación con un Comparator

La segunda versión del método sorted() permite la ordenación utilizando un Comparator personalizado. Este método recibe un Comparator como parámetro, definiendo cómo deben compararse y ordenarse los elementos.

Stream<T> sorted(Comparator<? super T> comparator);

Con este enfoque, es posible especificar un orden de clasificación personalizado, lo que proporciona mayor control sobre cómo se organizan los elementos.

Ejemplo práctico

Suponga que es necesario ordenar una lista de empleados de fábrica por salario en orden descendente. Se utilizará el método sorted() con un comparador para lograrlo.

Main.java


              123456789101112131415161718192021222324252627282930313233343536373839404142434445
            
package com.example;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        // List of factory employees
        List<Employee> employees = Arrays.asList(
                new Employee("John", 50000),
                new Employee("Emily", 75000),
                new Employee("Michael", 45000),
                new Employee("Sophia", 60000)
        );

        // Sorting employees by salary in descending order
        employees.stream()
                .sorted(Comparator.comparingInt(Employee::getSalary).reversed())  // Sorting in descending order
                .forEach(System.out::println);
    }
}

class Employee {
    private String name;
    private int salary;

    public Employee(String name, int salary) {
        this.name = name;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public int getSalary() {
        return salary;
    }

    @Override
    public String toString() {
        return name + ": " + salary;
    }
}

Aquí se utilizó el comparador Comparator.comparingInt(Employee::getSalary).reversed(), que primero ordena a los empleados por salario en orden ascendente y luego aplica reversed() para cambiarlo a orden descendente.

¿Todo estuvo claro?

¡Gracias por tus comentarios!

Sección 2. Capítulo 5

Pregunte a AI

Pregunte lo que quiera o pruebe una de las preguntas sugeridas para comenzar nuestra charla

Suggested prompts:

Can you show an example of sorting a custom class using the natural order?

How do I implement the Comparable interface in my own class?

Can you explain how to use a custom Comparator with the sorted() method?

Awesome!

Completion rate improved to 2.33

Desliza para mostrar el menú

Ordenación por orden natural

El método sorted() está sobrecargado y tiene dos versiones. Comencemos con la primera:

Stream<T> sorted();

Ejemplo práctico

Main.java


              12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849
            
package com.example;

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        // List of factory parts
        List<Part> parts = Arrays.asList(
                new Part("Wheel", 10),
                new Part("Engine", 250),
                new Part("Brake", 15),
                new Part("Chassis", 80)
        );

        // Sorting parts by weight in ascending order
        parts.stream()
                .sorted()  // Sorting by natural order
                .forEach(System.out::println);
    }
}

class Part implements Comparable<Part> {
    private String partName;
    private int weight;

    public Part(String partName, int weight) {
        this.partName = partName;
        this.weight = weight;
    }

    public String getPartName() {
        return partName;
    }

    public int getWeight() {
        return weight;
    }

    @Override
    public int compareTo(Part other) {
        return Integer.compare(this.weight, other.weight);  // Sorting by weight
    }

    @Override
    public String toString() {
        return partName + ": " + weight + "kg";
    }
}

Aquí, la clase Part implementa la interfaz Comparable<Part>. El método compareTo() ordena las partes por weight utilizando Integer.compare(this.weight, other.weight).

En la clase principal, el método sorted() ordena el stream de partes en orden ascendente según su weight.

Ordenación con un Comparator

Stream<T> sorted(Comparator<? super T> comparator);

Con este enfoque, es posible especificar un orden de clasificación personalizado, lo que proporciona mayor control sobre cómo se organizan los elementos.

Ejemplo práctico

Suponga que es necesario ordenar una lista de empleados de fábrica por salario en orden descendente. Se utilizará el método sorted() con un comparador para lograrlo.

Main.java


              123456789101112131415161718192021222324252627282930313233343536373839404142434445
            
package com.example;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        // List of factory employees
        List<Employee> employees = Arrays.asList(
                new Employee("John", 50000),
                new Employee("Emily", 75000),
                new Employee("Michael", 45000),
                new Employee("Sophia", 60000)
        );

        // Sorting employees by salary in descending order
        employees.stream()
                .sorted(Comparator.comparingInt(Employee::getSalary).reversed())  // Sorting in descending order
                .forEach(System.out::println);
    }
}

class Employee {
    private String name;
    private int salary;

    public Employee(String name, int salary) {
        this.name = name;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public int getSalary() {
        return salary;
    }

    @Override
    public String toString() {
        return name + ": " + salary;
    }
}

¿Todo estuvo claro?

¡Gracias por tus comentarios!

Sección 2. Capítulo 5