Al aprender a trabajar con arrays, siempre suelen mencionarse las pilas. Una pila no es más que una colección de valores de tipo LIFO (Last In First Out), o sea el último valor insertado en la

pila es el primero en salir o ejecutarse. La estructura básica de una pila es la siguiente:



Mediante un array conseguiremos construir nuestra pila de datos en Java. Para eso creamos la siguiente clase:

 
public class Stack {
 
    private int stck[];
    private int tos;
 
    //Constructor
    Stack(int size){
        //Crear la pila
        stck = new int[size];
        tos = -1;
    }
 
    //Introduce valor en la pila
    void push(int value) {
        if (tos == stck.length - 1)
            System.out.println("Stack Overflow!");
            //Pila esta llena
        else
            stck[++tos] = value;
            //Almacena valor en pila
    }
 
    //Retira valor de la pila
    int pop() {
        if (tos < 0) {
            //La pila esta vacia
            System.out.println("Stack Underflow!");
            return 0;
        } else
            return stck[tos--];
 
    }
}
 

El primer método de la clase es el constructor, al constructor tenemos que pasarle un parámetro que indique el tamaño de la pila. Dentro del constructor se crea una matriz con el tamaño especificado a través del constructor y se le asigna el valor -1 a la variable tos (eso indica que la pila está vacía).


El siguiente método push() introduce un valor al principio de la pila, primero se comprueba si la pila está llena, en caso contrario agrega el valor introducido en la pila. El último método pop() elimina de la pila el último valor insertado y lo devuelve (también se comprueba que la pila no esté vacía).

Ahora veamos cómo utilizar ésta clase:

public class Test {
 
    public static void main(String args[]) {
 
        //System.out.println("This is a test!");
 
        Stack pila = new Stack(10);
        //Llenar la pila
        for (int i = 0; i < 10; i++) pila.push(i);
 
        //Retirar 5 primeros elementos de la pila
        System.out.println("Valores contenidos en la pila: ");
        for (int i = 0; i < 5; i++) System.out.println("\t " + pila.pop());
 
    }
 
}
 

Primero se crea instancia la clase Stack y mediante el constructor se inicializa una pila que puede contener hasta 10 valores. Luego mediante la sentencia for() se introducen elementos en la pila insertándolos usando el método push().

Acto seguid, eliminamos y mostramos los 5 primeros valores de la pila.

Mas bien demuestra el concepto basico de como implementar nuestra propia pila, no creo que la clase java.util.Stack este del todo implementada así.

Nosotros en mi clase hicimos lo mismo bueno pero le agregamos otras funciones jeje, para ver el dato de la pila, y pues son de tipo boolean todos los metodos.

public class Pila
{
	private int Tope = -1;
	private int Max;
	private int Pila[];
	public int DatoPila;
 
	public Pila(int CantMax)
	{
		Pila = new int[CantMax];
		Max = CantMax;
	}
 
	private boolean PilaVacia()
	{
		boolean resp = false;
		if(Tope == -1)
			resp = true;
		return resp;
	}
 
	private boolean PilaLlena()
	{
		boolean resp = false;
		if((Tope-1) == Max)
			resp = true;
		return resp;
	}
 
	public boolean InsertarPila(int Dato)
	{
		boolean resp = false;
		if(!PilaLlena())
		{
			Tope++;
			Pila[Tope] = Dato;
			resp = true;
		}
		return resp;	
	}
 
	public boolean RemoverPila()
	{
		boolean resp = false;
		if(!PilaVacia())
		{
			DatoPila = Pila[Tope];
			Tope--;
			resp = true;
		}
		return resp;
	}
 
	public boolean VerPila()
	{
		boolean resp = false;
		if(!PilaVacia())
		{
			DatoPila = Pila[Tope];
			resp = true;
		}
		return resp;
	}
 
}