Listas en Java: tipo List

Cuando en el post de Colecciones, hablaba de las listas en Java, mencionaba dos tipos de listas: List y Set. Ahora vamos a centrarnos en las listas de tipo List que manejaremos con la clase ArrayList.

La clase ArrayList

La sintaxis de la declaración de una de estas lista con la clase ArrayList es la siguiente:

ArrayList<tipo de elemento> nombreDeLaLista = new ArrayList< > ;

Vamos a verlo con un ejemplo práctico.

Actividad: practicando con listas

  1. Abrimos un nuevo proyecto en NetBeans o cualquier otro IDE que estemos empleando. Seleccionamos Java Application como tipo de proyecto y hacemos clic en Next.
  2. Ponemos de nombre al proyecto: “practicandoConListas” y lo guardamos en alguna carpeta de nuestro ordenador de la que luego podamos recuperarlo fácilmente.
  3. Ya podemos empezar con el código. Lo primero que vamos a hacer es crearnos una Clase para luego trabajar con listas de objetos de dicha clase. Por ejemplo, nos creamos la clase estudiante:
    • Parámetros: nombre (String), edad(int), titulacion(string).
    • Un constructor con los tres parámetros.
    • Los métodos getter y setter
  1. La clase debiéramos de ser capaces de crearla sin ningún contratiempo con todo lo que ya hemos visto en cuadernos posteriores.
  2. Para practicar con la clase ArrayList tecleamos el siguiente código:
import java.util.ArrayList;
public class PracticandoConListas {

    public static void main(String[] args) {
        ArrayList<Estudiante>estudiantes= new ArrayList<>();
        
        estudiantes.add(new Estudiante("Maria",23,"Fisica"));
        estudiantes.add(new Estudiante("Juan",21,"Fisica"));
        estudiantes.add(new Estudiante("Fabiola",22,"Marketing"));
        
        System.out.println("Numero de estudiantes: "+estudiantes.size());
        System.out.println("¿Está vacia la lista de estudiantes?: "+estudiantes.isEmpty());
        System.out.println("¿Hay estudiantes?: "+!estudiantes.isEmpty());
        
        System.out.println("Vamos a vaciar la lista");
        estudiantes.clear();
        System.out.println("¿Está vacia la lista de estudiantes?: "+estudiantes.isEmpty());
    }
}
  1. En la declaración e inicialización del ArrayList estudiantes, podemos ver que le estamos indicando que el tipo de objetos que tendremos en la lista son objetos Estudiante. Y el nombre que le ponemos a la lista es estudiantes.
ArrayList<Estudiante>estudiantes= new ArrayList<>();

Estamos declarando e inicializando la lista en una misma sentencia. Podríamos hacerlo en dos sentencias distintas:

 ArrayList<Estudiante>estudiantes;
 estudiantes = new ArrayList<>();

En cualquier caso, lo más habitual es realizar ambas operaciones en una misma línea de código.

  1. Introducimos tres objetos Estudiante en la lista empleando el método add.
estudiantes.add(new Estudiante("Maria",23,"Fisica"));
estudiantes.add(new Estudiante("Juan",21,"Fisica"));
estudiantes.add(new Estudiante("Fabiola",22,"Marketing"));
  1. Empleo uno de los métodos más habituales de la Clase ArrayList, el método .size() , que devuelve el tamaño de la lista. Se dibuja en pantalla el valor obtenido.
System.out.println("Numero de estudiantes: "+estudiantes.size());
  1. Utilizamos el método .isEmpty() , para mostrar si la lista tiene objetos o está vacía. En las dos sentencias repito el mismo método, pero en la segunda antepongo el símbolo Negación (!) y cambio el valor de la variable booleana que devuelve el método.
System.out.println("¿Está vacia la lista de estudiantes?: "+estudiantes.isEmpty());
System.out.println("¿Hay estudiantes?: "+!estudiantes.isEmpty());
  1. Empleamos otro método muy útil, el método: .clear() , que vacía la lista de objetos. Este método no destruye la lista, que sigue estando operativa para trabajar con ella.
  2. Si ejecutamos el programa, obtenemos el siguiente resultado:
run:
Numero de estudiantes: 3
¿Está vacia la lista de estudiantes?: false
¿Hay estudiantes?: true
Vamos a vaciar la lista
¿Está vacia la lista de estudiantes?: true
BUILD SUCCESSFUL (total time: 0 seconds)
  1. Después de estas operaciones básicas con la lista, vamos a ver como recorrer la lista recuperando los objetos dentro de la misma. Para ello usaremos un ciclo for clásico. Teclea el siguiente código:
