CLASE STACK
A continuación vamos a explicar la clase Stack de
Java, que implementa la
interface List. Stack se
traduce por “pila” y para recordar su significado
podemos pensar en una pila de libros. También
veremos las características más im
portantes de esta nueva implementación y haremos un ejemplo a
modo de ejercicio.
STACK
La clase Stack es una clase de las llamadas de tipo LIFO
(Last In - First Out, o último en entrar - primero
en salir). Esta clase hereda de la clase que ya hemo
s estudiado anteriormente en el curso Vector y con 5
operaciones permite tratar un vector a modo de pila o stack.
Las operaciones básicas son
push
(que introduce un elemento en la pila),
pop
(que saca un elemento de
la pila),
peek
(consulta el primer elemento de la cima de la pila),
empty
(que comprueba si la pila está
vacía) y
search
(que busca un determinado elemento dentro de la pila y devuelve su posición dentro de
ella).
Esta clase es muy sencilla y al crear un objeto de ti
po Stack con el constructo
r básico evidentemente no
contendrá ningún elemento.
Un conjunto mucho más completo y consistente para operaciones de stack LIFO es proporcionado en la
interface Deque y sus implementaciones, pero nosotr
os de momento vamos a limitarnos al estudio de
la clase Stack.
EJEMPLO USO CLASE STACK
Realizaremos un ejemplo a modo de uso de pila. Un
o de los casos más usados en informática de una
pila es el de querer verificar si una determinada se
ntencia o instrucción está equilibrada en cuanto a
número de paréntesis, corchetes o llaves de aper
tura y cierre. Cuando se escribe código de
programación si no existe equilibrio entre signos de
apertura (por ejemplo un paréntesis de apertura) y
cierre (por ejemplo un paréntesis de cierre) ni siquiera debería procesarse la sentencia ya que no
estaría formalmente bien construida. De esto se enca
rgan los analizadores léxicos de los compiladores.
Así que vamos a utilizar esta vez tan solo una clas
e Programa con el método main, donde vamos a ir
analizando una sentencia para verificar si es equili
brada o no en símbolos de paréntesis, recorriendo
todos sus caracteres desde el
inicio hasta el final.
Iremos construyendo nuestra pila apilando un símbolo (cada vez que detectemos un símbolo de
apertura o desapilando de ella cuando detectemos un símbolo de cierre. Tendremos que ir analizando
Interface List del api java. Clas
e Stack. Ejemplos resueltos.
© aprenderaprogramar.com, 2006-2039
todos los caracteres de una expresión y actuar cuan
do detectemos un paréntesis, operando en función
de si el paréntesis leído es de abrir (“(”) o cerrar (“)”
). El equilibrio en la escritura vendrá determinado al
terminar el análisis en función de si la pila está
vacía (hay equilibrio) o contiene algún elemento (no hay
equilibrio).
Ejemplo: analizamos la expresión “Hay varios país
es (México, España) que comparten el mismo idioma
(español o castellano).”
El resultado al finalizar el análisis de la sentenci
a sería que la pila está vacía, y esto querrá decir que
nuestra sentencia es equilibrada en paréntesis y por tanto el resultado es correcto.
Si analizáramos la expresión “Hay varios países
(México, España) que comparten el mismo idioma
(español o castellano.”
El resultado al finalizar el análisis será que la p
ila contiene un paréntesis, lo que quiere decir que la
expresión no es equilibrada y no tiene el mism
o número de paréntesis abiertos que cerrados.
Tendremos que tener en cuenta casos especiales como una expresión cuyo primer elemento sea un
paréntesis de cierre. Por ejemplo: “Hay varios pa
íses )México, España(“
la consideraríamos una
expresión incorrecta ya que si la pila está vacía
el primer elemento siempre tendrá que ser un
paréntesis de apertura y no uno de cierre. Tendremos en cuenta por tanto que además de equilibrio
exista corrección en la forma de construcción (que
no puedan existir cierres de paréntesis que no se
hayan abierto).
Vamos a escribir ahora el siguiente
código con el que vamos a trabajar:
/* Ejemplo Interface List, clase Stack aprenderaprogramar.com */
import java.util.Stack;
public class
Programa
{
public static void main(String arg[]) {
String cadenano = "(Cadena no equilibrada en paréntesis(()()()))))";
String cadenasi = "(Cadena equilibrada en parentesis())";
System.out.println("Verifica
ción equilibrado en paré
ntesis para cadenano:");
System.out.p
rintln(verificaParentesis(cadenano));
System.out.println("Verifica
ción equilibrado en paré
ntesis para cadenasi:");
System.out.println(verificaParentesis(cadenasi));
}
public static boolean
verificaParentesis
(String cadena) {
Stack<String> pila = new Stack<String>(); int i = 0;
while (i<cadena.length()) {
// Recorremos la expresión carácter a carácter
if(cadena.charAt(i)=='(') {pila.push("(");}
// Si el paréntesis es de apertura apilamos siempre
else if (cadena.charAt(i)==')') {
// Si el paréntesis es de cierre actuamos según el caso
if (!pila.empty()){ pila.pop(); }
// Si la pila no está vacía desapilamos
else { pila.push(")"); break; }
// La pila no puede empezar con un cierre, apilamos y salimos
}
i++;
}
if(pila.empty()){ return true; } else { return false; }
}
}
------------------------------------------------------------------------------------------------------
http://www.aprenderaprogramar.com/attachments/article/608/CU00923C%20Estructura%20de%20datos%20pila%20clase%20stack%20api%20java%20ejemplo%20resuelto.pdf
http://lineadecodigo.com/java/crear-una-pila-en-java/
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package javaapplication1;
import java.util.Stack;
/**
*
* @author SEDUCA
*/
public class JavaApplication1 {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
Stack<String> pilaNombres=new Stack<>();
System.out.println(pilaNombres);
pilaNombres.push("Jose");
pilaNombres.push("Daniel");
pilaNombres.push("Pedro");
pilaNombres.push("Juan");
System.out.println(pilaNombres); //muestra todos los elementos existentesen la pila
System.out.println(pilaNombres.size()); //muestra la cantidad de elementos
System.out.println(pilaNombres.peek()); //muestra el ultimo elemento sin sacar
pilaNombres.pop();
System.out.println(pilaNombres);
System.out.println(pilaNombres.size());
System.out.println(pilaNombres.peek());
System.out.println("Saco la ultima que es:"+pilaNombres.pop());
System.out.println(pilaNombres);
pilaNombres.push("Fernando");
if(! pilaNombres.isEmpty()){
System.out.println(pilaNombres.pop());
}
}
}
otro ejercicio con procedimiento
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package ejercicio_pila_revertir;
import java.util.Stack;
/**
*
* @author SEDUCA
*/
public class Ejercicio_pila_revertir {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
Stack<String> pilaNombres=new Stack<>();
System.out.println(pilaNombres);
pilaNombres.push("Jose");
pilaNombres.push("Daniel");
pilaNombres.push("Pedro");
pilaNombres.push("Juan");
InvertirPila(pilaNombres);
}
public static void InvertirPila(Stack<String> pPila){
Stack<String> pilaAux=new Stack<>();
Stack<String> pilaAux2=new Stack<>();
while (!pPila.isEmpty()){
pilaAux.push(pPila.pop());
}
System.out.println(pilaAux);
while (!pilaAux.empty()){
pilaAux2.push(pilaAux.pop());
}
System.out.println(pilaAux2);
while (!pPila.empty()){
pPila.push(pilaAux2.pop());
}
System.out.println(pPila);
}
}
Con la función DLookup podemos buscar un campo de un registro determinado en una tabla específica en Microsoft Access.
Note