Cómo comprobar si una lista está vacía en Java

Introducción

En este laboratorio, aprenderás cómo comprobar de manera efectiva si una lista en Java está vacía. Exploraremos el método estándar isEmpty(), verificaremos el tamaño de la lista utilizando size() y entenderemos cómo manejar posibles escenarios de listas nulas para escribir código robusto y confiable.

Utiliza isEmpty() para comprobar la lista

En este paso, aprenderemos cómo comprobar si una lista en Java está vacía utilizando el método isEmpty(). Esta es una tarea común en la programación, y isEmpty() proporciona una forma clara y eficiente de hacerlo.

Primero, creemos un nuevo archivo Java llamado ListCheck.java en tu directorio ~/project. Puedes hacer esto haciendo clic derecho en el Explorador de archivos de la izquierda y seleccionando "Nuevo archivo", luego escribiendo ListCheck.java.

Ahora, abre ListCheck.java en el editor y agrega el siguiente código:

import java.util.ArrayList;
import java.util.List;

public class ListCheck {

    public static void main(String[] args) {
        // Create an empty list
        List<String> emptyList = new ArrayList<>();

        // Create a list with elements
        List<String> populatedList = new ArrayList<>();
        populatedList.add("Apple");
        populatedList.add("Banana");

        // Check if the lists are empty using isEmpty()
        System.out.println("Is emptyList empty? " + emptyList.isEmpty());
        System.out.println("Is populatedList empty? " + populatedList.isEmpty());
    }
}

Desglosemos este código:

import java.util.ArrayList; y import java.util.List;: Estas líneas importan las clases necesarias para trabajar con listas.
List<String> emptyList = new ArrayList<>();: Esta línea crea una nueva lista vacía que puede contener objetos String.
List<String> populatedList = new ArrayList<>();: Esta línea crea otra nueva lista.
populatedList.add("Apple"); y populatedList.add("Banana");: Estas líneas agregan elementos a la populatedList.
System.out.println("Is emptyList empty? " + emptyList.isEmpty());: Esta línea llama al método isEmpty() en emptyList. El método isEmpty() devuelve true si la lista no tiene elementos y false en caso contrario. El resultado se imprime luego en la consola.
System.out.println("Is populatedList empty? " + populatedList.isEmpty());: Esta línea hace lo mismo para populatedList.

Guarda el archivo ListCheck.java.

Ahora, abre la Terminal en la parte inferior del WebIDE y asegúrate de estar en el directorio ~/project. Puedes usar el comando cd ~/project si es necesario.

Compila el código Java utilizando el comando javac:

javac ListCheck.java

Si no hay errores, se creará un archivo ListCheck.class en el directorio ~/project.

Finalmente, ejecuta el programa Java compilado utilizando el comando java:

java ListCheck

Deberías ver una salida similar a esta:

Is emptyList empty? true
Is populatedList empty? false

Esta salida confirma que isEmpty() identificó correctamente la lista vacía y la lista con elementos. Utilizar isEmpty() es la forma preferida de comprobar si una lista está vacía en Java, ya que es más legible y potencialmente más eficiente que comprobar el tamaño.

Verificar el tamaño de la lista con size()

En el paso anterior, aprendimos cómo comprobar si una lista está vacía utilizando isEmpty(). Si bien isEmpty() es excelente para comprobar si una lista tiene algún elemento, a veces necesitas saber exactamente cuántos elementos hay en una lista. Para esto, Java proporciona el método size().

En este paso, modificaremos nuestro archivo ListCheck.java para utilizar el método size() y ver cómo funciona.

Abre el archivo ListCheck.java en el editor del WebIDE si no está abierto. Debería estar ubicado en tu directorio ~/project.

Ahora, agreguemos algunas líneas a nuestro método main para imprimir el tamaño de nuestras listas. Agrega las siguientes líneas después de las líneas donde utilizaste isEmpty():

import java.util.ArrayList;
import java.util.List;

public class ListCheck {

    public static void main(String[] args) {
        // Create an empty list
        List<String> emptyList = new ArrayList<>();

        // Create a list with elements
        List<String> populatedList = new ArrayList<>();
        populatedList.add("Apple");
        populatedList.add("Banana");

        // Check if the lists are empty using isEmpty()
        System.out.println("Is emptyList empty? " + emptyList.isEmpty());
        System.out.println("Is populatedList empty? " + populatedList.isEmpty());

        // Get and print the size of the lists using size()
        System.out.println("Size of emptyList: " + emptyList.size());
        System.out.println("Size of populatedList: " + populatedList.size());
    }
}

Agregamos dos nuevas líneas:

System.out.println("Size of emptyList: " + emptyList.size());: Esta línea llama al método size() en emptyList. El método size() devuelve el número de elementos en la lista como un entero.
System.out.println("Size of populatedList: " + populatedList.size());: Esta línea hace lo mismo para populatedList.

Guarda el archivo ListCheck.java.

Ahora, regresa a la Terminal en el directorio ~/project. Necesitamos recompilar el código Java modificado:

javac ListCheck.java

Si la compilación es exitosa, ejecuta el programa nuevamente:

java ListCheck

