Boa noite pessoal!!!
Quero ordenar uma lista, andei dando uma olhada aqui no forum mas nao encontrei o que preciso, sei que tenho que usar o Collections.sort mas não consegui tambem sei tenho que implementar uma classe com compareble e usar o compareTo, tentei e ão consegui alguem pode me ajudar???
tenho as seguinte classes
public class Pessoa {
private String nome;
private char sexo;
public Pessoa(String umNome, boolean masculino) {
nome = umNome;
if(masculino) {
sexo = 'M';
}
else {
sexo = 'F';
}
}
public String getNome() {
return nome;
}
public char getSexo() {
return sexo;
}
public String toString() {
return "["+nome+","+sexo+"]";
}
public boolean equals(Object o) {
if(o == null)
return false;
if(getClass() != o.getClass())
return false;
Pessoa outraPess = (Pessoa) o;
if((nome.equals(outraPess.nome)))
return true;
else
return false;
}
}
public class Cadastro {
private ListTAD<Pessoa> pessoas;
public Cadastro() {
pessoas = new ListSimpleLinked<Pessoa>();
}
public void adicionar(Pessoa p) {
pessoas.add(p);
}
public ListTAD<Pessoa> getHomens() {
ListTAD<Pessoa> tmp = new ListSimpleLinked<Pessoa>();
for (int i=0; i < pessoas.size(); i++) {
Pessoa p = pessoas.get(i);
if (p.getSexo() == 'M') {
tmp.add(p);
}
}
return tmp;
}
public ListTAD<Pessoa> getMulheres() {
ListTAD<Pessoa> tmp = new ListSimpleLinked<Pessoa>();
for (int i=0; i < pessoas.size(); i++) {
Pessoa p = pessoas.get(i);
if (p.getSexo() == 'F') {
tmp.add(p);
}
}
return tmp;
}
public String toString() {
return pessoas.toString();
}
}
public interface ListTAD<E>
{
/**
* Adiciona um elemento ao final da lista
* @param element elemento a ser adicionado ao final da lista
*/
public void add(E e);
/**
* Insere um elemento em uma determinada posição da lista
* @param index a posição da lista onde o elemento será inserido
* @param element elemento a ser inserido
* @throws IndexOutOfBoundsException se (index < 0 || index > size())
*/
public void add (int index, E element);
/**
* Esvazia a lista
*/
public void clear();
/**
* Retorna true se a lista contém o elemento especificado
* @param element o elemento a ser testado
* @return true se a lista contém o elemento especificado
*/
public boolean contains(E e);
/**
* Retorna o elemento de uma determinada posição da lista
* @param index a posição da lista
* @return o elemento da posição especificada
* @throws IndexOutOfBoundsException se (index < 0 || index >= size())
*/
public E get(int index);
/**
* Retorna o índice da primeira ocorrência do elemento na lista, ou -1 se a lista não contém o elemento
* @param element o elemento a ser buscado
* @return o índice da primeira ocorrência do elemento na lista, ou -1 se a lista não contém o elemento
*/
public int indexOf (E e);
/**
* Retorna true se a lista não contêm elementos
* @return true se a lista não contêm elementos
*/
public boolean isEmpty();
/**
* Remove a primeira ocorrência do elemento na lista, se estiver presente
* @param element o elemento a ser removido
* @return true se a lista contém o elemento especificado
*/
public boolean remove(E e);
/**
* Remove o elemento de uma determinada posição da lista
* @param index a posição da lista
* @return o elemento que foi removido da lista
* @throws IndexOutOfBoundsException se (index < 0 || index >= size())
*/
public E remove(int index);
/**
* Retorna o número de elementos da lista
* @return o número de elementos da lista
*/
public int size();
/**
* Substitui o elemento armanzenado em uma determinada posição da lista pelo elemento indicado
* @param index a posição da lista
* @param element o elemento a ser armazenado na lista
* @return o elemento anterior armazenado na posição da lista
* @throws IndexOutOfBoundsException se (index < 0 || index >= size())
*/
public E set(int index, E element);
public void addFirst(E e);
public E getFirst();
public E getLast();
public boolean removeFirst();
public boolean removeLast();
/**
* Ordena a lista de acordo com a ordenação natural dos elementos, que devem implementar a interface Comparable
*/
public void sort();
}
public class ListSimpleLinked<E> implements ListTAD<E>
{
// Referência para o primeiro elemento da lista encadeada.
private Nodo<E> prim;
// Referência para o último elemento da lista encadeada.
private Nodo<E> ult;
// Contabiliza o número de elementos da lista.
private int totalElementos;
// Classe interna Nodo
private class Nodo<T> {
private T element;
private Nodo<T> next;
public Nodo(T e) {
element = e;
next = null;
}
public void setElement(T e) {
element = e;
}
public void setNext (Nodo<T> n) {
next = n;
}
public T getElement() {
return element;
}
public Nodo<T> getNext() {
return next;
}
}
public ListSimpleLinked () {
prim = null;
ult = null;
totalElementos = 0;
}
/**
* Adiciona um elemento ao final da lista
* @param element elemento a ser adicionado ao final da lista
*/
public void add(E e) {
Nodo<E> n = new Nodo<E>(e);
if (ult != null)
ult.setNext(n);
else
prim = n;
ult = n;
totalElementos++;
}
/**
* Insere um elemento em uma determinada posição da lista
* @param index a posição da lista onde o elemento será inserido
* @param element elemento a ser inserido
* @throws IndexOutOfBoundsException se (index < 0 || index > size())
*/
public void add (int index, E element)
{
Nodo<E> aux = prim;
Nodo<E> n = new Nodo<E> (element);
int i=0;
if (index < 0 || index > totalElementos ) // índice inválido
throw new IndexOutOfBoundsException();
else if (index == 0) // inserção no início
{
if (prim == null)
ult = n;
else n.setNext(prim);
prim = n;
totalElementos++;
}
else
{
while(i<(index-1) && aux != null)
{
aux = aux.getNext();
i++;
}
if ( aux == ult )// inserção no fim
{
if (ult == null)
prim = n;
else
ult.setNext(n);
ult = n;
totalElementos++;
}
else // inserção no meio
{
n.setNext(aux.getNext());
aux.setNext(n);
totalElementos++;
}
}
}
/**
* Esvazia a lista
*/
public void clear() {
prim = null;
ult = null;
totalElementos = 0;
}
/**
* Retorna true se a lista contém o elemento especificado
* @param element o elemento a ser testado
* @return true se a lista contém o elemento especificado
*/
public boolean contains(E e) {
Nodo<E> aux;
aux = prim;
while(aux != null){
if (aux.getElement().equals(e))
return true;
aux = aux.getNext();
}
return false;
}
/**
* Retorna o elemento de uma determinada posição da lista
* @param index a posição da lista
* @return o elemento da posição especificada
* @throws IndexOutOfBoundsException se (index < 0 || index >= size())
*/
public E get(int index)
{
Nodo<E> aux;
E element = null;
if(index<0 || index>=totalElementos)
throw new IndexOutOfBoundsException();
if (index==0) // retorna o primeiro
element = prim.getElement();
else if (index==(totalElementos-1))
element = ult.getElement(); // retorna o último
else
{
aux = prim.getNext();
for(int i=1; i<index; i++)
aux = aux.getNext();
element = aux.getElement();
}
return element;
}
/**
* Retorna o índice da primeira ocorrência do elemento na lista, ou -1 se a lista não contém o elemento
* @param element o elemento a ser buscado
* @return o índice da primeira ocorrência do elemento na lista, ou -1 se a lista não contém o elemento
*/
public int indexOf (E e)
{
Nodo<E> aux=prim;
int i = 0;
while(aux != null) {
if ( aux.getElement().equals(e) )
return i;
aux = aux.getNext();
i++;
}
return -1;
}
/**
* Retorna true se a lista não contêm elementos
* @return true se a lista não contêm elementos
*/
public boolean isEmpty() {
if (prim == null)
return true;
else
return false;
}
/**
* Remove a primeira ocorrência do elemento na lista, se estiver presente
* @param element o elemento a ser removido
* @return true se a lista contém o elemento especificado
*/
public boolean remove(E e) {
Nodo<E> ant, aux;
if (prim == null)
return false;
if ( prim.getElement().equals(e) )
{
if (ult == prim)
ult = null;
prim = prim.getNext();
totalElementos--;
return true;
}
ant = prim;
aux = prim.getNext();
while(aux != null)
{
if ( aux.getElement().equals(e) ) {
if (aux == ult)
ult = ant;
ant.setNext(aux.getNext());
totalElementos--;
return true;
}
else {
ant = aux;
aux = aux.getNext();
}
}
return false;
}
/**
* Remove o elemento de uma determinada posição da lista
* @param index a posição da lista
* @return o elemento que foi removido da lista
* @throws IndexOutOfBoundsException se (index < 0 || index >= size())
*/
public E remove(int index)
{
Nodo<E> aux,ant;
E element = null;
if (index<0 || index>=totalElementos)
throw new IndexOutOfBoundsException();
if (index==0) { // remove o primeiro
element = prim.getElement();
if (ult == prim)
ult = null;
prim = prim.getNext();
totalElementos--;
}
else
{
ant = prim;
aux = prim.getNext();
for(int i=1; i<index; i++)
{
ant = ant.getNext();
aux = aux.getNext();
}
ant.setNext(aux.getNext());
element = aux.getElement();
totalElementos--;
if (aux == ult)
ult = ant;
}
return element;
}
/**
* Retorna o número de elementos da lista
* @return o número de elementos da lista
*/
public int size() {
return totalElementos;
}
/**
* Substitui o elemento armanzenado em uma determinada posição da lista pelo elemento indicado
* @param index a posição da lista
* @param element o elemento a ser armazenado na lista
* @return o elemento anterior armazenado na posição da lista
* @throws IndexOutOfBoundsException se (index < 0 || index >= size())
*/
public E set(int index, E element) {
if (index<0 || index>=totalElementos)
throw new IndexOutOfBoundsException();
Nodo<E> aux = prim;
for(int i=0; i<index; i++){
aux = aux.getNext();
}
E elem = aux.getElement();
aux.setElement(element);
return elem;
}
public void addFirst(E e) {
Nodo<E> novo = new Nodo<E>(e);
if (prim == null)
ult = novo;
else
novo.setNext(prim);
prim = novo;
totalElementos++;
}
public E getFirst() {
if (prim != null)
return prim.getElement();
else
return null;
}
public E getLast() {
if (ult != null)
return ult.getElement();
else
return null;
}
public boolean removeFirst() {
if (prim == null)
return false;
else {
if (ult == prim)
ult = null;
prim = prim.getNext();
totalElementos--;
return true;
}
}
public boolean removeLast() {
if (prim == null)
return false;
else {
if (ult == prim)
{
ult = null;
prim = null;
}
else {
Nodo<E> aux = prim;
while (aux.getNext() != ult)
aux = aux.getNext();
aux.setNext(null);
ult = aux;
}
totalElementos--;
return true;
}
}
/**
* Ordena a lista de acordo com a ordenação natural dos elementos, que devem implementar a
* interface Comparable
*/
public void sort()
{
//é aqui que tenho que fazer a ordenação
}
}
......
Ordenar uma lista Me ajudem Pessoal
R
3 Respostas
M
Olá.
Você poderia nos ajudar colocando seu código entre as tags “code”. 
Agora com relação ao seu questionamento, você pode fazer o seguinte:
-
Fazer a classe dos objetos que você quer ordenar implemenar a interface Comparable;
-
Você terá que implementar o método chamado compareTo(T t) {} que retorna um inteiro (>0, <0, ==0). Implementando a interface Comparable você terá apenas um critério de comparação. Dê uma pesquisada sobre a interface Comparator, que seria útil para você classificar seus objetos segundo outros critérios;
É por ai, pesquise aqui no fórum mesmo que tem muita coisa a respeito, se eu explicar tudo perde a graça.
Abraços.
Se você estivar atrás de um algoritmo de ordenção pra usar, bons candidados pra esse caso são o MergeSort e o QuickSort, na wikipedia tem tudo!
pega a tua classe Pessoa e faz
public class Pessoa implements Comparable<Pessoa>
ai tu vai ser forcado a implementar um metodo, o de ordenacao,
seguindo o criterio que tu quiser, no caso, o nome:
public int compareTo(Pessoa outraPessoa) {
return nome.compareTo(outraPessoa.nome);
}
depois tu preenche a tua lista com um monte de pessoas, e faz:
Collections.sort(minhaListaDePessoas);
OBS: vc tem outa opcao:
chegue a um colega de faculdade de sua sala que ja fez e peca
pra ele fazer o seu.
flw
Criado 2 de maio de 2008
Ultima resposta 3 de mai. de 2008
Respostas 3
Participantes 4
Alura O que é Python? — um guia completo para iniciar nessa linguagem de programação Acesse agora o guia sobre Python e inicie sua jornada nessa linguagem de programação: o que é e para que serve, sua sintaxe e como iniciar nela!
Casa do Codigo Engenharia de Prompt para Devs: Um guia para aprender a... Por Ricardo Pupo Larguesa — Casa do Codigo