Uso de la clase java.util.Stack en flujo de aplicaciones J2ME

Una pila (stack en inglés) es una estructura de datos de tipo LIFO (del inglés Last In First Out, último en entrar, primero en salir) que permite almacenar y recuperar datos. Se aplica en multitud de ocasiones en informática debido a su simplicidad y ordenación implícita en la propia estructura.

Para el manejo de los datos se cuenta con dos operaciones básicas: apilar (push), que coloca un objeto en la pila, y su operación inversa, retirar (o desapilar, pop), que retira el último elemento apilado. Ver Pila (estructura de datos) en Wikipedia.

Java provee una implementación de esta estructura de datos en la clase java.util.Stack que cuenta con los métodos empty, peek, pop, push y search.

Push: agrega un elemento a la pila.
Pop: recupera el último elemento y lo elimina.
Peek: recupera el último elemento sin eliminarlo de la pila.

Un ejemplo de utilización de esta clase puede ser para almacenar el flujo de una aplicación J2ME como se ve en este ejemplo adaptado del código de Cash2ME:

package net.sf.cash2me;

import java.util.Stack;

import javax.microedition.lcdui.Displayable;
import javax.microedition.midlet.MIDlet;
import javax.microedition.midlet.MIDletStateChangeException;

public class Cash2ME extends MIDlet {

private Displayable currentScreen; // La pantalla actual
    private Stack screenStack;       // contiene todas las pantallas previas

 /**
  * Recibe un objeto Displayable y lo configura como Current de Display, es decir
  * lo muestra en la pantalla.
  * @param screen El objeto Displayable a mostrar.
  */
private void setCurrent(Displayable screen) {
   if (currentScreen == null || screen != currentScreen) {
       if (screenStack == null)
           screenStack = new Stack();
            screenStack.push(currentScreen); //almacena la pantalla actual en la pila.
       currentScreen = screen;   
   }
   Display.getDisplay(this).setCurrent(currentScreen); //muestra la pantalla recibida
}

 /**
  * Muestra la pantalla anterior.
  */
public void showPrevious() {
   if (screenStack != null) {
        /*Controla si hay más de una pantalla en la pila*/
       Displayable screen = screenStack.size() > 1
            /*Si hay más de una pantalla en la pila recupera la última y la elimina de la pila.*/
           ? (Displayable)screenStack.pop()
            /* Si queda solo una, utiliza el método peek para recuperar la última pantalla
           sin borrarla de la pila.*/  
           : (Displayable)screenStack.peek();
       if (screen != null)
           Display.getDisplay(this).setCurrent(currentScreen = screen);
   }
}
}

En este ejemplo en lugar de recurrir directamente al método Display.setCurrent se recurre a estos métodos para llevar un "historial" de las pantallas recorridas. De esta forma cada vez que a lo largo de la aplicación se muestra una pantalla nueva, primero se guarda la pantalla actual en la pila y luego se muestra la nueva.

Cuando la aplicación necesita volver a la pantalla anterior, recupera la última pantalla, que estará arriba de la pila, la muestra y la elimina, usando el método pop.

Si se llega al final de la pila, quedando una sola pantalla en la pila, se utiliza el método peek para recuperar dicha pantalla sin eliminarla.

Más Información
Otro ejemplo de pilas en java: How do I use stacks in Java?
Referencia de la clase Stack: Class Stack