Aprenda Organizando Itens em Ordem com o Método sorted() | Operações Intermediárias na Stream API

Na Stream API do Java, o método sorted() permite ordenar os elementos do stream de forma eficiente. A ordenação é uma operação fundamental, pois simplifica o processamento de dados, facilitando a organização dos elementos na ordem desejada.

Ordenação em Ordem Natural

O método sorted() é sobrecarga e possui duas versões. Vamos começar com a primeira:

Stream<T> sorted();

Esta versão ordena os elementos com base em sua ordenação natural. Para utilizar este método, os elementos devem implementar a interface Comparable, o que permite que sejam automaticamente comparados e ordenados.

Exemplo Prático

Imagine uma fábrica com várias peças, cada uma com um peso único. O objetivo é ordenar essas peças em ordem crescente com base em seu peso utilizando a interface 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";
    }
}

Aqui, a classe Part implementa a interface Comparable<Part>. O método compareTo() ordena as peças por weight utilizando Integer.compare(this.weight, other.weight).

Na classe principal, o método sorted() ordena o stream de peças em ordem crescente com base no seu weight.

Ordenação com um Comparator

A segunda versão do método sorted() permite a ordenação utilizando um Comparator personalizado. Este método recebe um Comparator como parâmetro, definindo como os elementos devem ser comparados e ordenados.

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

Com esta abordagem, é possível especificar uma ordem de classificação personalizada, proporcionando mais controle sobre como os elementos são organizados.

Exemplo Prático

Suponha que seja necessário ordenar uma lista de funcionários de fábrica por salário em ordem decrescente. Utilize o método sorted() com um comparador para alcançar esse resultado.

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;
    }
}

Aqui, foi utilizado o comparador Comparator.comparingInt(Employee::getSalary).reversed(), que primeiro ordena os funcionários pelo salário em ordem crescente e, em seguida, aplica reversed() para alterar para ordem decrescente.

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 2. Capítulo 5

Pergunte à IA

Pergunte o que quiser ou experimente uma das perguntas sugeridas para iniciar nosso bate-papo

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

Deslize para mostrar o menu

Ordenação em Ordem Natural

O método sorted() é sobrecarga e possui duas versões. Vamos começar com a primeira:

Stream<T> sorted();

Exemplo Prático

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";
    }
}

Aqui, a classe Part implementa a interface Comparable<Part>. O método compareTo() ordena as peças por weight utilizando Integer.compare(this.weight, other.weight).

Na classe principal, o método sorted() ordena o stream de peças em ordem crescente com base no seu weight.

Ordenação com um Comparator

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

Com esta abordagem, é possível especificar uma ordem de classificação personalizada, proporcionando mais controle sobre como os elementos são organizados.

Exemplo Prático

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;
    }
}

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 2. Capítulo 5