La manera clásica de manejar listas en un lenguaje de programación es a través de los arreglos, y Java no es la excepción. Sin embargo dado que son muy limitados, en esta ocasión vamos a conocer algo mucho mejor: el ArrayList ¿Listo para escribir código? ¡Manos a la obra!
Tabla de Contenido
¿Qué es un ArrayList y cómo se utiliza?
Básicamente es un array mejorado que puede aumentar o disminuir su tamaño a necesidad del usuario. Los ArrrayList no sólo contienen datos de un determinado tipo, sino que pueden contener otros arreglos, otros ArrayList e incluso objetos.
¿Cómo se utiliza un ArrayList?
La clase ArrayList, la vamos a encontrar en el paquete java.util. Su sintaxis es muy sencilla:
ArrayList<Tipo u Objeto> variable = new ArrayList<Tipo u Objeto>();
Siendo el elemento un Tipo u Objeto, un tipo de datos o un objeto. Por ejemplo:
// Un ArrayList de tipo String
ArrayList<String> vehiculos = new ArrayList<String>();
// Un arrayList de números enteros
ArrayList<Integer> edades = new ArrayList<Integer>();
Entonces, si hacemos una clase sencilla:
public class Carro{
private String marca;
private String modelo;
public Carro(String ma, String mo){
this.marca = ma;
this.modelo = mo;
}
public void setMarca(String ma){ this.marca = ma; }
public void setModelo(String mo){ this.modelo = mo; }
public String getMarca(){ return this.marca; }
public String getModelo(){ return this.modelo; }
}
Ahora podemos hacer un ArrayList de nuestra clase.
ArrayList<Carro> lote = new ArrayList<Carro>();
Cómo añadir elementos al ArrayList
En el caso de un ArrayList sencillo, todo lo que necesitamos hacer para añadir nuevos elementos, es invocar al método add. Por ejemplo:
vehiculos.add("Sentra");
vehiculos.add("Atos");
En el caso de un ArrayList de objetos, obviamente necesitamos primero crear las instancias del objeto, por ejemplo:
Carro auto1 = new Carro("Nissan", "Tsuru");
Carro auto2 = new Carro("Ford", "Ka");
Entonces, con el mismo método add, añadimos esas instancias al ArrayList.
lote.add(auto1);
lote.add(auto2);
Cómo acceder a los elementos del ArrayList
Con el método get podemos acceder a los elementos del ArrayList, por supuesto debemos recordar que todos los array comienzan en la posición 0. En el caso del ArrayList sencillo, tenemos sólo dos elementos en las posiciones 0 y 1 respectivamente. Así que, podemos imprimir uno de ellos de forma directa.
System.out.println(vehiculos.get(0));
O guardar el otro en una variable y luego mostrar el contenido de esa variable.
String carrito = vehiculos.get(1);
System.out.println(carrito);
Por supuesto, también podemos utilizar un ciclo para procesarlo todo junto. Si este es el caso, necesitamos invocar al método size ya que con él sabremos la cantidad de elementos que hay dentro del ArrayList.
for(int c=0;c<vehiculos.size();c++){
System.out.println("El vehículo es: " + vehiculos.get(c));
}
En el caso del ArrayList de objetos es básicamente lo mismo, sólo debemos recordar utilizar los getters de nuestra clase original. Por ejemplo, así accedemos a la marca del primer elemento.
System.out.println(lote.get(0).getMarca());
Y entonces, para acceder a los objetos con sus dos propiedades:
for(int c=0;c<lote.size();c++){
System.out.println("Marca:" + lote.get(c).getMarca());
System.out.println("Modelo:" + lote.get(c).getModelo());
}
Cómo modificar un elemento del ArrayList
Para modificar un elemento del ArrayList, utilizamos el método set. Por ejemplo, así modificamos el primer elemento del ArrayList básico.
vehiculos.set(0, "Z205");
En el caso de un ArrayList de objetos, todo lo que tenemos que hacer es utilizar los setters de la clase original y automáticamente se actualizará el ArrayList. Por ejemplo, así modificamos el segundo objeto.
auto2.setMarca("Dodge");
auto2.setModelo("Stratus");
Cómo eliminar un elemento del ArrayList
Para eliminar elementos del ArrayList utilizamos el método remove, el cuál es un sencillo y funciona igual en ambos casos. Por ejemplo, así eliminar el segundo elemento del ArrayList básico:
vehiculos.remove(1);
De manera muy similar, eliminar el segundo elemento del ArrayList de objetos.
lote.remove(1);
Cómo ordenar un ArrayList
Para ordenar un ArrayList, necesitamos utilizar el método sort, pero este se encuentra en al clase Collections que también se encuentra en java.util. Para ver esto en acción, agreguemos algunos elementos al primer ArrayList.
vehiculos.add("Atos");
vehiculos.add("CrossFox");
vehiculos.add("Alteo");
vehiculos.add("Tundra");
vehiculos.add("Beetle");
Ahora, lo ordenamos:
Collections.sort(vehiculos);
Y si recorremos de nuevo el ArrayList.
for(int c=0;c<vehiculos.size();c++){
System.out.println("El vehículo es: " + vehiculos.get(c));
}
Y el resultado se nota:
El vehículo es: Alteo
El vehículo es: Atos
El vehículo es: Beetle
El vehículo es: CrossFox
El vehículo es: Tundra
El vehículo es: Z205
Cómo hacer un ArrayList de ArrayList
En algunos casos, necesitaremos hacer un ArrayList de ArrayList, de manera similar a como se realiza una matriz de datos. Por ejemplo, aquí tenemos una matriz de enteros.
ArrayList<ArrayList<Integer>> lista = new ArrayList<ArrayList<Integer>>();
Ahora, hacemos los ArrayList que vamos a colocar ahí dentro.
ArrayList<Integer> l1 = new ArrayList<Integer>();
ArrayList<Integer> l2 = new ArrayList<Integer>();
ArrayList<Integer> l3 = new ArrayList<Integer>();
Llenamos el primer ArrayList.
l1.add(100);
l1.add(150);
l1.add(200);
Y lo agregamos a la matriz.
lista.add(l1);
Hacemos lo mismo con los otros dos.
l2.add(25);
l2.add(50);
l2.add(75);
lista.add(l2);
l3.add(1);
l3.add(2);
l3.add(3);
lista.add(l3);
Finalmente, con dos ciclos anidados recorremos su contenido.
for(int i=0;i<lista.size();i++){
for(int e=0;e<lista.get(i).size();e++){
System.out.println("Elemento en pos " + i + "," + e + ":" + lista.get(i).get(e));
}
}
Siendo este el resultado obtenido.
Elemento en pos 0,0:100
Elemento en pos 0,1:150
Elemento en pos 0,2:200
Elemento en pos 1,0:25
Elemento en pos 1,1:50
Elemento en pos 1,2:75
Elemento en pos 2,0:1
Elemento en pos 2,1:2
Elemento en pos 2,2:3
Un caso práctico: Llenar un JTable con un ArrayList
Hagamos un caso práctico para terminar de entender este tema. Llenaremos un JTable a partir de los datos obtenidos de un formulario. El formulario nos servirá para llenar un ArrayList y este servirá de fuente de datos a nuestro JTable.
Usaremos Apache NetBeans para nuestro propósito. Comenzamos creando un proyecto nuevo en NetBeans en el menú File y seleccionando New Project.
En la siguiente ventana, seleccionamos dentro de Categories la opción Java with Ant, luego en Projects elegimos Java Application. Después presionamos el botón Next.
El Project Name será TablaArrayList, después presionamos el botón Finish.
Una vez se termine de construir el proyecto necesitamos un nuevo package, ya que no es recomendable utilizar el default package. Para esto, presionamos el botón derecho del ratón sobre el default package, entonces elegimos New y en la lista de opciones escogemos Java Package.
El Package Name será tablaarraylist, después presionamos el botón Finish.
Con el package creado, haremos una primera clase que será nuestra base. Presionamos el botón derecho del ratón sobre nuestro package, elegimos New y luego Java Class en la lista.
El Class Name será Persona. Al terminar, presionamos el botón Finish.
Nuestra clase persona tendrá tres datos: Nombre, edad y correo electrónico. Por supuesto, la clase tendrá sus correspondientes getters y setters.
package tablaarraylist;
public class Persona {
private String nombre;
private Integer edad;
private String correo;
public void setNombre(String n){ this.nombre = n; }
public void setEdad(Integer e){ this.edad = e; }
public void setCorreo(String c){ this.correo = c; }
public String getNombre(){ return this.nombre; }
public Integer getEdad(){ return this.edad; }
public String getCorreo(){ return this.correo; }
}
Una vez escrita nuestra clase base, vamos a crear un JFrame. Sobre el package presionamos el botón derecho del ratón, elegimos New y después seleccionamos JFrame Form de la lista.
El Class Name será VistaPersona. Al terminar, presionamos el botón Finish.
Diseñaremos nuestro formulario como se ve en la imagen de abajo. Los nombres de variable de los objetos serán:
- txtNombre para la caja de texto del nombre
- spnEdad para el Spinner de la edad
- txtCorreo para la caja de texto de correo
- btnGuardar para el botón
- tblPersonas para el objeto JTable
Usando el botón Source, localizamos el inicio de la clase. Vamos a agregar las variables necesarias. Comenzamos con el ArrayList que se va a hacer cargo de los datos, este será de tipo Persona, es decir, basado en la primera clase que hicimos.
private ArrayList<Persona> person = new ArrayList<Persona>();
Necesitamos también un objeto de tipo Persona para manejar cada dato de forma individual.
private Persona per;
Las variables para manipular los objetos del formulario.
private String nombre;
private Integer edad;
private String correo;
Un objeto DefaultTableModel para enviar la información del ArrayList hacia el JTable.
DefaultTableModel modelo = new DefaultTableModel();
Y una variable para llevar la cuenta de los datos que vamos insertando.
private int siguiente;
Nuestra clase debe lucir así por el momento:
En el constructor de la clase, justo debajo del método initComponents iniciaremos el DefaultTableModel agregando los nombres de las columnas con el método AddColumn.
modelo.addColumn("Nombre Completo");
modelo.addColumn("Edad");
modelo.addColumn("Correo Electrónico");
También le diremos que iniciamos la cuenta del siguiente registro en 0.
siguiente = 0;
Y cargamos el modelo en nuestro JTable con el método setModel.
tblPersonas.setModel(modelo);
Así luce el constructor de la clase:
Regresemos a la vista del formulario con el botón Design. Es hora de hacer funcionar el botón, para ello, presionamos el botón derecho del ratón sobre nuestro botón, seleccionamos la opción Events, luego elegimos Action y por último actionPerformed.
¡Es hora de programar el botón! Primero haremos un sencillo vector de String de 3 posiciones:
String[] fila = new String[3];
Luego tomamos los datos de los objetos y los pasamos a nuestras variables.
nombre = txtNombre.getText();
edad = Integer.parseInt(spnEdad.getValue().toString());
correo = txtCorreo.getText();
Instanciamos nuestro objeto Persona.
per = new Persona();
Con los setters, le pasamos la información que está en nuestras variables.
per.setNombre(nombre);
per.setEdad(edad);
per.setCorreo(correo);
Agregamos nuestro objeto Persona al ArrayList.
person.add(per);
Luego, obtenemos cada valor reemplazando el índice con la variable siguiente. Recordemos que get obtiene el elemento, pero al ser un objeto debemos invocar su correspondiente getter.
fila[0] = person.get(siguiente).getNombre().toString();
fila[1] = person.get(siguiente).getEdad().toString();
fila[2] = person.get(siguiente).getCorreo().toString();
Metemos la fila que acabamos de generar al modelo.
modelo.addRow(fila);
Aumentamos la siguiente fila para la próxima interacción.
siguiente++;
Y finalmente limpiamos las cajas de texto y reseteamos el Spinner.
txtNombre.setText("");
spnEdad.setValue(0);
txtCorreo.setText("");
Así debe quedar el botón de Guardar.
Una vez terminado ¡Es hora de probar nuestro resultado! Observe el vídeo.
¿Te ha resultado? Déjanos saber en los comentarios aquí abajo, en nuestra cuenta de twitter @cablenaranja7 o en nuestra página de facebook.
Docente, IT Manager, Blogger & Developer. Escribo por diversión, educo por pasión. | Grandstanding is not my thing.
