Explorando a função sort() dentro da linguagem de programação Java
- #Java
Introdução
Na programação, funções são como blocos de construção essenciais, permitindo que trechos específicos de código sejam isolados e reutilizados. Neste artigo, exploraremos a função sort() em Java, destacando como essa ferramenta simplifica o processo de ordenação, tornando a manipulação de conjuntos de dados mais eficiente e direta. Inicialmente exploraremos o conceito de função, seguido de uma breve explicação sobre algoritmos de ordenação para então exploramos o função sort().
O que são funções?
Uma função em programação é um conceito que permite aos programadores isolarem trechos de códigos que realizam uma determinada tarefa para ser reutilizada posteriormente. Podemos comparar uma função com um liquidificador que recebe uma serie de ingredientes heterogêneos, bate/mistura todos eles e então devolve uma mistura homogêneo. A Figura 1 apresenta um esquema relacionado a tarefa de produzir uma vitamina de frutas.
Figura 1 - Processo de fazer uma vitamina de frutas
Fonte - Elaboração própria
Na programação os ingredientes heterogêneos seriam os parâmetros das funções, o processo de bater/misturar o corpo da função e o liquido homogêneo o retorno da função. O trecho de código apresenta a implementação desse processo na linguagem de programação Java utilizando o conceito de funções.
public String baterIngredientes(List<String> ingredientes) {
String mistura = "";
for(String ingrediente : ingredientes) {
mistura += ingrediente;
}
return mistura;
}
O código mostrado anteriormente implementa uma função denominada baterIngredientes() que simula o processo de bater/misturar do liquidificador, para tanto ela recebe uma lista de ingredientes como argumento List<String> ingredientes para serem misturados, faz a mistura dentro do corpo da função, ou seja, tudo que está entre {}, em seguida retorna a mistura dos ingredientes com a palavra reservada return.
O que é ordenação?
Outro conceito importante e amplamente estudado em ciência da computação é o de ordenação. Existem vários algoritmos de ordenação com diferentes complexidades, mas no fim das contas, todos buscam resolver o mesmo problema: dado um conjunto de elementos desordenados e um critério de ordenação, devolver um conjunto de elementos ordenado. O código abaixo apresenta a implementação do algoritmo de ordenação Bubble Sort[4] em Java.
void bubbleSort(int arr[])
{
int n = arr.length;
for (int i = 0; i < n - 1; i++)
for (int j = 0; j < n - i - 1; j++)
if (arr[j] > arr[j + 1]) {
// swap temp and arr[i]
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
Um algoritmo de ordenação pode ser modularizado dentro de uma função e é exatamente isso que linguagens de programação como o Java fazem ao utilizar o método sort(), tendo em vista que a ordenação de dados é essencial em diferentes contextos de uma aplicação.
O método sort() em Java
O método sort() em Java é utilizada para ordenar elementos em uma lista ou array. Ela permite que os dados sejam ordenados de acordo com um critério especifico, podendo ser a ordem alfabética, numérica ou um critério customizado. Vamos analisar em detalhes a sintaxe e funcionamento dessa função.
Sintaxe do método sort()
Em Java o método sort() está disponível nas seguintes classes:
- Arrays - Nesse caso o método sort() utiliza os algoritmos de ordenação Quicksort de dois pivôs e mergesort iterativo para fazer a ordenação de arrays de tipos primitivos e arrays de objetos respectivamente[1][2]. Veja a sintaxe de declaração do método sort() no código abaixo:
public static void sort(int[] a); //ordenação de tipos primitivos
public static <T> void sort(T[] a, Comparator<? super T> c); //ordenação de objetos
- Collections - Nessa classe o método sort() faz a ordenação de coleções e utiliza o algoritmo de ordenação TimSort para essa finalidade. Qualquer coleção de objetos personalizados pode ser ordenado com o método sort(), desde que implemente a interface Comparable ou forneça um Comparator personalizado[3]. Veja a sintaxe de declação do método a seguir:
public static <T extends Comparable<? super T>> void sort(List<T> list);
public static <T> void sort(List<T> list, Comparator<? super T> c)
Como utilizar o método sort()
Iremos utilizar a seguinte classe para fazer a ordenação de objetos personalizados:
public class Produto {
public String nome;
public double preco;
public int quantidade;
// Construtor
public Produto(String nome, double preco, int quantidade, String categoria) {
this.nome = nome;
this.preco = preco;
this.quantidade = quantidade;
}
@Override
public String toString() {
return "Produto{" +
"nome='" + nome + '\'' +
", preco=" + preco +
", quantidade=" + quantidade +
'}';
}
}
A classe implementada anteriormente representa um produto dentro de um supermercado, para fins de didáticos optei por deixar os atributos como public, mas em cenários reais isso não é o ideal a se fazer. Suponha que os seguintes produtos foram instanciados no programa principal da aplicação do supermercado:
public class Supermercado {
public static void main(String[] args) {
Product arroz = new Product("Arroz", 30.00, 8);
Product oleo = new Product("Oleo", 7.00, 2);
Product pneu = new Product("Pneu", 150.00, 15);
Product farinha = new Product("Farinha de milho", 10.00, 2);
Product chocolate = new Product("Chocolate", 7.90, 45);
}
}
Agora suponha que esses produtos estão armazenados em um array de produtos, como mostra o código a seguir:
public class Supermercado {
public static void main(String[] args) {
//..... código anterior
Produto[] produtos = new Produto[]{arroz, oleo, pneu, farinha, chocolate};
for (int i = 0; i < produtos.length; i++) System.out.println(produtos[i]);
}
}
Quando criamos um array de objetos personalizados, os objetos adicionados nessa estrutura mantém a ordem de inserção logo ao executar a aplicação a saída é:
Produto{nome='Arroz', preco=30.0, quantidade=8}
Produto{nome='Oleo', preco=7.0, quantidade=2}
Produto{nome='Pneu', preco=150.0, quantidade=15}
Produto{nome='Farinha de milho', preco=10.0, quantidade=2}
Produto{nome='Chocolate', preco=7.9, quantidade=45}
Mas suponha que os estoquistas do supermercado precisem que os produtos estejam ordenados pela quantidade do produto em ordem crescente e pelo nome do produto em ordem alfabética caso a quantidade seja a mesma. Como isso pode ser feito? É nesse ponto que o método sort entra em ação. Para utilizar o método sort vamos precisar importar a classe Arrays na nossa aplicação, em seguida precisaremos criar um Comparator para definir o critério de comparação mencionado anteriormente. Vamos ao código para entender como isso funciona:
import java.util.Arrays;
import java.util.Comparator;
public class Supermercado {
public static void main(String[] args) {
//..... código anterior
Produto[] produtos = new Produto[]{arroz, oleo, pneu, farinha, chocolate};
//definição do critério de comparação, usando um Comparator
Comparator<Produto> comparator = new Comparator<Produto>() {
@Override
public int compare(Produto p1, Produto p2) {
int aux = Integer.compare(p1.quantidade, p2.quantidade);
if(aux == 0) {
return p1.nome.compareToIgnoreCase(p2.nome);
};
return aux;
}
};
Arrays.sort(produtos, comparator); //uso do método sort
for (int i = 0; i < produtos.length; i++) System.out.println(produtos[i]);
}
}
Observe que para realizar uma ordenação personalizado é necessário criar um Comparator para dizer ao método sort como os objetos do array serão comparados durante a ordenação. Após a criação do Comparator basta utilizar o método Arrays.sort() fornecendoo como argumento o array a ser ordenado que no exemplo anterior são os produtos e o critério de comparação no nosso caso o comparator. A saida após a execução do programa é a seguinte
Produto{nome='Farinha de milho', preco=10.0, quantidade=2}
Produto{nome='Oleo', preco=7.0, quantidade=2}
Produto{nome='Arroz', preco=30.0, quantidade=8}
Produto{nome='Pneu', preco=150.0, quantidade=15}
Produto{nome='Chocolate', preco=7.9, quantidade=45}
Observe que os produtos foram ordenados em ordem crescente de quantidade e em caso de empate pela ordem alfabética do nome dos produtos.
No caso das coleções, o passo a passo é o mesmo o único cuidado que devemos ter é com a classe que deve ser importada para utilizar o método sort() que no caso das coleções é a Classe Collections. O código a seguir apresenta o mesmo exemplo, porém utilizando uma lista no lugar de um array.
import java.util.Collections;
import java.util.Comparator;
public class Supermercado {
public static void main(String[] args) {
//..... código anterior
List<Produto> produtos = new ArrayList<>();
produtos.add(arroz);
produtos.add(oleo);
produtos.add(pneu);
produtos.add(farinha);
produtos.add(chocolate);
//definição do critério de comparação, usando um Comparator
Comparator<Produto> comparator = new Comparator<Produto>() {
@Override
public int compare(Produto p1, Produto p2) {
int aux = Integer.compare(p1.quantidade, p2.quantidade);
if(aux == 0) {
return p1.nome.compareToIgnoreCase(p2.nome);
};
return aux;
}
};
Collections.sort(produtos, comparator); //uso do método sort
for (int i = 0; i < produtos.length; i++) System.out.println(produtos[i]);
}
}
É possível chamar o método sort() diretamente pelo objeto que representa a coleção, no exemplo acima poderíamos fazer produtos.sort(comparator);
Conclusão
As funções são conceitos importante dentro da programação, uma vez que elas permitem o reaproveitamento de código dentro de uma aplicação, um exemplo disso é o método sort() que é uma ferramenta essencial para qualquer programador Java, ele oferece flexibilidade e eficiência na ordenação de dados, seja para objetos complexos ou tipos primitivos. Espero que este artigo tenha esclarecido o uso desse método e inspirado você a explorá-lo ainda mais em seus projetos!
Referências
[1] https://www.geeksforgeeks.org/arrays-sort-in-java-with-examples/
[2] https://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html
[3] https://www.geeksforgeeks.org/sorting-custom-object-by-implementing-comparable-interface-in-java/
[4] https://www.geeksforgeeks.org/java-program-for-bubble-sort/
