En el entorno de ejecución de Java, la memoria se divide en varias áreas clave para la gestión de recursos. Aunque hay cinco secciones principales, como los registros, el área de métodos nativos y el área de métodos, el enfoque aquí se centra en la pila (stack) y el montón (heap).

Características de la Pila (Stack)

• La pila opera como una estructura lineal con principio LIFO (Last In, First Out), donde el último elemento añadido es el primero en eliminarse.
• Se almacena en la caché de primer nivel y se libera al finalizar la operación.
• Cada hilo de ejecución posee su propia pila, que contiene referencias a objetos o valores de tipos primitivos; los objetos en sí residen en el montón.
• Los datos en una pila son privados y no pueden ser accedidos desde otras pilas.

Características del Montón (Heap)

• El montón almacena exclusivamente objetos, cada uno vinculado a información de su clase.
• Sigue un enfoque FIFO (First In, First Out) para ciertas operaciones, aunque la gestión de memoria es dinámica.
• Es compartido por todos los hilos, con objetos almacenados en caché de segundo nivel.
• Su ciclo de vida está controlado por el recolector de basura de la JVM.

Implementación de una Pila Personalizada con ArrayList

Se puede simular una pila usando una lista de ArrayList, gestionando los elementos en el extremo superior para operaciones LIFO.

import java.util.ArrayList;

public class MiPilaEstatica {
    private ArrayList<Object> elementos = new ArrayList<>();

    public boolean estaVacia() {
        return elementos.isEmpty();
    }

    public int tamano() {
        return elementos.size();
    }

    public Object verTope() {
        if (elementos.isEmpty()) {
            return null;
        }
        return elementos.get(elementos.size() - 1);
    }

    public Object desapilar() {
        if (elementos.isEmpty()) {
            throw new RuntimeException("La pila está vacía");
        }
        return elementos.remove(elementos.size() - 1);
    }

    public void apilar(Object item) {
        elementos.add(item);
    }

    @Override
    public String toString() {
        return "PilaEstatica: " + elementos.toString();
    }
}

Ejemplo de uso con una clase de prueba:

public class PruebaPila {
    public static void main(String[] args) {
        MiPilaEstatica pila = new MiPilaEstatica();
        System.out.println("¿Vacía? " + pila.estaVacia());
        System.out.println("Tamaño: " + pila.tamano());
        pila.apilar("Elemento A");
        pila.apilar("Elemento B");
        System.out.println("Tope: " + pila.verTope());
        System.out.println("Desapilar: " + pila.desapilar());
        System.out.println("Tope tras desapilar: " + pila.verTope());
    }
}

Implementación de una Pila Personalizada con LinkedList

Alternativamente, LinkedList permite una implementación eficiente de pila mediante el manejo del primer nodo como el tope.

import java.util.LinkedList;

public class MiPilaDinamica {
    private LinkedList<Object> elementos = new LinkedList<>();

    public void apilar(Object item) {
        elementos.addFirst(item);
    }

    public Object desapilar() {
        if (elementos.isEmpty()) {
            throw new RuntimeException("La pila está vacía");
        }
        return elementos.removeFirst();
    }

    public Object verTope() {
        if (elementos.isEmpty()) {
            return null;
        }
        return elementos.getFirst();
    }

    public int tamano() {
        return elementos.size();
    }
}

Prueba de la pila con LinkedList:

public class PruebaPilaDinamica {
    public static void main(String[] args) {
        MiPilaDinamica pila = new MiPilaDinamica();
        pila.apilar("Uno");
        pila.apilar("Dos");
        pila.apilar("Tres");
        while (pila.tamano() > 0) {
            System.out.println("Elemento: " + pila.desapilar());
        }
    }
}