Pilhas

Olá galera =) irei postar meu código sobre pilhas abaixo e queria que analisassem e dissessem o que acharam:

Classe com os método push e pop:

[code]import javax.swing.JOptionPane;

public class MetodosStack {
public String [] elemento=new String [10];
public String resultado="";
public int i;

public void push(int i){
    for(i=0;i<10;i++){
	   this.elemento[i]=JOptionPane.showInputDialog("Digite"+" "+(i+1)+"º"+" elemento");

	    if( ((String)this.elemento[i]).isEmpty()){
    	
		   JOptionPane.showMessageDialog(null,"O elemento não pode ser nulo"); 
		   System.exit(1);

	    }
    
    
     }

     for(i=10-1;i>=0;i--){
	   resultado=resultado+((i+1)+"["+this.elemento[i])+"]"+"\n";
	   JOptionPane.showMessageDialog(null,"Sua pilha está assim: "+"\n"+resultado);	

     }


 }
 public String pop() {
    if(this.elemento[i].isEmpty()){
		JOptionPane.showMessageDialog(null,"Adicione um elemento a pilha!!!");
	}
    for(i=10-1;i>=5;i--){
	     String resultado=" ";
    	 resultado=resultado+"Removendo "+(i+1)+"º "+"elemento: "+"\n"+(i+1)+"["+(this.elemento[i])+"]"+"\n";
	     JOptionPane.showMessageDialog(null,"\n"+resultado);
    }
    for(i=5-1;i>=0;i--){
    	String resultado;
    	resultado=((i+1)+"["+this.elemento[i]+"]")+"\n";
    	JOptionPane.showMessageDialog(null,"Pilha atual: "+"\n"+resultado+"\n");
    	
    }
  return resultado=" ";
	   
   	
 }   

}
[/code]

Classe principal:

[code]import javax.swing.JOptionPane;
public class PrincipalStack {

/**
 * by:Robson Barreto
 */
public static void main(String[] args) {
	// TODO Auto-generated method stub
MetodosStack stack= new MetodosStack();

int op=0;
do{
op=Integer.parseInt(JOptionPane.showInputDialog(“Selecione uma opção: “+”\n”+“1- Empilhar”+"\n"+“2-Desempilhar”));

switch(op){

case 1:stack.push(0);
break;

  case 2: 
	  
	  JOptionPane.showMessageDialog(null,"\n"+stack.pop());
  break;

}
}while(op!=0);

}

}[/code]

Obrigado !!!

bacana… mas… e qual é a sua duvida?

Analisei meio por cima.

Então, não faz muito sentido você ler os elementos/listar dentro da classe da pilha.

Segundo, sua pilha esta limitada a somente 10 elementos(a não ser que tenha sido de proposito)

Terceiro, não é legal ficar concatenando String desta forma

"Removendo "+(i+1)+"º "+"elemento: "+"\n"

Dê uma olhada em StringBuilder

Se quiser aprender mais sobre pilha, dê uma olhada na classe java.util.LinkedList (Não utiliza vetor, e sim uma lista ligada)

[quote=magostta]Analisei meio por cima.

Então, não faz muito sentido você ler os elementos/listar dentro da classe da pilha.

Segundo, sua pilha esta limitada a somente 10 elementos(a não ser que tenha sido de proposito)

Terceiro, não é legal ficar concatenando String desta forma

"Removendo "+(i+1)+"º "+"elemento: "+"\n"

Dê uma olhada em StringBuilder

Se quiser aprender mais sobre pilha, dê uma olhada na classe java.util.LinkedList (Não utiliza vetor, e sim uma lista ligada)
[/quote]

Cara valeu pelas dicas porém esse código foi feito para ter só 10 elementos mesmo, o propósito dele é mais didático, visto que foi feito como trabalho para explicar o conceito de pilha para a turma onde eu estudo !!!

java.teen,

Eu analisei e achei que não ficou boa a separação de responsabilidades entre as classes.
Explico: em projeto orientado a objetos, é importante que cada classe possua responsabilidades bem definidas. É o conceito de coesão.
Normalmente uma classe pilha fica responsável apenas por guardar os elementos da pilha, empilhar, desempilhar e gerenciar a pilha. Pode usar um vetor para isso.
Uma outra classe ficaria responsável por interagir com o usuário e manipular a pilha.
Também não é necessário empilhar todos os 10 elementos e desempilhar os 10 de uma vez. Pode ficar por conta do usuário empilhar ou desempilhar à vontade.

