Tenho por objetivo ampliar minha rede de aprendizado na linguagem de programação Java e durante as inúmeras trocas de informações tenho percebido a dificuldade de alguns programadores em reconhecer conceitos básicos.
Este é um mini-tutorial de fácil compreensão sobre a estrutura de dados chamada Pilha, que é representada pela classe Stack em Java.
Ao longo do tempo pretendo publicar mais material no fórum. Sugestões e críticas são bem-vindas. A ajuda é recíproca! 
[size=“22”]Mini-tutorial Java 2SE - Pilhas (Stack): Conceitos[/size]
[size=“18”]Conceito sucinto de Pilha[/size]
[quote][i]Uma pilha é uma estrutura de dados com padrão de acesso LIFO (Last-In, First-Out), ou seja, o último
elemento que é armazenado é obrigatoriamente o primeiro elemento a ser retirado.
Em Java, pilhas de objetos são implementadas por objetos da classe Stack. Os dois métodos fundamentais
associados a uma estrutura de pilha devem permitir colocar um elemento no topo da pilha (método push()) e retirar o
elemento no topo da pilha (método pop()).
Outras funcionalidades associadas a esta classe incluem os métodos peek() (qual o objeto que está no topo da pilha?),
search() (a que profundidade encontra-se o objeto especificado?) e boolean empty() (pilha está vazia?).[/i]
http://www.dca.fee.unicamp.br/cursos/PooJava/collections/h_stack.html
© Ivan Luiz Marques Ricarte
DCA/FEEC/UNICAMP
Last modified: Fri Apr 25 09:36:33 BRT 2003[/quote]
[size=“18”]Conceito de LIFO/FILO[/size]
[quote][i] LIFO é um acrônimo para a expressão inglesa Last In, First Out que, em português significa [b]último
a entrar, primeiro a sair[/b]. Em ciência da computação, refere-se a estruturas de dados do tipo pilha. [b]É equivalente a
FILO[/b], que significa First In, Last Out e pode também ser referida como pilha.
O conceito de pilha é amplamente utilizado na informática, como, por exemplo, durante a execução de um programa, para o
armazenamento de valores de variável local a um bloco e também para conter o endereço de retorno do trecho de programa que
chamou a função ou procedimento atualmente em execução.[/i]
Origem: Wikipédia, a enciclopédia livre.[/quote]
[size=“22”]Mini-tutorial Java 2SE - Pilhas (Stack): Exemplo TestaStack.java[/size]
[size=“18”]DECLARANDO NOSSOS ELEMENTOS/OBJETOS[/size]
Vamos iniciar nosso programa declarando objetos da classe String, onde cada um receberá um valor inicial baseado em nome próprio. São oito objetos: chan, hasan, chico, arnold, elza, clarice, silvio e richard.
Tais objetos e seus respectivos valores serão incrementados na nossa estrutura de pilha.
[code]public class TestaStack {
public static void main(String[] args) {
// DECLARANDO NOSSOS ELEMENTOS/OBJETOS
String chan = "Chan", hassan = "Hassan", chico = "Chico", arnold = "Arnold", elza = "Elza", clarice =
“Clarice”, silvio = “Silvio”, richard = “Richard”;
}
}[/code]
[size=“18”]DECLARANDO A PILHA[/size]
No passo anterior declaramos os objetos que serão incrementados na pilha. Agora, vamos declarar a pilha. Tal estrutura corresponde à classe Stack na linguagem de programação Java.
O nosso objeto da classe Stack será nomeado explicitamente de nossaPilha da seguinte maneira: Stack<String> nossaPilha = new Stack<String>();
Uma observação importante é quanto à classe esperada para nossa pilha. Neste caso é informado que durante a criação da pilha ela deverá conter objetos String. Essa particularidade está no nome de classe colocado entre “<” e “>”.
[code]import java.util.Stack;
public class TestaStack {
public static void main(String[] args) {
// DECLARANDO NOSSOS ELEMENTOS/OBJETOS
String chan = "Chan", hassan = "Hassan", chico = "Chico", arnold = "Arnold", elza = "Elza", clarice =
“Clarice”, silvio = “Silvio”, richard = “Richard”;
// DECLARANDO A PILHA
Stack<String> nossaPilha = new Stack<String>();
}
}[/code]
[size=“18”]EXIBINDO INFORMAÇÕES SOBRE A PILHA[/size]
Para exibir informações sobre uma pilha, você pode utilizar a instrução System.out.println(nossaPilha);. Entretanto, a saída será sucinta e com os elementos dispostos em ordem crescente e na horizontal. Exemplo: [Chan, Hassan, Chico, Clarice, Silvio, Richard] ( Richard é o topo e Chan é a Base ).
Para uma representação que facilite a compreensão da estrutura da pilha e envolva prática, vamos utilizar o seguinte bloco de instruções:
// EXIBINDO INFORMAÇÕES SOBRE A PILHA
if (nossaPilha.isEmpty()) {
System.out.println("A PILHA ESTÁ VAZIA!");
} else {
System.out
.println("NOSSA PILHA...\n\nElemento\tÍndice\n----------------------");
for (int i = nossaPilha.size() - 1; i > -1; i--) {
System.out.println(nossaPilha.get(i) + "\t\t" + i);
}
System.out.println("\nNÚMERO DE ELEMENTOS: " + nossaPilha.size());
System.out.println("ELEMENTO NO TOPO: \"" + nossaPilha.peek()
+ "\" no índice " + nossaPilha.indexOf(nossaPilha.peek()));
}
Inicialmente vamos nos certificar que a pilha contenha elementos, caso o método nossaPilha.isEmpty() retorne o valor booleano true, o usuário será advertido que a pilha está vazia.
Caso a pilha contenha elementos, a repetição for (int i = nossaPilha.size() - 1; i > -1; i–){} percorrerá todos os elementos da lista na forma decrescente, exibindo o valor e índice correspondente. ATENÇÃO: int i = nossaPilha.size() - 1 corresponde o topo da lista, considerando que o método nossaPilha.size() retorna o número de elementos e os índice inicial da pilha é 0, a subtração de 1 elemento é necessária. Em i > -1 informa que a repetição deverá ocorrer até que o índice da pilha seja válido/existente (maior ou igual a 0). O i– é o decremento do índice (não esqueça que a exibição dos elementos será de maneira análoga a objetos empilhados).
Em System.out.println("\nNÚMERO DE ELEMENTOS: " + nossaPilha.size()); o método .size() retorna a quantidade de elementos disponíveis.
Em System.out.println("ELEMENTO NO TOPO: “” + nossaPilha.peek() + “” no índice " + nossaPilha.indexOf(nossaPilha.peek())); o método nossaPilha.peek() retorna o elemento no topo da pilha. Em indexOf(nossaPilha.peek()) teremos o índice do elemento ao topo da pilha.
[color=“red”]Execute o programa após acrescentar o código citado. Obs. A pilha estará vazia![/color]
[code]import java.util.Stack;
public class TestaStack {
public static void main(String[] args) {
// DECLARANDO NOSSOS ELEMENTOS/OBJETOS
String chan = "Chan", hassan = "Hassan", chico = "Chico", arnold = "Arnold", elza = "Elza", clarice =
“Clarice”, silvio = “Silvio”, richard = “Richard”;
// DECLARANDO A PILHA
Stack<String> nossaPilha = new Stack<String>();
// EXIBINDO INFORMAÇÕES SOBRE A PILHA
if (nossaPilha.isEmpty()) {
System.out.println("A PILHA ESTÁ VAZIA!");
} else {
System.out.println("NOSSA PILHA...\n\nElemento\tÍndice\n----------------------");
for (int i = nossaPilha.size() - 1; i > -1; i--) {
System.out.println(nossaPilha.get(i) + "\t\t" + i);
}
System.out.println("\nNÚMERO DE ELEMENTOS: " + nossaPilha.size());
System.out.println("ELEMENTO NO TOPO: \"" + nossaPilha.peek() + "\" no índice " + nossaPilha.indexOf
(nossaPilha.peek()));
}
}
}[/code]
[color=“red”]SAÍDA:[/color]
A PILHA ESTÁ VAZIA!
[size=“18”]Passo 1: Incrementar Chan[/size]
A partir de agora vamos interagir diretamente na pilha. O primeiro passo será acrescentar elementos a pilha. O método push() é o responsável por incrementar elementos na pilha. O primeiro elemento a ser incrementado será chan: nossaPilha.push(chan);
[color=“red”]Execute o programa após acrescentar o código citado. Observe a ilustração e a saída do programa![/color]
[code]import java.util.Stack;
public class TestaStack {
public static void main(String[] args) {
// DECLARANDO NOSSOS ELEMENTOS/OBJETOS
String chan = "Chan", hassan = "Hassan", chico = "Chico", arnold = "Arnold", elza = "Elza", clarice =
“Clarice”, silvio = “Silvio”, richard = “Richard”;
// DECLARANDO A PILHA
Stack<String> nossaPilha = new Stack<String>();
// Passo 1: Incrementar Chan
nossaPilha.push(chan);
// EXIBINDO INFORMAÇÕES SOBRE A PILHA
if (nossaPilha.isEmpty()) {
System.out.println("A PILHA ESTÁ VAZIA!");
} else {
System.out
.println("NOSSA PILHA...\n\nElemento\tÍndice\n----------------------");
for (int i = nossaPilha.size() - 1; i > -1; i--) {
System.out.println(nossaPilha.get(i) + "\t\t" + i);
}
System.out.println("\nNÚMERO DE ELEMENTOS: " + nossaPilha.size());
System.out.println("ELEMENTO NO TOPO: \"" + nossaPilha.peek()
+ "\" no índice " + nossaPilha.indexOf(nossaPilha.peek()));
}
}
}[/code]
[color=“red”]SAÍDA:[/color]
NOSSA PILHA…
Elemento Índice
Chan 0
NÚMERO DE ELEMENTOS: 1
ELEMENTO NO TOPO: “Chan” no índice 0
[size=“18”]Passo 2: Incrementar Hassan[/size]
Para praticar vamos incrementar hassan: nossaPilha.push(hassan);
[color=“red”]Execute o programa após acrescentar o código citado. Observe a ilustração e a saída do programa![/color]
[code]import java.util.Stack;
public class TestaStack {
public static void main(String[] args) {
// DECLARANDO NOSSOS ELEMENTOS/OBJETOS
String chan = "Chan", hassan = "Hassan", chico = "Chico", arnold = "Arnold", elza = "Elza", clarice =
“Clarice”, silvio = “Silvio”, richard = “Richard”;
// DECLARANDO A PILHA
Stack<String> nossaPilha = new Stack<String>();
// Passo 1: Incrementar Chan
nossaPilha.push(chan);
// Passo 2: Incrementar Hassan
nossaPilha.push(hassan);
// EXIBINDO INFORMAÇÕES SOBRE A PILHA
if (nossaPilha.isEmpty()) {
System.out.println("A PILHA ESTÁ VAZIA!");
} else {
System.out
.println("NOSSA PILHA...\n\nElemento\tÍndice\n----------------------");
for (int i = nossaPilha.size() - 1; i > -1; i--) {
System.out.println(nossaPilha.get(i) + "\t\t" + i);
}
System.out.println("\nNÚMERO DE ELEMENTOS: " + nossaPilha.size());
System.out.println("ELEMENTO NO TOPO: \"" + nossaPilha.peek()
+ "\" no índice " + nossaPilha.indexOf(nossaPilha.peek()));
}
}
}
[/code]
[color=“red”]SAÍDA:[/color]
NOSSA PILHA…
Elemento Índice
Hassan 1
Chan 0
NÚMERO DE ELEMENTOS: 2
ELEMENTO NO TOPO: “Hassan” no índice 1
[size=“18”]Passo 3: Incrementar Chico e Elza[/size]
Agora vamos incrementar ]dois elementos: nossaPilha.push(chico) e nossaPilha.push(elza).
[color=“red”]Execute o programa após acrescentar o código citado. Observe a ilustração e a saída do programa![/color]
[code]import java.util.Stack;
public class TestaStack {
public static void main(String[] args) {
// DECLARANDO NOSSOS ELEMENTOS/OBJETOS
String chan = "Chan", hassan = "Hassan", chico = "Chico", arnold = "Arnold", elza = "Elza", clarice =
“Clarice”, silvio = “Silvio”, richard = “Richard”;
// DECLARANDO A PILHA
Stack<String> nossaPilha = new Stack<String>();
// Passo 1: Incrementar Chan
nossaPilha.push(chan);
// Passo 2: Incrementar Hassan
nossaPilha.push(hassan);
// Passo 3: Incrementar Chico e Elza
nossaPilha.push(chico);
nossaPilha.push(elza);
// EXIBINDO INFORMAÇÕES SOBRE A PILHA
if (nossaPilha.isEmpty()) {
System.out.println("A PILHA ESTÁ VAZIA!");
} else {
System.out
.println("NOSSA PILHA...\n\nElemento\tÍndice\n----------------------");
for (int i = nossaPilha.size() - 1; i > -1; i--) {
System.out.println(nossaPilha.get(i) + "\t\t" + i);
}
System.out.println("\nNÚMERO DE ELEMENTOS: " + nossaPilha.size());
System.out.println("ELEMENTO NO TOPO: \"" + nossaPilha.peek()
+ "\" no índice " + nossaPilha.indexOf(nossaPilha.peek()));
}
}
}[/code]
[color=“red”]SAÍDA:[/color]
NOSSA PILHA…
Elemento Índice
Elza 3
Chico 2
Hassan 1
Chan 0
NÚMERO DE ELEMENTOS: 4
ELEMENTO NO TOPO: “Elza” no índice 3
[size=“18”]Passo 4: Decrementar elemento Elza do topo[/size]
Este passo consiste em retirar o elemento do topo da pilha. O método pop() é responsável por tal ação. A instrução nossaPilha.pop(); retira o elemento clarice e o topo passa a ser chico.
[color=“red”]Execute o programa após acrescentar o código citado. Observe a ilustração e a saída do programa![/color]
[code]import java.util.Stack;
public class TestaStack {
public static void main(String[] args) {
// DECLARANDO NOSSOS ELEMENTOS/OBJETOS
String chan = "Chan", hassan = "Hassan", chico = "Chico", arnold = "Arnold", elza = "Elza", clarice =
“Clarice”, silvio = “Silvio”, richard = “Richard”;
// DECLARANDO A PILHA
Stack<String> nossaPilha = new Stack<String>();
// Passo 1: Incrementar Chan
nossaPilha.push(chan);
// Passo 2: Incrementar Hassan
nossaPilha.push(hassan);
// Passo 3: Incrementar Chico e Elza
nossaPilha.push(chico);
nossaPilha.push(elza);
// Passo 4: Decrementar elemento Elza do topo
nossaPilha.pop();
// EXIBINDO INFORMAÇÕES SOBRE A PILHA
if (nossaPilha.isEmpty()) {
System.out.println("A PILHA ESTÁ VAZIA!");
} else {
System.out
.println("NOSSA PILHA...\n\nElemento\tÍndice\n----------------------");
for (int i = nossaPilha.size() - 1; i > -1; i--) {
System.out.println(nossaPilha.get(i) + "\t\t" + i);
}
System.out.println("\nNÚMERO DE ELEMENTOS: " + nossaPilha.size());
System.out.println("ELEMENTO NO TOPO: \"" + nossaPilha.peek()
+ "\" no índice " + nossaPilha.indexOf(nossaPilha.peek()));
}
}
}[/code]
[color=“red”]SAÍDA:[/color]
NOSSA PILHA…
Elemento Índice
Chico 2
Hassan 1
Chan 0
NÚMERO DE ELEMENTOS: 3
ELEMENTO NO TOPO: “Chico” no índice 2
[size=“18”]Passo 5: Incrementar Clarice[/size]
Agora vamos incrementar outro elemento: nossaPilha.push(clarice);
[color=“red”]Execute o programa após acrescentar o código citado. Observe a ilustração e a saída do programa![/color]
[code]import java.util.Stack;
public class TestaStack {
public static void main(String[] args) {
// DECLARANDO NOSSOS ELEMENTOS/OBJETOS
String chan = "Chan", hassan = "Hassan", chico = "Chico", arnold = "Arnold", elza = "Elza", clarice =
“Clarice”, silvio = “Silvio”, richard = “Richard”;
// DECLARANDO A PILHA
Stack<String> nossaPilha = new Stack<String>();
// Passo 1: Incrementar Chan
nossaPilha.push(chan);
// Passo 2: Incrementar Hassan
nossaPilha.push(hassan);
// Passo 3: Incrementar Chico e Elza
nossaPilha.push(chico);
nossaPilha.push(elza);
// Passo 4: Decrementar elemento Elza do topo
nossaPilha.pop();
// Passo 5: Incrementar Clarice
nossaPilha.push(clarice);
// EXIBINDO INFORMAÇÕES SOBRE A PILHA
if (nossaPilha.isEmpty()) {
System.out.println("A PILHA ESTÁ VAZIA!");
} else {
System.out
.println("NOSSA PILHA...\n\nElemento\tÍndice\n----------------------");
for (int i = nossaPilha.size() - 1; i > -1; i--) {
System.out.println(nossaPilha.get(i) + "\t\t" + i);
}
System.out.println("\nNÚMERO DE ELEMENTOS: " + nossaPilha.size());
System.out.println("ELEMENTO NO TOPO: \"" + nossaPilha.peek()
+ "\" no índice " + nossaPilha.indexOf(nossaPilha.peek()));
}
}
}[/code]
[color=“red”]SAÍDA:[/color]
NOSSA PILHA…
Elemento Índice
Clarice 3
Chico 2
Hassan 1
Chan 0
NÚMERO DE ELEMENTOS: 4
ELEMENTO NO TOPO: “Clarice” no índice 3
[size=“18”]Passo 6: Incrementar Silvio e Richard[/size]
Agora vamos incrementar dois elementos: nossaPilha.push(silvio); e nossaPilha.push(richard);.
[color=“red”]Execute o programa após acrescentar o código citado. Observe a ilustração e a saída do programa![/color]
[code]import java.util.Stack;
public class TestaStack {
public static void main(String[] args) {
// DECLARANDO NOSSOS ELEMENTOS/OBJETOS
String chan = "Chan", hassan = "Hassan", chico = "Chico", arnold = "Arnold", elza = "Elza", clarice =
“Clarice”, silvio = “Silvio”, richard = “Richard”;
// DECLARANDO A PILHA
Stack<String> nossaPilha = new Stack<String>();
// Passo 1: Incrementar Chan
nossaPilha.push(chan);
// Passo 2: Incrementar Hassan
nossaPilha.push(hassan);
// Passo 3: Incrementar Chico e Elza
nossaPilha.push(chico);
nossaPilha.push(elza);
// Passo 4: Decrementar elemento Elza do topo
nossaPilha.pop();
// Passo 5: Incrementar Clarice
nossaPilha.push(clarice);
// Passo 6: Incrementar Silvio e Richard
nossaPilha.push(silvio);
nossaPilha.push(richard);
// EXIBINDO INFORMAÇÕES SOBRE A PILHA
if (nossaPilha.isEmpty()) {
System.out.println("A PILHA ESTÁ VAZIA!");
} else {
System.out
.println("NOSSA PILHA...\n\nElemento\tÍndice\n----------------------");
for (int i = nossaPilha.size() - 1; i > -1; i--) {
System.out.println(nossaPilha.get(i) + "\t\t" + i);
}
System.out.println("\nNÚMERO DE ELEMENTOS: " + nossaPilha.size());
System.out.println("ELEMENTO NO TOPO: \"" + nossaPilha.peek()
+ "\" no índice " + nossaPilha.indexOf(nossaPilha.peek()));
}
}
}
[/code]
[color=“red”]SAÍDA:[/color]
NOSSA PILHA…
Elemento Índice
Richard 5
Silvio 4
Clarice 3
Chico 2
Hassan 1
Chan 0
NÚMERO DE ELEMENTOS: 6
ELEMENTO NO TOPO: “Richard” no índice 5
[size=“18”]Passo 7: Substituir elemento na pilha. Chan por Arnold![/size]
Uma das facilidades herdadas da classe Stack é a possibilidade de substituir qualquer elemento da pilha através do método set(). Em nossaPilha.set(0, arnold); vamos substituir o elemento na base chamado chan pelo elemento arnold. Perceba ordem da passagem de parâmetros do método: set(“índice desejado”,”elemento que ira substituir”);.
[color=“red”]Execute o programa após acrescentar o código citado. Observe a ilustração e a saída do programa![/color]
[code]import java.util.Stack;
public class TestaStack {
public static void main(String[] args) {
// DECLARANDO NOSSOS ELEMENTOS/OBJETOS
String chan = "Chan", hassan = "Hassan", chico = "Chico", arnold = "Arnold", elza = "Elza", clarice =
“Clarice”, silvio = “Silvio”, richard = “Richard”;
// DECLARANDO A PILHA
Stack<String> nossaPilha = new Stack<String>();
// Passo 1: Incrementar Chan
nossaPilha.push(chan);
// Passo 2: Incrementar Hassan
nossaPilha.push(hassan);
// Passo 3: Incrementar Chico e Elza
nossaPilha.push(chico);
nossaPilha.push(elza);
// Passo 4: Decrementar elemento Elza do topo
nossaPilha.pop();
// Passo 5: Incrementar Clarice
nossaPilha.push(clarice);
// Passo 6: Incrementar Silvio e Richard
nossaPilha.push(silvio);
nossaPilha.push(richard);
// Passo 7: Substituir elemento na pilha. Chan por Arnold!
nossaPilha.set(0, arnold);
// EXIBINDO INFORMAÇÕES SOBRE A PILHA
if (nossaPilha.isEmpty()) {
System.out.println("A PILHA ESTÁ VAZIA!");
} else {
System.out
.println("NOSSA PILHA...\n\nElemento\tÍndice\n----------------------");
for (int i = nossaPilha.size() - 1; i > -1; i--) {
System.out.println(nossaPilha.get(i) + "\t\t" + i);
}
System.out.println("\nNÚMERO DE ELEMENTOS: " + nossaPilha.size());
System.out.println("ELEMENTO NO TOPO: \"" + nossaPilha.peek()
+ "\" no índice " + nossaPilha.indexOf(nossaPilha.peek()));
}
}
}[/code]
[color=“red”]SAÍDA:[/color]
NOSSA PILHA…
Elemento Índice
Richard 5
Silvio 4
Clarice 3
Chico 2
Hassan 1
Arnold 0
NÚMERO DE ELEMENTOS: 6
ELEMENTO NO TOPO: “Richard” no índice 5
[size=“18”]Passo FINAL: Limpar a pilha![/size]
O último passo é limpar a pilha. O método clear() retira instantaneamente todos os elementos.
[color=“red”]Execute o programa após acrescentar o código citado. Observe a ilustração e a saída do programa![/color]
[code]import java.util.Stack;
public class TestaStack {
public static void main(String[] args) {
// DECLARANDO NOSSOS ELEMENTOS/OBJETOS
String chan = "Chan", hassan = "Hassan", chico = "Chico", arnold = "Arnold", elza = "Elza", clarice =
“Clarice”, silvio = “Silvio”, richard = “Richard”;
// DECLARANDO A PILHA
Stack<String> nossaPilha = new Stack<String>();
// Passo 1: Incrementar Chan
nossaPilha.push(chan);
// Passo 2: Incrementar Hassan
nossaPilha.push(hassan);
// Passo 3: Incrementar Chico e Elza
nossaPilha.push(chico);
nossaPilha.push(elza);
// Passo 4: Decrementar elemento Elza do topo
nossaPilha.pop();
// Passo 5: Incrementar Clarice
nossaPilha.push(clarice);
// Passo 6: Incrementar Silvio e Richard
nossaPilha.push(silvio);
nossaPilha.push(richard);
// Passo 7: Substituir elemento na pilha. Chan por Arnold!
nossaPilha.set(0, arnold);
// Passo FINAL: Limpar a pilha
nossaPilha.clear();
// EXIBINDO INFORMAÇÕES SOBRE A PILHA
if (nossaPilha.isEmpty()) {
System.out.println("A PILHA ESTÁ VAZIA!");
} else {
System.out
.println("NOSSA PILHA...\n\nElemento\tÍndice\n----------------------");
for (int i = nossaPilha.size() - 1; i > -1; i--) {
System.out.println(nossaPilha.get(i) + "\t\t" + i);
}
System.out.println("\nNÚMERO DE ELEMENTOS: " + nossaPilha.size());
System.out.println("ELEMENTO NO TOPO: \"" + nossaPilha.peek()
+ "\" no índice " + nossaPilha.indexOf(nossaPilha.peek()));
}
}
}[/code]
[color=“red”]SAÍDA:[/color]
A PILHA ESTÁ VAZIA!
[size=“22”]Mini-tutorial Java 2SE - Pilhas (Stack): Exemplo TestaStackSearch[/size]
[size=“18”]PESQUISANDO: Método search():[/size]
Outro método essencial da classe Stack é o search(). Este recurso localiza valores na pilha, retornando a distância do elemento a partir do topo. Quando não é possível encontrar o valor desejado, o retorno do método será o inteiro negativo -1.
ATENÇÃO: Para compreender essa relação entre a distância do elemento a partir do topo, considere: uma pilha com 6 elementos onde o a distância do elemento no topo é 1 e na base corresponde a 6.
Que tal testar o seguinte programa (agora exibindo a distância de cada elemento em relação ao topo)…
[code]import java.util.Stack;
public class TestaStackSearch {
public static void main(String[] args) {
// DECLARANDO NOSSOS ELEMENTOS/OBJETOS
String chan = "Chan", hassan = "Hassan", chico = "Chico", arnold = "Arnold", elza = "Elza", clarice =
“Clarice”, silvio = “Silvio”, richard = “Richard”;
// DECLARANDO A PILHA
Stack<String> nossaPilha = new Stack<String>();
// Passo 1: Incrementar Chan
nossaPilha.push(arnold);
nossaPilha.push(hassan);
nossaPilha.push(chico);
nossaPilha.push(clarice);
nossaPilha.push(silvio);
nossaPilha.push(richard);
// EXIBINDO INFORMAÇÕES SOBRE A PILHA
if (nossaPilha.isEmpty()) {
System.out.println("A PILHA ESTÁ VAZIA!");
} else {
System.out
.println("NOSSA PILHA...\n\nElemento\tÍndice\tDistância do topo\n-------------------
----------------------");
for (int i = nossaPilha.size() - 1; i > -1; i–) {
System.out.println(nossaPilha.get(i) + “\t\t” + i + “\t”
+ (nossaPilha.size() - i));
}
System.out.println("\nNÚMERO DE ELEMENTOS: " + nossaPilha.size());
System.out.println("ELEMENTO NO TOPO: \"" + nossaPilha.peek()
+ "\" no índice " + nossaPilha.indexOf(nossaPilha.peek()));
}
}
}[/code]
[color=“red”]SAÍDA:[/color]
NOSSA PILHA…
Elemento Índice Distância do topo
Richard 5 1
Silvio 4 2
Clarice 3 3
Chico 2 4
Hassan 1 5
Arnold 0 6
NÚMERO DE ELEMENTOS: 6
ELEMENTO NO TOPO: “Richard” no índice 5
… Acrescente o código abaixo antes da exibição das informações da pilha. Perceba o valor da distância a partir do topo em cada um dos elementos pesquisados.
// Localizar
System.out.println(nossaPilha.search("Chan"));
System.out.println(nossaPilha.search("Richard"));
System.out.println(nossaPilha.search("Silvio"));
System.out.println(nossaPilha.search("Hassan"));
:oops: No final de semana atualizo com outras considerações!