import java.util.ArrayList;
public class PracticandoConListas {
    public static void main(String[] args) {
        ArrayList<Estudiante>estudiantes= new ArrayList<>();
        estudiantes.add(new Estudiante("Maria",23,"Fisica"));
        estudiantes.add(new Estudiante("Juan",21,"Fisica"));
        estudiantes.add(new Estudiante("Fabiola",22,"Marketing"));
        System.out.println("Recorriendo el array");          
        for (int i=0; i<estudiantes.size();i++){
            Estudiante est = estudiantes.get(i);
            System.out.println(est.getNombre());
        }
    }
}
  1. Recorremos la lista con una sentencia for, empleando el método .size() para limitar las iteraciones del bucle al número de elementos de la lista.
for (int i=0; i<estudiantes.size();i++){
    Estudiante est = estudiantes.get(i);
    System.out.println(est.getNombre());
}

Nos creamos un objeto tipo Estudiante al que llamamos est y, empleando el método get(), recuperamos el objeto de la lista que se encuentre en la posición indicada por el índice i. Hay que tener en cuenta que igual que en los arrays, el primer elemento tiene el índice i=0.

  1. Ejecutamos el programa y obtenemos el resultado:
run:
Recorriendo el array
Maria
Juan
Fabiola
BUILD SUCCESSFUL (total time: 0 seconds)
  1. No obstante, cuando recorramos una lista de objeto, lo más habitual es que empleemos un bucle for:each, en lugar de un bucle for con un iterador, más propio de los arrays.
  2. Para recorrer la lista con el nuevo bucle for, sustituimos las sentencias del bucle for clásico por las siguientes:
for (Estudiante est:estudiantes){
    System.out.println(est.getNombre());
}

Si ejecutamos el programa, veremos que el resultado que obtenemos es el mismo que con el otro bucle.

  1. Nos queda por probar una cosa: que las listas admiten objetos repetidos. Para ello, añadimos al final de la lista el mismo objeto que añadimos al inicio y probamos que pasa. El código del programa quedaría:
import java.util.ArrayList;
public class PracticandoConListas {
    public static void main(String[] args) {
        ArrayList<Estudiante>estudiantes= new ArrayList<>();
        estudiantes.add(new Estudiante("Maria",23,"Fisica"));
        estudiantes.add(new Estudiante("Juan",21,"Fisica"));
        estudiantes.add(new Estudiante("Fabiola",22,"Marketing"));
        estudiantes.add(new Estudiante("Maria",23,"Fisica"));
        System.out.println("Recorriendo el array");
        System.out.println("---------------------");
        for (Estudiante est:estudiantes){
            System.out.println(est.getNombre());
        }
    }
}

Y el resultado al ejecutar el programa sería:

run:
Recorriendo el array
---------------------
Maria
Juan
Fabiola
Maria
BUILD SUCCESSFUL (total time: 0 seconds)

Con lo que podemos comprobar, que las listas tipo List, admiten duplicados.

  1. Para continuar con la practica de las listas, vamos a ver como emplearlas en métodos. Una acción muy habitual es buscar un objeto por uno de sus parámetros en una lista. Para ello, en nuestro código anterior, vamos a crearnos un método que podamos emplear para recuperar un estudiante de la lista, buscando por el nombre del estudiante. El código completo del programa sería:
import java.util.ArrayList;
public class PracticandoConListas {
    public static void main(String[] args) {
        ArrayList<Estudiante>estudiantes= new ArrayList<>();
        estudiantes.add(new Estudiante("Maria",23,"Fisica"));
        estudiantes.add(new Estudiante("Juan",21,"Fisica"));
        estudiantes.add(new Estudiante("Fabiola",22,"Marketing"));
        estudiantes.add(new Estudiante("Maria",23,"Fisica"));
        System.out.println("Buscando un estudiante en la lista de clase");
        System.out.println("-------------------------------------------");
        Estudiante estBuscado = encontrarEstudiante (estudiantes,"Fabiola");
        if (estBuscado!=null){
            System.out.println("estudiante encontrado: " +estBuscado.getNombre());
        }else{
            System.out.println("El estudiante buscado no está en la lista");
        }
    }
    public static Estudiante encontrarEstudiante (ArrayList<Estudiante> listaClase, String nombre){
        for (Estudiante est: listaClase){
            if(est.getNombre().equalsIgnoreCase(nombre)){
                return est;
            }
        }
        return null;
    }
}
  1. Veamos primero el método empleado. Definimos el método encontrarEstudiante que devuelve un objeto Estudiante y hay que pasarle como parámetros: la lista de estudiantes y el nombre del estudiante que buscamos.
