Ordenando Lista de Objetos em Java

Pessoal, andei apanhando um pouco no trabalho, e achei essa solução, para ordenar um ArrayList,
segue abaixo o que salvou minha vida ahuahuahuaha :

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.

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

Resultado:

fogo
agua
vento
terra
Ordenando a lista:
agua
fogo
terra
vento

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.

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

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.

public class Carro implements Comparable {
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());
 }
 }

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.

List carros = new ArrayList();
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.");
 }

Resultado:

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.

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.

Fonte: blog.sippulse.com – Jonas Diogo

Anúncios