Cómo verificar si una pila está vacía en Java

Introducción

En este laboratorio, aprenderás cómo verificar si una Stack (pila) en Java está vacía. Exploraremos diferentes métodos para lograr esto, incluyendo el método estándar isEmpty() y el método size(). También aprenderás cómo manejar el caso de una pila nula.

A través de ejemplos prácticos, adquirirás experiencia práctica en el uso de estas técnicas para determinar la vacuidad de una Stack en Java, que es una operación fundamental cuando se trabaja con esta estructura de datos.

Skills Graph

Uso de isEmpty() para verificar una pila

En este paso, aprenderemos cómo verificar si una Stack (pila) en Java está vacía utilizando el método isEmpty(). La clase Stack es parte del Marco de Colecciones de Java y representa una pila de objetos de último en entrar, primero en salir (LIFO, por sus siglas en inglés). Verificar si una pila está vacía es una operación común cuando se trabaja con pilas, por ejemplo, antes de intentar eliminar un elemento.

El método isEmpty() es una forma simple y eficiente de determinar si una colección, incluyendo una Stack, contiene algún elemento. Devuelve true si la colección está vacía (no contiene elementos) y false en caso contrario.

Vamos a crear un sencillo programa en Java para demostrar el método isEmpty().

1. Abre el archivo HelloJava.java en el editor WebIDE si aún no está abierto.

2. Reemplaza todo el contenido del archivo con el siguiente código:

   import java.util.Stack;
   
   public class HelloJava {
       public static void main(String[] args) {
           // Create a new Stack
           Stack<String> stack = new Stack<>();
   
           // Check if the stack is empty using isEmpty()
           boolean isEmptyBeforePush = stack.isEmpty();
           System.out.println("Is the stack empty before pushing elements? " + isEmptyBeforePush);
   
           // Push some elements onto the stack
           stack.push("Element 1");
           stack.push("Element 2");
   
           // Check if the stack is empty after pushing elements
           boolean isEmptyAfterPush = stack.isEmpty();
           System.out.println("Is the stack empty after pushing elements? " + isEmptyAfterPush);
       }
   }

   Veamos las nuevas partes de este código:

   • import java.util.Stack;: Esta línea importa la clase Stack, haciéndola disponible para su uso en nuestro programa.
   • Stack<String> stack = new Stack<>();: Esta línea crea una nueva Stack vacía que puede contener objetos String.
   • stack.isEmpty();: Este es el método en el que nos estamos centrando. Verifica si el objeto stack está vacío.
   • stack.push("...");: Este método agrega un elemento a la cima de la pila.

3. Guarda el archivo (Ctrl+S o Cmd+S).

4. Ahora, vamos a compilar nuestro programa modificado. En la Terminal, asegúrate de estar en el directorio ~/project. Luego, ejecuta:

   javac HelloJava.java

   Si la compilación es exitosa, no verás ninguna salida.

5. Finalmente, vamos a ejecutar nuestro programa:

   java HelloJava

   Deberías ver una salida similar a esta:

   Is the stack empty before pushing elements? true
   Is the stack empty after pushing elements? false

   Esta salida confirma que el método isEmpty() informó correctamente el estado de la pila antes y después de agregar elementos.

Verificación con el método size()

En el paso anterior, utilizamos el método isEmpty() para verificar si una pila está vacía. Otro método útil para colecciones, incluyendo la Stack (pila), es el método size(). El método size() devuelve el número de elementos actualmente en la colección. Podemos utilizar este método para verificar si una pila está vacía comprobando si su tamaño es 0.

Si bien isEmpty() generalmente se prefiere para simplemente verificar si una colección está vacía, ya que a veces puede ser más eficiente, comprobar si size() == 0 logra el mismo resultado. Es bueno conocer ambos métodos.

Vamos a modificar nuestro programa para utilizar el método size() para verificar la vacuidad.

1. Abre el archivo HelloJava.java en el editor WebIDE.

2. Modifica el código para utilizar size() == 0 en lugar de isEmpty():

   import java.util.Stack;
   
   public class HelloJava {
       public static void main(String[] args) {
           // Create a new Stack
           Stack<String> stack = new Stack<>();
   
           // Check if the stack is empty using size()
           boolean isEmptyBeforePush = stack.size() == 0;
           System.out.println("Is the stack empty before pushing elements? " + isEmptyBeforePush);
   
           // Push some elements onto the stack
           stack.push("Element A");
           stack.push("Element B");
           stack.push("Element C");
   
           // Check the size of the stack after pushing elements
           int sizeAfterPush = stack.size();
           System.out.println("Size of the stack after pushing elements: " + sizeAfterPush);
   
           // Check if the stack is empty after pushing elements using size()
           boolean isEmptyAfterPush = stack.size() == 0;
           System.out.println("Is the stack empty after pushing elements? " + isEmptyAfterPush);
       }
   }

   Observa los cambios:

   • Reemplazamos stack.isEmpty() con stack.size() == 0 para verificar la vacuidad.
   • También agregamos una línea para imprimir el tamaño real de la pila después de agregar elementos utilizando stack.size().

