Quem nunca na sua vida de programador, seja iniciando pela linguagem de programação C ou direto pelo Java, não enfrentou alguns problemas com Segmentation fault e NullPointException ao trabalhar-se com vetores, principalmente por se acessar índices que não existiam. Na linguagem de programação C não existe muita escapatória para esses casos, além de implementar toda a lógica para a manipulação desses vetores. Um dos exercícios clássicos em C é o de ordenar um vetor em ordem crescente ou decrescente, utilizando-se de alguma lógica com fors e ifs.
Ao iniciar o estudo em Java, também aprendemos a utilizar primeiramente os vetores e enfrentamos os mesmos problemas que no C, até fazemos os mesmos exercícios já feitos em C sobre vetores. Mas ai pensamos, Java sendo uma linguagem de mais alto nivel que o C, será que não existe uma solução mais elegante? A resposta vem da Collections Framework, que é uma API robusta criada pela Sun que possui diversas classes que representam estruturas de dados avançadas, como ArrayList e LinkedList, e funções úteis para se trabalhar com vetores.
O objetivo desse artigo não é dar toda explicação de como utilizar a sintaxe da API Collections, sendo os dois primeiros parágrafos uma breve introdução sobre o assunto, mas sim de como ordenar uma lista de objetos em Java sem ter que implementar nenhuma lógica mirabolante. Uma lista de objetos em Java pode ser facilmente ordenada utilizando o método sort da API Collections. Como exemplo iremos criar uma lista de strings e adicionar algumas palavras nela, depois iremos imprimir essa lista para ver sua ordem. Depois executaremos o método sort para ordenar a lista e imprimiremos novamente a lista para comparar o resultado.
[sourcecode language=”java”]
List<String> lista = new ArrayList<String>();
lista.add(“fogo”);
lista.add(“agua”);
lista.add(“vento”);
lista.add(“terra”);
for(String i : lista){
System.out.println(i);
}
Collections.sort(lista);
System.out.println(“Ordenando a lista:”);
for(String i : lista){
System.out.println(i);
}
[/sourcecode]
Resultado:
[sourcecode language=”powershell”]
fogo
agua
vento
terra
Ordenando a lista:
agua
fogo
terra
vento
[/sourcecode]
Como pode ser visto acima, a lista foi reordenada em ordem crescente. Mas como o método sort sabia como organizar a lista? Ele precisa utilizar um método int compareTo(Object) para poder ordenar a lista, que retorna zero, se o objeto comparado for igual a este objeto, um número negativo, se este objeto for menor que objeto dado, e um número positivo, se este objeto for maior que o objeto dado. Este método está definido na interface Comparable, que deve ser implementado pela classe que será ordenado em uma lista. Não é necessariamente obrigatório que a classe implemente a interface Comparable, ao chamar o método sort pode também ser passado como parâmetro além da lista que será ordenada um método que fará a ordenação.
Entendemos como à ordenação é feita, mais ainda assim não implementamos a interface Comparable e nenhuma logica para a ordenação. Como a lista pode ser ordenada com o método sort? A resposta é que a classe string já implementa a interface Comparable que ordena em ordem alfabética seus elementos. Outras classes em Java que implementam essa interface são: BigDecimal, BigInteger, Byte, ByteBuffer, Character, CharBuffer, Charset, CollationKey, Date, Double, DoubleBuffer, File, Float, FloatBuffer, IntBuffer, Integer, Long, LongBuffer, ObjectStreamField, Short, ShortBuffer e URI que podem ser ordenadas simplesmente utilizando-se o método sort.
Agora chegamos ao caso se quisermos ordenar uma lista de objetos de uma classe que nós mesmos criamos. Para isso a nossa classe deve implementar a interface Comparable. Utilizaremos como exemplo a classe abaixo chamada carro, que contém apenas dois atributos, cilindrada e cor, e um construtor que recebe esses atributos.
[sourcecode language=”java”]
public class Carro {
private String cor;
private int cilindrada;
public Carro(String cor, int cilindrada) {
super();
this.cor = cor;
this.cilindrada = cilindrada;
}
public String getCor() {
return cor;
}
public void setCor(String cor) {
this.cor = cor;
}
public int getCilindrada() {
return cilindrada;
}
public void setCilindrada(int cilindrada) {
this.cilindrada = cilindrada;
}
}
[/sourcecode]
Realizaremos agora as modificações necessárias na nossa classe carro para que possamos ordenar uma lista da nossa classe utilizando o método sort. Primeiramente a nossa classe deve implementar a intarface Comparable e consequentemente implementar o método sort, lembrando que este método retorna zero se o objeto é igual, um numero negativo se for menor e um numero positivo se for maior. Iremos também decidir como queremos a ordenação da nossa lista de carros seja feita, a ordenação será feita em ordem decrescente de cilindrada, e em caso de ter igual será ordenado em ordem alfabética de cor. A classe finalizada por ser vista abaixo.
[sourcecode language=”java”]
public class Carro implements Comparable<Carro> {
private String cor;
private int cilindrada;
public Carro(String cor, int cilindrada) {
super();
this.cor = cor;
this.cilindrada = cilindrada;
}
public String getCor() {
return cor;
}
public void setCor(String cor) {
this.cor = cor;
}
public int getCilindrada() {
return cilindrada;
}
public void setCilindrada(int cilindrada) {
this.cilindrada = cilindrada;
}
public int compareTo(Carro carro) {
if(this.cilindrada > carro.cilindrada){
return -1;
}
else if(this.cilindrada < carro.cilindrada){
return 1;
}
return this.getCor().compareToIgnoreCase(carro.getCor());
}
}
[/sourcecode]
Para mostrar que a ordenação realmente funcionou, iremos fazer um teste, onde criaremos uma lista de carros, adicionaremos alguns carros há lista, alguns com mesma cilindradas e cores diferentes. Depois iremos imprimir essa lista de carros, executar o método sort e exibir de novo a lista para ver se a ordenação realmente ocorreu.
[sourcecode language=”java”]
List<Carro> carros = new ArrayList<Carro>();
carros.add(new Carro(“Azul”,500));
carros.add(new Carro(“Verde”,300));
carros.add(new Carro(“Laranja”,700));
carros.add(new Carro(“Marrom”,300));
carros.add(new Carro(“Amarelo”,700));
for(Carro c : carros){
System.out.println(“Carro de cor “+c.getCor()+” e “+c.getCilindrada()+” cilindradas.”);
}
Collections.sort(carros);
System.out.println(“Ordenando a lista:”);
for(Carro c : carros){
System.out.println(“Carro de cor “+c.getCor()+” e “+c.getCilindrada()+” cilindradas.”);
}
[/sourcecode]
Resultado:
[sourcecode language=”powershell”]
Carro de cor Azul e 500 cilindradas.
Carro de cor Verde e 300 cilindradas.
Carro de cor Laranja e 700 cilindradas.
Carro de cor Marrom e 300 cilindradas.
Carro de cor Amarelo e 700 cilindradas.
Ordenando a lista:
Carro de cor Amarelo e 700 cilindradas.
Carro de cor Laranja e 700 cilindradas.
Carro de cor Azul e 500 cilindradas.
Carro de cor Marrom e 300 cilindradas.
Carro de cor Verde e 300 cilindradas.
[/sourcecode]
Como esperado a ordenação funcionou corretamente. Era isso que este artigo proponha a se tratar, pode ser algo simples para algumas pessoas, mas para quem não conhece pode ser de grande ajuda, facilitando muito o seu trabalho.
Dúvidas? Sugestões? Deixe seu comentário!
PT_BR 
EN