Ordenar uma lista Me ajudem Pessoal...

Smalltalk Membro desde: 02/05/2008 18:41:54 Mensagens: 1 Offline

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

......

JavaChild Membro desde: 31/03/2006 14:01:52 Mensagens: 141 Offline

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:

1) Fazer a classe dos objetos que você quer ordenar implemenar a interface Comparable;

2) 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.

JavaEvangelist Membro desde: 13/10/2006 10:54:18 Mensagens: 338 Offline

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

ai tu vai ser forcado a implementar um metodo, o de ordenacao,
seguindo o criterio que tu quiser, no caso, o nome:

depois tu preenche a tua lista com um monte de pessoas, e faz:

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

Notícias, artigos e o maior fórum brasileiro sobre Java