3. Guarda el archivo (Ctrl+S o Cmd+S).

4. Compila el programa modificado en la Terminal:

   javac HelloJava.java

   Nuevamente, la ausencia de salida significa que la compilación fue exitosa.

5. Ejecuta el programa:

   java HelloJava

   Deberías ver una salida similar a esta:

   Is the stack empty before pushing elements? true
   Size of the stack after pushing elements: 3
   Is the stack empty after pushing elements? false

   Esta salida muestra que comprobar stack.size() == 0 identifica correctamente una pila vacía, y stack.size() devuelve el número de elementos.

Prueba con una pila nula

En los pasos anteriores, aprendimos cómo verificar si una Stack (pila) está vacía utilizando isEmpty() y size(). También es importante entender qué sucede si el objeto Stack en sí es null. En Java, null significa que una variable no se refiere a ningún objeto. Intentar llamar a un método en un objeto null resultará en una NullPointerException, que es un error de tiempo de ejecución común.

Veamos esto en acción y aprendamos cómo manejarlo.

1. Abre el archivo HelloJava.java en el editor WebIDE.

2. Modifica el código para establecer la pila en null y luego intenta verificar si está vacía:

   import java.util.Stack;
   
   public class HelloJava {
       public static void main(String[] args) {
           // Create a new Stack and then set it to null
           Stack<String> stack = new Stack<>();
           stack.push("Some Element"); // Add an element first
           stack = null; // Now set the stack variable to null
   
           // Try to check if the stack is empty using isEmpty()
           try {
               boolean isEmpty = stack.isEmpty(); // This line will cause an error
               System.out.println("Is the stack empty? " + isEmpty);
           } catch (NullPointerException e) {
               System.out.println("Caught a NullPointerException! The stack object is null.");
           }
   
           // Try to check the size using size()
           try {
                int size = stack.size(); // This line will also cause an error
                System.out.println("Size of the stack: " + size);
           } catch (NullPointerException e) {
                System.out.println("Caught a NullPointerException! Cannot get size of a null stack.");
           }
       }
   }

   Esto es lo nuevo:

   • stack = null;: Esta línea hace que la variable stack apunte a null. El objeto Stack que creamos anteriormente ya no es accesible a través de esta variable.
   • try { ... } catch (NullPointerException e) { ... }: Este es un bloque try-catch. Se utiliza para manejar posibles errores (excepciones) que pueden ocurrir durante la ejecución del código dentro del bloque try. Si se produce una NullPointerException, se ejecutará el código dentro del bloque catch.

3. Guarda el archivo (Ctrl+S o Cmd+S).

4. Compila el programa en la Terminal:

   javac HelloJava.java

   La compilación debe ser exitosa.

5. Ejecuta el programa:

   java HelloJava

   Deberías ver una salida similar a esta:

   Caught a NullPointerException! The stack object is null.
   Caught a NullPointerException! Cannot get size of a null stack.

   Esta salida muestra que intentar llamar a isEmpty() o size() en una variable de pila null resulta en una NullPointerException, y nuestros bloques try-catch manejaron exitosamente estas excepciones.

Esto demuestra por qué es crucial asegurarse de que un objeto no sea null antes de llamar a métodos en él. Puedes verificar si un objeto es null utilizando una simple condición: if (stack != null) { ... }.

Resumen

En este laboratorio, aprendimos cómo verificar si una Stack (pila) en Java está vacía. Exploramos el método principal para este propósito, isEmpty(), que es parte del Marco de Colecciones de Java (Java Collections Framework). Vimos cómo usar isEmpty() para determinar si una pila contiene algún elemento, devolviendo true si la pila está vacía y false en caso contrario.

Demostramos el uso de isEmpty() creando una nueva Stack, comprobando su estado de vacío antes y después de agregar elementos y mostrando los resultados. Este ejercicio práctico consolidó nuestra comprensión de cómo utilizar eficazmente el método isEmpty() para verificar la vacuidad de una pila en programas Java.