No tópico abaixo tem um exemplo muito bom de pilha, do Mantu (Luciano Mantuaneli). No construtor da classe SimpleStack você passa o número máximo de elmentos da pilha, que será o tamanho do vetor:

Tomei a liberdade de usar a classe SimpleStack do Mantu e criei um código que o usuário pode usar para empilhar e desempilhar. Rode e veja o que você acha:

[code]import javax.swing.*;

public class Main {
static SimpleStack pilha = new SimpleStack(10);

public static void main(String[] args) {  
    int op;

    while(true){
        String resposta = JOptionPane.showInputDialog(null, "Selecione uma opcao: \n"+
                                                     "1 - Empilhar\n"+
                                                     "2 - Desempilhar\n"+
                                                     "3 - Listar");
        if(resposta == null) return;

        try{
           op = Integer.parseInt(resposta);
        }catch(NumberFormatException e){
           JOptionPane.showMessageDialog(null, "Opcao invalida.");
           continue;
        }

        switch(op){
        case 1:
           empilhar();
           break;
        case 2:
           desempilhar();
           break;
        case 3:
           listar();
           break;
        }
    }
}

private static void empilhar(){
    String valor = JOptionPane.showInputDialog(null, "Digite o elemento a inserir na pilha: ");
    valor = pilha.push(valor);
    if(valor == null){
        JOptionPane.showMessageDialog(null,"A pilha está cheia.");
    }
}

private static void desempilhar(){
    String valor = pilha.pop();
    if(valor == null){
        JOptionPane.showMessageDialog(null,"Não ha mais elementos na pilha.");
    }else{
        JOptionPane.showMessageDialog(null,"Desempilhado o elemento: "+valor);
    }
}

private static void listar(){
    JOptionPane.showMessageDialog(null, pilha.toString());
} 

}[/code]

[code]/**

  • @author luciano.mantuaneli
  • @date 01/04/2008
    */
    //package br.com.mantu.help.guj.zagaia.stack;