public static Estudiante encontrarEstudiante (ArrayList<Estudiante> listaClase, String nombre){
    for (Estudiante est: listaClase){
        if(est.getNombre().equalsIgnoreCase(nombre)){
            return est;
        }
    }
    return null;
}

Este método lo declaramos como static para poder usarlo sin tener que crear un objeto.

Programamos un bucle for:each que utiliza el método encontrarEstudiante para recorrer la lista pasada como parámetro: listaClase.

Para cada objeto en la lista, comparamos su propiedad nombre con el parámetro nombre que pasamos al método y que pretende ser el nombre del estudiante que buscamos.

Para comparar los dos nombres, empleamos el método equalsIgnoreCase() de la clase String, que compara las dos cadenas de caracteres ignorando si las letras de dichas cadenas son mayúsculas o minúsculas.

Las instrucciones return, devuelven el objeto Estudiante caso de que lo encuentre en la lista, o null si no está en la lista.

  1. Utilizamos ahora la función desde el método main. : llamamos a la función encontrarEstudiante pasándole la lista estudiantes y el nombre “Fabiola”. El objeto que nos devuelve la función lo guardamos en el objeto estBuscado del tipo Estudiante.
Estudiante estBuscado = encontrarEstudiante (estudiantes,"Fabiola");

Y mostramos por pantalla un mensaje, indicando si hemos encontrado o no al estudiante en la lista.

  1. Ejecutamos el programa y obtenemos el resultado:
run:
Buscando un estudiante en la lista de clase
-------------------------------------------
estudiante encontrado:Fabiola
BUILD SUCCESSFUL (total time: 0 seconds)

Probablemente te habrás fijado que con el programa anterior se devuelve el primer estudiante que se encuentra con el nombre que buscamos, pero podría darse la situación de que hubiera varios estudiantes con el mismo nombre. En este caso, tendríamos que recuperar todos los objetos Estudiante que tuvieran dicho nombre.

  1. Vamos a modificar nuestro método encontrarEstudiante para que nos devuelva todos los estudiantes que encuentre en la lista que tengan el nombre que pasamos como parámetro. El método nos tendrá que devolver una lista de objetos Estudiantes. Tecleamos el siguiente código:
import java.util.ArrayList;
public class PracticandoConListas {
    public static void main(String[] args) {
        ArrayList<Estudiante>estudiantes= new ArrayList<>();
        estudiantes.add(new Estudiante("Maria",23,"Fisica"));
        estudiantes.add(new Estudiante("Juan",21,"Fisica"));
        estudiantes.add(new Estudiante("Fabiola",22,"Marketing"));
        estudiantes.add(new Estudiante("Maria",20,"Lengua"));
        System.out.println("Buscando estudiantes en la lista de clase");
        ArrayList<Estudiante>estudiantesEncontrados= new ArrayList<>();
        estudiantesEncontrados = encontrarEstudiante (estudiantes,"Maria");
        System.out.println("Estudiantes encontrados:");
        System.out.println("-------------------------");
        for (Estudiante e: estudiantesEncontrados){
            System.out.println (e.getNombre()+" - Edad: "+e.getEdad()+" - Estudia: "+e.getTitulacion());
        }
    }
    public static ArrayList<Estudiante> encontrarEstudiante (ArrayList<Estudiante> listaClase, String nombre){
        ArrayList<Estudiante> est = new ArrayList<>();
        for (Estudiante e: listaClase){
            if(e.getNombre().equalsIgnoreCase(nombre)){
                est.add(e);
            }
        }
        return est;
    }
}

La declaración del método estático encontrarEstudiante. Lo único que cambia sobre la declaración anterior es que ahora nos va a devolver una lista de objetos Estudiante y no un único objeto Estudiante. Puede verse que el tipo de dato que devuelve el método es ArrayList<Estudiante>.

Nos creamos una lista de objetos Estudiante donde iremos guardando los estudiantes que encontremos en listaClase con el nombre que buscamos. En realidad, es nuestra sublista.

Igual que en el método anterior, recorremos listaClase con un bucle for:each. Comprobamos con una sentencia if si el objeto en el que nos encontramos tiene el nombre que buscamos. Y, en este último caso, añadimos el objeto a la lista est que nos hemos creado al principio del método.

Devolvemos la lista est, que será un subset de la lista inicial que pasamos al método en el parámetro listaClase

  1. Vamos a ver ahora como utilizamos este nuevo método desde el método main.
estudiantesEncontrados = encontrarEstudiante (estudiantes,"Maria");

Definimos la lista de objetos Estudiante estudiantesEncontrados. Guardamos en estudiantesEncontrados la lista que nos devuelve el método encontrarEstudiante. En este caso probamos con el nombre “Maria” ya que sabemos que tenemos dos Marias en la lista, para comprobar que el método funciona correctamente.

  1. Empleando un bucle for:each, presentamos por pantalla todos los objetos de la lista estudiantesEncontrados.