Ahora deberías ver una salida similar a esta:

Is emptyList empty? true
Is populatedList empty? false
Size of emptyList: 0
Size of populatedList: 2

Como puedes ver, size() informó correctamente que emptyList tiene 0 elementos y populatedList tiene 2 elementos.

Si bien podrías comprobar si una lista está vacía verificando si su tamaño es 0 (list.size() == 0), se prefiere generalmente utilizar isEmpty() por claridad y legibilidad. Sin embargo, size() es esencial cuando necesitas saber el número exacto de elementos en una lista, por ejemplo, cuando recorres la lista en un bucle o realizas cálculos basados en el número de elementos.

Manejar listas nulas

En los pasos anteriores, trabajamos con listas que estaban vacías o contenían elementos. Sin embargo, en la programación del mundo real, es posible que una variable de lista sea null. Una referencia null significa que la variable no apunta a ningún objeto en la memoria. Intentar llamar a un método como isEmpty() o size() en una lista null resultará en una NullPointerException, que es un error común en Java.

En este paso, aprenderemos cómo manejar de forma segura las listas null antes de intentar comprobar si están vacías o obtener su tamaño.

Abre el archivo ListCheck.java en el editor del WebIDE.

Vamos a agregar una nueva variable de lista y establecerla en null. Luego, demostraremos lo que sucede cuando intentas llamar a métodos en ella sin comprobar si es null. Modifica tu método main para incluir el siguiente código:

import java.util.ArrayList;
import java.util.List;

public class ListCheck {

    public static void main(String[] args) {
        // Create an empty list
        List<String> emptyList = new ArrayList<>();

        // Create a list with elements
        List<String> populatedList = new ArrayList<>();
        populatedList.add("Apple");
        populatedList.add("Banana");

        // Create a null list
        List<String> nullList = null;

        // Check if the lists are empty using isEmpty()
        System.out.println("Is emptyList empty? " + emptyList.isEmpty());
        System.out.println("Is populatedList empty? " + populatedList.isEmpty());

        // Get and print the size of the lists using size()
        System.out.println("Size of emptyList: " + emptyList.size());
        System.out.println("Size of populatedList: " + populatedList.size());

        // --- This part will cause an error if uncommented ---
        // System.out.println("Is nullList empty? " + nullList.isEmpty()); // This line will cause a NullPointerException
        // System.out.println("Size of nullList: " + nullList.size());   // This line will also cause a NullPointerException
        // ----------------------------------------------------

        // Safely check for null before calling methods
        System.out.println("\nSafely checking for null:");
        if (nullList == null) {
            System.out.println("nullList is null.");
        } else {
            System.out.println("Is nullList empty? " + nullList.isEmpty());
            System.out.println("Size of nullList: " + nullList.size());
        }

        if (emptyList == null) {
             System.out.println("emptyList is null.");
        } else {
             System.out.println("Is emptyList empty? " + emptyList.isEmpty());
             System.out.println("Size of emptyList: " + emptyList.size());
        }
    }
}

Hemos agregado:

List<String> nullList = null;: Esto declara una variable de lista pero establece su valor en null.
Líneas comentadas que causarían una NullPointerException.
Una declaración if: if (nullList == null). Esta es la parte crucial para manejar null. Comprobamos si la variable nullList es null antes de intentar llamar a cualquier método en ella. Si es null, imprimimos un mensaje. Si no es null, podemos llamar de forma segura a isEmpty() y size().
También agregamos una comprobación similar para emptyList para mostrar que la condición if también funciona correctamente para listas no nulas.

Guarda el archivo ListCheck.java.

Compila el código modificado en la Terminal:

javac ListCheck.java

Ejecuta el programa:

java ListCheck

La salida debería verse así:

Is emptyList empty? true
Is populatedList empty? false
Size of emptyList: 0
Size of populatedList: 2

Safely checking for null:
nullList is null.
Is emptyList empty? true
Size of emptyList: 0

Observa que comprobamos con éxito si nullList era null y evitamos la NullPointerException. También confirmamos que la comprobación funciona correctamente para emptyList.

Siempre recuerda comprobar si una lista (o cualquier referencia de objeto) podría ser null antes de llamar a métodos en ella. Esta es una práctica fundamental en Java para prevenir errores de NullPointerException. Un patrón común es if (myList != null && !myList.isEmpty()) para comprobar si una lista no es nula y no está vacía en una sola condición.

Resumen

En este laboratorio, aprendimos cómo comprobar si una lista en Java está vacía. Comenzamos explorando el método isEmpty(), que ofrece una forma sencilla y eficiente de determinar si una lista contiene algún elemento. Creamos listas de ejemplo, tanto vacías como con elementos, y utilizamos isEmpty() para verificar su estado, observando la salida booleana.

También examinamos cómo usar el método size() para comprobar si una lista está vacía comparando su tamaño con cero. Este método devuelve el número de elementos en la lista, y un tamaño de 0 indica una lista vacía. Finalmente, abordamos el aspecto crucial de manejar listas nulas antes de intentar comprobar si están vacías, demostrando cómo prevenir la NullPointerException agregando una comprobación de nulidad.