Uma das funções mais comuns de que precisamos como desenvolvedores que lidam com dados é a classificação - ao poder classificar nossos dados, podemos otimizar nossos algoritmos para serem executados muito mais rapidamente e encontrar os dados necessários em uma fração do tempo que seria necessário. levaria para o contrário. Na lição de hoje, falaremos sobre Java Collections sort(). Como um rápido experimento de pensamento: imagine que você está procurando um nome na lista de uma universidade. Pode haver dezenas de milhares de alunos nesta escola. Se a lista que você recebeu não estivesse em ordem alfabética, você precisaria folhear cada página e olhar com muito cuidado para ter certeza de não pular um único nome em nenhum lugar, até que finalmente encontre o nome que está procurando. Por outro lado, se a lista estiver em ordem alfabética, não só você terá que ser menos rigoroso na busca, como mas você poderia facilmente pular para a seção na lista com a mesma primeira letra e continuar a pular as páginas em grandes saltos até pousar na pessoa que estava procurando. Quanto mais dados você estiver trabalhando, mais importante será usá-los da maneira mais eficaz e eficiente possível. Neste artigo, veremos como classificar qualquer implementação de List em Java (incluindo ArrayList) usando o método de classificação Collections.
Como classificar um ArrayList em Java usando o método de classificação Java Collections
Vamos falar sobre o método Java Collections.sort. O pacote java.util contém muitos utilitários e pacotes úteis que são freqüentemente usados por desenvolvedores, incluindo o ArrayList. Suponha que você tenha o seguinte programa simples:
import java.util.*;
import java.io.*;
class Main{
public static void main(String[] args){
List<String> colors = new ArrayList<String>();
colors.add("Red ");
colors.add("Orange");
colors.add("Green");
colors.add("Blue");
}
}
Você deseja imprimir a lista de cores, mas em ordem alfabética. Como você pode fazer isso? Usando java.util.Collections, a classificação é tão fácil quanto uma linha:
Collections.sort(colors);
Ta-da! Sua lista de cores agora foi classificada no local. Se você fosse imprimir a lista, como tal:
System.out.println(colors);
Então você obteria a seguinte saída:
[Blue, Green, Orange, Red]
Quão fácil foi isso?! Seria igualmente fácil usar Collections.sort() para classificar em ordem crescente uma lista de Integers, Floats ou qualquer outro tipo de dados simples. Mas e se você quisesse classificar em ordem decrescente? Definitivamente, há casos em que isso faz sentido - imagine que você tenha uma lista de notas de teste para uma determinada turma e queira descobrir quem são os alunos com as melhores notas. Faria muito mais sentido classificar a lista em ordem decrescente (pontuações mais altas primeiro), para que as respostas que você está procurando estejam bem no topo. Felizmente, Collections.sort() é substituído por um segundo parâmetro opcional, que permite fazer exatamente isso:
sort(List l, Comparator c)
Mas o que é um comparador? Bem, um comparador é simplesmente uma função que compara duas entradas e retorna um número que representa qual entrada vem primeiro. Se você estiver classificando uma ArrayList de tipos de dados primitivos, as Coleções Java já fornecem um comparador reverseOrder(). Pode ser chamado assim:
Agora, as cores foram classificadas inversamente no local para que, se você as imprimir, obtenha a seguinte saída:
[Red, Orange, Green, Blue]
Como usar coleções para classificar tipos de dados não primitivos em Java
Até agora, você viu que classificar ArrayLists de strings ou ints em Java usando o método Collections.sort() é tão fácil quanto uma linha de código. Mas, muitas vezes, seus ArrayLists estarão armazenando tipos de dados não primitivos. Ao trabalhar com dados que possuem atributos mais complexos, você desejará escrever classes para representar esses objetos e como eles serão comparados entre si usando seus atributos. Para explorar um exemplo disso, vamos revisitar o exemplo de ordenação de uma lista de cores, mas desta vez, em vez de ordenar Strings, iremos ordenar objetos Color. Nossa classe Color básica pode se parecer com isto:
public class Color{
private int r;
private int g;
private int b;
private String name;
Color(String name, int red, int green, int blue){
this.name = name;
this.r = red;
this.g = green;
this.b = blue;
}
}
Para tornar nossa classe Color compatível com Collections.sort(), para que Collections entenda como comparar e ordenar objetos Color, precisamos fazer duas pequenas modificações:
faça Color um objeto Comparable (adicione implements Comparable<Object>)
substituir o método compareTo na classe (substituir public int compareTo(Object o))
Com essas modificações, nossa classe agora fica assim:
public class Color implements Comparable<Object>{
private int r;
private int g;
private int b;
private String name;
Color(int red int green, int blue, String name){
this.r = red;
this.g = green;
this.b = blue;
this.name = name;
}
@Override
public int compareTo(Object o) {
Color c = (Color) o;
return this.name.compareTo(c.name);
}
}
Observe que o método compareTo de Color simplesmente chama o método compareTo de String; a classificação será feita em ordem alfabética. Se quiséssemos classificar por valor vermelho em ordem crescente, por exemplo, poderíamos substituir a instrução return por return this.r - cr; (se quiséssemos classificar por valor verde em ordem decrescente, seria return cg - this.g;). Agora, se chamarmos
Collections.sort(colors);
em uma ArrayList de Colors em vez de apenas Strings, funcionaria porque Collections entende como comparar objetos Color. Se você não quiser que seu objeto implemente Comparable<Object>, você pode, alternativamente, escrever um comparador para sua classe e passá-lo para o método Collections.sort() de 2 parâmetros. Um comparador substitui um método public int compare(Object one, Object two), e o método Collections.sort() usa isso para comparar objetos durante a classificação. Um exemplo de comparadores SortByName e SortByRed é implementado abaixo:
class SortByName implements Comparator<Color>
{
public int compare(Color a, Color b)
{
return a.name.compareTo(b.name);
}
}
class SortByRGB implements Comparator<Color>
{
public int compare(Color a, Color b)
{
return a.r - b.r;
}
}
Com isso, você já pode ligar
Collections.sort(colors, new SortByName());
sem a classe Color realmente implementando Comparable, e ainda funcionará. Às vezes, você verá isso ser feito em linha, usando funções lambda. Uma função lambda é essencialmente uma função sem nome que você pode definir na linha de código que a chama. Eles são úteis quando você só precisa chamar uma função para uma instância específica e não deseja definir uma função totalmente separada em outro lugar. O comparador SortByName pode ser definido em linha, usando uma função lambda, como esta:
Como você deve ter adivinhado, (a, b) representa os parâmetros das funções lambda (os dois objetos a serem comparados). O -> significa que o que se segue é uma definição de função lambda. É sobre isso! Você já viu os métodos mais populares de classificação de ArrayLists em Java usando o pacote Collections.
GO TO FULL VERSION