for (Estudiante e: estudiantesEncontrados){
    System.out.println (e.getNombre()+" - Edad: "+e.getEdad()+" - Estudia: "+e.getTitulacion());
}
  1. Si ejecutamos el programa obtenemos el siguiente resultado:
run:
Buscando estudiantes en la lista de clase
Estudiantes encontrados:
-------------------------
Maria - Edad: 23 - Estudia: Fisica
Maria - Edad: 20 - Estudia: Lengua
BUILD SUCCESSFUL (total time: 0 seconds)
  1. Finalmente, para acabar con las listas tipo list, vamos a introducir el método remove(), que se emplea para borrar un elemento de la lista. El argumento de este método puede ser el índice del objeto en la lista o un objeto que hallamos recuperado de la lista. Veámoslo en un ejemplo.

Tecleamos el código:

import java.util.ArrayList;
public class PracticandoConListas {
    public static void main(String[] args) {
        ArrayList<Estudiante>estudiantes= new ArrayList<>();
        estudiantes.add(new Estudiante("Maria",23,"Fisica"));
        estudiantes.add(new Estudiante("Juan",21,"Fisica"));
        estudiantes.add(new Estudiante("Fabiola",22,"Marketing"));
        estudiantes.add(new Estudiante("Maria",20,"Lengua"));
        System.out.println("Borrando estudiantes de la lista");
        System.out.println("-------------------------------------");
        System.out.println("Lista inicial");
        System.out.println("-------------------------------------");
        dibujarEstLista(estudiantes);
        System.out.println("Borramos primer elemento");
        System.out.println("-------------------------------------");
        estudiantes.remove(0);        
        dibujarEstLista(estudiantes);
        System.out.println("Borramos otro estudiante");
        System.out.println("-------------------------------------");
        Estudiante est = new Estudiante("",1,"");
        for (Estudiante e: estudiantes){
            est=e;
        }
        estudiantes.remove(est);
        dibujarEstLista(estudiantes);
    }
    public static void dibujarEstLista(ArrayList<Estudiante> listaClase){
    System.out.println("Numero de estudiantes en la lista: "+listaClase.size());
    for (Estudiante e: listaClase){
            System.out.println (e.getNombre()+" - Edad: "+e.getEdad()+" - Estudia: "+e.getTitulacion());
        }
    }
}
  1. Definimos el método dibujarEstLista que dibuja todos los estudiantes en la lista que se le pase. Empleando el método, podremos dibujar la lista antes de modificarla y después de haberla modificado, comprobando si las modificaciones se han realizado correctamente.
public static void dibujarEstLista(ArrayList<Estudiante> listaClase){
System.out.println("Numero de estudiantes en la lista: "+listaClase.size());
for (Estudiante e: listaClase){
    System.out.println (e.getNombre()+" - Edad: "+e.getEdad()+" - Estudia: "+e.getTitulacion());
    }
}
  1. Borramos el primer objeto de la lista utilizando el método remove(), pasándole el índice 0.
estudiantes.remove(0);
  1. Recorremos toda la lista almacenando los distintos objetos en el objeto est, con lo que al final del bucle, el objeto almacenado en est será el último de la lista.
for (Estudiante e: estudiantes){
    est=e;
}
  1. Borramos el último objeto de la lista utilizando la función remove() y pasándole el objeto est en el que habíamos guardado el último objeto de la lista.
estudiantes.remove(est);

Si ejecutamos el programa obtenemos el siguiente resultado:

run:
Borrando estudiantes de la lista
-------------------------------------
Lista inicial
-------------------------------------
Numero de estudiantes en la lista: 4
Maria - Edad: 23 - Estudia: Fisica
Juan - Edad: 21 - Estudia: Fisica
Fabiola - Edad: 22 - Estudia: Marketing
Maria - Edad: 20 - Estudia: Lengua
Borramos primer elemento
-------------------------------------
Numero de estudiantes en la lista: 3
Juan - Edad: 21 - Estudia: Fisica
Fabiola - Edad: 22 - Estudia: Marketing
Maria - Edad: 20 - Estudia: Lengua
Borramos otro estudiante
-------------------------------------
Numero de estudiantes en la lista: 2
Juan - Edad: 21 - Estudia: Fisica
Fabiola - Edad: 22 - Estudia: Marketing
BUILD SUCCESSFUL (total time: 0 seconds)

NOTA: Este post es parte de la colección “Java”. Puedes ver el índice de esta colección aquí.

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.