/**

  • @author luciano.mantuaneli

  • @date 01/04/2008
    /
    public class SimpleStack {
    /
    *

    • Vetor de String que armazenará os elementos.
    • Se uma posição estiver nula, esta posição será encarada como uma posição
    • vazia na pilha. Sendo assim, nunca poderá existir uma posição vazia
    • seguida de uma posição não-vazia(diferente de null), pois isso indicaria
    • que, de alguma forma, removemos algum elemento da pilha que não o do topo.
      /
      private String[] elements;
      /
      *
    • inteiro que indicará quantos elementos NÃO NULOS existem dentro de
    • elements. Note por exemplo que:
    • -Se size for igual a 26, o topo da pilha está na posição 25 de elements
    • -Se size for igual a 10, o topo da pilha está na posição 9 de elements
    • -Se size for igual a n, o topo da pilha está na posição (n - 1) de elements
    • Resumindo, podemos assumir QUASE sempre que o topo da pilha é a posição
    • (size - 1) de elements.
    • O “quase” se deve ao caso de quando nossa pilha é vazia. Nesse caso,
    • size é igual a 0. Se fossemos seguir a regra acima indistintamente,
    • acabaríamos assumindo que neste caso o topo da pilha está na posição -1
    • de elements, o que é um erro… Trata-se então de uma exceção, a qual
    • deveremos estar atentos para fazer bobagem!
    • Para fins didáticos, criaremos um método privado que retorna a posição
    • exata do topo da pilha, e sempre utilizaremos este método para termos tal
    • informação.
      */
      private int size;

    /**

    • Construtor que recebe um int como parâmetro, indicando qual será a
    • capacidade da pilha recém-instanciada
      /
      public SimpleStack(int capacity) {
      /
      • Utilizamos o método abs da classe Math só pra evitar que se tente
      • criar uma pilha “devedora”…
        */
        elements = new String[Math.abs(capacity)];
        size = 0;
        }

    /**

    • Método utilizado para adicionar elementos à nossa pilha. Este elemento

    • sempre será inserido no topo deta pilha.

    • -Se o elemento for null, vamos lançar uma exceção, informando que nossa

    • pilha não aceita null como elemento válido.

    • -Se a pilha estiver cheia, retornamos null para indicar que não foi

    • possível insirir elemento.

    • -Se o elemento for inserido com sucesso, retornamos o próprio elemento,

    • indicando assim o sucesso da operação
      */
      public String push(String element) {
      if(element == null)
      throw new IllegalArgumentException(“O elemento não pode ser nulo!”);

      if(size == elements.length)
      return null;

      size++;
      elements[getTopPosition()] = element;
      return element;
      }

    /**

    • Método utilizado para se obter o elemento que está no topo desta pilha,

    • porém, sem removê-lo da mesma.

    • -Se a pilha estiver vazia, retornamos null para indicar que a pilha

    • está vazia.

    • -Se houver ao menos um elemento na pilha, o elemento que está no topo

    • será retornado, indicando o sucesso da operação
      */
      public String peek() {
      if(isEmpty())
      return null;

      return elements[getTopPosition()];
      }

    /**

    • Método utilizado para retirar(“destacar”) um elemento desta pilha. Este
    • elemento sempre será aquele que se encontra no topo desta pilha.
    • -Se a pilha estiver vazia, retornamos null para indicar que a pilha
    • está vazia.
    • -Se houver ao menos um elemento na pilha, o elemento que está no topo
    • será retornado, indicando o sucesso da operação
      */
      public String pop() {
      String result = peek();
      /Se havia um elemento no topo da pilha…/
      if(result != null) {
      elements[getTopPosition()] = null;
      size–;
      }
      return result;
      }

    /**

    • Método utilizado para limpar todo o conteúdo da pilha.
      */
      public void clear() {
      for(int i = 0; i < size; i++)
      elements[i] = null;
      size = 0;
      }

    /**

    • Método utilizado para se obter o tamanho (número de elementos) da pilha
      */
      public int getSize() {
      return size;
      }

    /**

    • Método utilizado para se obter a capacidade da pilha
      */
      public int getCapacity() {
      return elements.length;
      }

    /**

    • Método utilizado para verificar se a pilha está vazia. Se for o caso,
    • será retornado true, caso contrário, será retornado false.
      */
      public boolean isEmpty() {
      return size <= 0;
      }

    /**

    • Este método tem uma finalidade estritamente didática, visando facilitar o
    • entendimento do código desta classe.
    • Este método retorna um inteiro que representa a posição de elements onde
    • se encontra o último elemento inserido nesta pilha (O topo da pilha)
      */
      private int getTopPosition() {
      if (isEmpty())
      return 0;
      return size - 1;
      }

    /**

    • Este método serve para representar textualmente esta pilha

    • @see java.lang.Object#toString()
      */
      public String toString() {
      StringBuilder sb = new StringBuilder("[");
      for(int i = 0; i < size; i++) {
      sb.append(elements[i]);
      if(i < size - 1)
      sb.append(" | “);
      }
      sb.append(”>");

      return sb.toString();
      }
      } [/code]

[quote=al.barbosa]java.teen,

Eu analisei e achei que não ficou boa a separação de responsabilidades entre as classes.
Explico: em projeto orientado a objetos, é importante que cada classe possua responsabilidades bem definidas. É o conceito de coesão.
Normalmente uma classe pilha fica responsável apenas por guardar os elementos da pilha, empilhar, desempilhar e gerenciar a pilha. Pode usar um vetor para isso.
Uma outra classe ficaria responsável por interagir com o usuário e manipular a pilha.
Também não é necessário empilhar todos os 10 elementos e desempilhar os 10 de uma vez. Pode ficar por conta do usuário empilhar ou desempilhar à vontade.

No tópico abaixo tem um exemplo muito bom de pilha, do Mantu (Luciano Mantuaneli). No construtor da classe SimpleStack você passa o número máximo de elmentos da pilha, que será o tamanho do vetor:

Tomei a liberdade de usar a classe SimpleStack do Mantu e criei um código que o usuário pode usar para empilhar e desempilhar. Rode e veja o que você acha:

[code]import javax.swing.*;

public class Main {
static SimpleStack pilha = new SimpleStack(10);

public static void main(String[] args) {  
    int op;

    while(true){
        String resposta = JOptionPane.showInputDialog(null, "Selecione uma opcao: \n"+
                                                     "1 - Empilhar\n"+
                                                     "2 - Desempilhar\n"+
                                                     "3 - Listar");
        if(resposta == null) return;

        try{
           op = Integer.parseInt(resposta);
        }catch(NumberFormatException e){
           JOptionPane.showMessageDialog(null, "Opcao invalida.");
           continue;
        }

        switch(op){
        case 1:
           empilhar();
           break;
        case 2:
           desempilhar();
           break;
        case 3:
           listar();
           break;
        }
    }
}

private static void empilhar(){
    String valor = JOptionPane.showInputDialog(null, "Digite o elemento a inserir na pilha: ");
    valor = pilha.push(valor);
    if(valor == null){
        JOptionPane.showMessageDialog(null,"A pilha está cheia.");
    }
}

private static void desempilhar(){
    String valor = pilha.pop();
    if(valor == null){
        JOptionPane.showMessageDialog(null,"Não ha mais elementos na pilha.");
    }else{
        JOptionPane.showMessageDialog(null,"Desempilhado o elemento: "+valor);
    }
}

private static void listar(){
    JOptionPane.showMessageDialog(null, pilha.toString());
} 

}[/code]

[code]/**

  • @author luciano.mantuaneli
  • @date 01/04/2008
    */
    //package br.com.mantu.help.guj.zagaia.stack;

/**

  • @author luciano.mantuaneli

  • @date 01/04/2008
    /
    public class SimpleStack {
    /
    *

    • Vetor de String que armazenará os elementos.
    • Se uma posição estiver nula, esta posição será encarada como uma posição
    • vazia na pilha. Sendo assim, nunca poderá existir uma posição vazia
    • seguida de uma posição não-vazia(diferente de null), pois isso indicaria
    • que, de alguma forma, removemos algum elemento da pilha que não o do topo.
      /
      private String[] elements;
      /
      *
    • inteiro que indicará quantos elementos NÃO NULOS existem dentro de
    • elements. Note por exemplo que:
    • -Se size for igual a 26, o topo da pilha está na posição 25 de elements
    • -Se size for igual a 10, o topo da pilha está na posição 9 de elements
    • -Se size for igual a n, o topo da pilha está na posição (n - 1) de elements
    • Resumindo, podemos assumir QUASE sempre que o topo da pilha é a posição
    • (size - 1) de elements.
    • O “quase” se deve ao caso de quando nossa pilha é vazia. Nesse caso,
    • size é igual a 0. Se fossemos seguir a regra acima indistintamente,
    • acabaríamos assumindo que neste caso o topo da pilha está na posição -1
    • de elements, o que é um erro… Trata-se então de uma exceção, a qual
    • deveremos estar atentos para fazer bobagem!
    • Para fins didáticos, criaremos um método privado que retorna a posição
    • exata do topo da pilha, e sempre utilizaremos este método para termos tal
    • informação.
      */
      private int size;

    /**

    • Construtor que recebe um int como parâmetro, indicando qual será a
    • capacidade da pilha recém-instanciada
      /
      public SimpleStack(int capacity) {
      /
      • Utilizamos o método abs da classe Math só pra evitar que se tente
      • criar uma pilha “devedora”…
        */
        elements = new String[Math.abs(capacity)];
        size = 0;
        }

    /**

    • Método utilizado para adicionar elementos à nossa pilha. Este elemento

    • sempre será inserido no topo deta pilha.

    • -Se o elemento for null, vamos lançar uma exceção, informando que nossa

    • pilha não aceita null como elemento válido.

    • -Se a pilha estiver cheia, retornamos null para indicar que não foi

    • possível insirir elemento.

    • -Se o elemento for inserido com sucesso, retornamos o próprio elemento,

    • indicando assim o sucesso da operação
      */
      public String push(String element) {
      if(element == null)
      throw new IllegalArgumentException(“O elemento não pode ser nulo!”);

      if(size == elements.length)
      return null;

      size++;
      elements[getTopPosition()] = element;
      return element;
      }

    /**

    • Método utilizado para se obter o elemento que está no topo desta pilha,

    • porém, sem removê-lo da mesma.

    • -Se a pilha estiver vazia, retornamos null para indicar que a pilha

    • está vazia.

    • -Se houver ao menos um elemento na pilha, o elemento que está no topo

    • será retornado, indicando o sucesso da operação
      */
      public String peek() {
      if(isEmpty())
      return null;

      return elements[getTopPosition()];
      }

    /**

    • Método utilizado para retirar(“destacar”) um elemento desta pilha. Este
    • elemento sempre será aquele que se encontra no topo desta pilha.
    • -Se a pilha estiver vazia, retornamos null para indicar que a pilha
    • está vazia.
    • -Se houver ao menos um elemento na pilha, o elemento que está no topo
    • será retornado, indicando o sucesso da operação
      */
      public String pop() {
      String result = peek();
      /Se havia um elemento no topo da pilha…/
      if(result != null) {
      elements[getTopPosition()] = null;
      size–;
      }
      return result;
      }

    /**

    • Método utilizado para limpar todo o conteúdo da pilha.
      */
      public void clear() {
      for(int i = 0; i < size; i++)
      elements[i] = null;
      size = 0;
      }

    /**

    • Método utilizado para se obter o tamanho (número de elementos) da pilha
      */
      public int getSize() {
      return size;
      }

    /**

    • Método utilizado para se obter a capacidade da pilha
      */
      public int getCapacity() {
      return elements.length;
      }

    /**

    • Método utilizado para verificar se a pilha está vazia. Se for o caso,
    • será retornado true, caso contrário, será retornado false.
      */
      public boolean isEmpty() {
      return size <= 0;
      }

    /**

    • Este método tem uma finalidade estritamente didática, visando facilitar o
    • entendimento do código desta classe.
    • Este método retorna um inteiro que representa a posição de elements onde
    • se encontra o último elemento inserido nesta pilha (O topo da pilha)
      */
      private int getTopPosition() {
      if (isEmpty())
      return 0;
      return size - 1;
      }

    /**

    • Este método serve para representar textualmente esta pilha

    • @see java.lang.Object#toString()
      */
      public String toString() {
      StringBuilder sb = new StringBuilder("[");
      for(int i = 0; i < size; i++) {
      sb.append(elements[i]);
      if(i < size - 1)
      sb.append(" | “);
      }
      sb.append(”>");

      return sb.toString();
      }
      } [/code]

[/quote]
Entendi cara valeu pelos toques,essa ideia de deixar o usuário empilhar 1 elemento por exemplo e empilhar um outro depois(anulando o fato dele ter que fazer a pilha toda de uma vez) eu pensei também, porém minha apresentação é amanhã e fica muito em cima para mim fazer as alterações !!! Futuramente vou aprimorar mais o código. Valeu mesmo!

Uma versão mais simples e genérica.[code]public class Pilha {

private No<T> topo;

public void empilhar( T valor ) {
    No<T> novoNo = new No<T>( valor );
    novoNo.anterior = topo;
    topo = novoNo;
}

// retorna null se a pilha estiver vazia
public T desempilhar() {

    if ( !estaVazia() ) {
        T valor = topo.valor;
        topo = topo.anterior;
        return valor;
    }

    return null;

}

// retorna null se a pilha estiver vazia
public T topo() {

    if ( !estaVazia() ) {
        return topo.valor;
    }

    return null;

}

public boolean estaVazia() {
    return topo == null;
}

public void imprimir() {

    No<T> atual = topo;

    while ( atual != null ) {
        System.out.println( atual.valor );
        atual = atual.anterior;
    }

}

public static void main( String[] args ) {

    Pilha<String> p = new Pilha<String>();
    p.imprimir();

    p.empilhar( "Foo" );
    p.empilhar( "Bar" );
    p.empilhar( "David" );

    p.imprimir();

    System.out.println( "Desempilhou: " + p.desempilhar() );
    p.imprimir();

}

private class No<T> {

    T valor;
    No<T> anterior;

    No( T valor ) {
        this.valor = valor;
    }

}

}[/code]