feed twitter facebook LinkedIn facebook

Java » Obtener elemento de un ArrayList

noviembre 20, 2014 por Víctor Cuervo Sin Comentarios Imprimir Imprimir

Hemos visto muchos ejemplos que manipulan ArrayList, que crean iteradores o iteradores de listas sobre un ArrayList. Pero como podemos realizar una operación tan sencilla como es obtener elemento de un ArrayList.

A priori podríamos pensar que tenemos que recurrir a un iterador para recuperar los elementos mediante el método .next().

  1. Iterator<String> it = al.iterator();
  2.  
  3. while(it.hasNext())
  4. System.out.println(it.next());

Pero sería muy complicado y nos obligaría a estar iterando sobre una lista.

Por otro lado podríamos pensar que ya que es un array puede ser que tenga el operador corchete [] para acceder a sus elementos.

  1. System.out.println(al[2]);

Esto no es así y el operador corchete no existe dentro de un ArrayList.

Podríamos ser más enrevesados y convertir nuestro ArrayList en un array, para, de estar forma poder acceder mediante el operador corchete.

  1. Object[] nombres = al.toArray();
  2. System.out.println(nombres[2]);

Pero la verdad es que la respuesta es mucho más sencilla y si queremos obtener elemento de un ArrayList la clave reside en utilizar el método .get() sobre el ArrayList, indicándole el índice del elemento que quieres recuperar.

De esta forma, si queremos recuperar el segundo elemento de nuestro ArrayList, nos bastará con escribir el siguiente código:

  1. System.out.println(al.get(1));

Y es que, al igual que todas las colecciones, el ArrayList se empieza a enumerar desde el índice 0 para el primer elemento.

Así que no le des vueltas y utiliza el método .get() para obtener elemento de un ArrayList.

Java » Reemplazar un elemento del ArrayList

noviembre 18, 2014 por Víctor Cuervo Sin Comentarios Imprimir Imprimir

Un ArrayList contiene una lista de elementos enlazados. Cuando estemos manipulando una lista es posible que necesitemos reeemplazar un elemento del ArrayList. De esta forma sustituiremos el contenido de uno de estos elementos por otro contenido.

Para ilustrar el ejemplo vamos a empezar creando un ArrayList.

  1. ArrayList<String> al = new ArrayList<String>();
  2.  
  3. al.add("Víctor");
  4. al.add("Luis");
  5. al.add("Elena");

Si recorremos y mostramos el contenido del ArrayList por pantalla utilizando un iterador:

  1. Iterator<String> it = al.iterator();
  2. while(it.hasNext())
  3. System.out.println(it.next());

Veremos que se nos muestra el contenido:

Víctor
Luis
Elena

Ahora vamos a reemplazar un elemento del ArrayList. En concreto vamos a cambiar el valor del elemento "Elena". Para ello necesitamos saber dos cosas, la primera es que el método que nos permite cambiar un valor es el método .set() y la segunda es la posición que ocupa para reemplazar un elemento del ArrayList.

Así ejecutamos el siguiente código:

  1. al.set(2,"Teresa");

Vemos que se indica el valor 2 como parámetro ya que las posiciones del ArrayList empiezan a enumerarse desde el 0.

Si ahora volvemos a mostrar el contenido del ArrayList saldrá por pantalla:

Víctor
Luis
Teresa

Ya hemos visto lo sencillo que es reemplazar un elemento del ArrayList mediante el método .set().

Java » Eliminar todos los elementos de un ArrayList

noviembre 16, 2014 por Víctor Cuervo 11 Comentarios Imprimir Imprimir

En este ejemplo vamos a ver como podemos eliminar todos los elementos de un ArrayList. De esta manera dejaremos elArrayList totalmente vacío.

Empezamos creando un ArrayList sobre el que insertaremos elementos:

  1. ArrayList<String> al = new ArrayList<String>();
  2.  
  3. // Añadir elementos a un ArrayList
  4. al.add("Victor");
  5. al.add("Luis");
  6. al.add("Elena");

Si comprobamos cuántos elementos contiene el ArrayList.

  1. System.out.println("La lista contiene "+al.size()+" elementos");

Veremos que nos responde que el tamaño es de 3 elementos.

Para eliminar todos los elementos de un ArrayList bastará con que ejecutemos el método .clear(). Este método lo ejecutaremos directamente sobre el ArrayList.

  1. al.clear();

Automáticamente el ArrayList se quedará vacío de elementos. Si volvemos a validar cuántos elementos contiene el ArrayList veremos que la respuesta es que el tamaño es de 0 elementos.

Java » Número de elementos en un ArrayList

noviembre 14, 2014 por Víctor Cuervo Sin Comentarios Imprimir Imprimir

Cuando estemos manipulando una lista será muy útil saber cuál es el número de elementos en un ArrayList. Ya que lo normal es que operaciones del usuario estén añadiendo y eliminando elementos de forma continua.

Lo primero, crear el ArrayList.

  1. ArrayList<String> al = new ArrayList<String>();
  2.  
  3. // Añadir elementos a un ArrayList
  4. al.add("Victor");
  5. al.add("Luis");
  6. al.add("Elena");

Podemos saber cuál es el número de elementos en un ArrayList utilizando el método .size().

  1. int tamanio = al.size();
  2. System.out.println("El número de elementos es de "+tamanio);

Una vez que sabemos cuál es el número de elementos en un ArrayList podemos realizar cosas como recorrer el ArrayList, apoyándonos en el tamaño.

  1. for(int x=0;x<tamanio;x++) {
  2. System.out.println(al.get(x));
  3. }

¿Qué otras cosas se te ocurren en las cuales es interesante saber el número de elementos en un ArrayList?

Java » Eliminar un elemento de un ArrayList

noviembre 12, 2014 por Víctor Cuervo Sin Comentarios Imprimir Imprimir

Un ArrayList es una lista de elementos enlazados. En este ejemplo vamos a ver como podemos eliminar un elemento de un ArrayList y veremos que es lo que sucede con el resto de elementos.

De igual manera que sucede con el resto de ejemplos que estamos viendo para manipular los ArrayList, vamos a crear el ArrayList.

  1. ArrayList<String> al = new ArrayList<String>();
  2.  
  3. al.add("Víctor");
  4. al.add("Luis");
  5. al.add("Elena");

En los ejemplos suelo utilizar cadenas de texto por comodidad. Pero en el tipo de elemento genérico del ArrayList podemos utilizar cualquier otro tipo, ya sea primitivo o un objeto. El resultado del código será el mismo.

Para eliminar un elemento de un ArrayList nos vamos a apoyar en el método .remove(). El método .remove() de un ArrayList espera como parámetro el índice del elemento que queremos eliminar.

Los índices de un elemento ArrayList empiezan a enumerarse por el valor 0.

De esta forma si ejecutamos el código:

  1. al.remove(1);

Sobre el ArrayList que hemos creado al principio. Y ahora listamos de nuevo el ArrayList:

  1. Iterator<String> it = al.iterator();
  2. while(it.hasNext())
  3. System.out.println(it.next());

Lo que obtendremos por pantalla será:

Víctor
Elena

Ya que el elemento que ocupaba el índice 1, que era "Luis", ha sido eliminado.

Como se puede ver, eliminar un elemento de un ArrayList es un código muy sencillo. Solo tenemos que tener en cuenta el índice que eliminamos.

Java » Recorrer una lista con ListIterator

noviembre 10, 2014 por Víctor Cuervo Sin Comentarios Imprimir Imprimir

Un ListIterator es un iterador Java que nos permite recorrer una lista de elementos en varias direcciones, bien hacia delante o bien hacía atrás. Para recorrer una lista con ListIterator lo primero que tenemos que hacer es crear una lista. En este caso vamos a crear un ArrayList.

  1. ArrayList<String> al = new ArrayList<String>();
  2.  
  3. // Añadir elementos a un ArrayList
  4. al.add("Victor");
  5. al.add("Luis");
  6. al.add("Elena");

Lo siguiente para recorrer una lista con ListIterator será obtener el puntero al iterador, esto lo conseguimos mediante el método .listIterator(). El puntero se quedará sobre un elemento ListIterator.

  1. ListIterator<String> it = al.listIterator();

Ahora que hemos obtenido el puntero podemos recorrer una lista con ListIterator desplazando el puntero hacia delante o moviendo el puntero hacía atrás. Esta segunda opción será muy útil para mostrar los elementos en orden inverso de la lista.

Podemos recorrer una lista con ListIterator hacia delante que seguirá el mismo mecanismo que cuando explicábamos como iterar un ArrayList.

De esta forma moveremos el iterador mediante el método .next() y controlaremos el final de la lista mediante el método .hasNext().

  1. while(it.hasNext())
  2. System.out.println(it.next());

Pero podemos recorrer una lista con ListIterator en orden inverso. En este caso vamos a utilizar el método .previous().

  1. while(it.hasPrevious())
  2. System.out.println(it.previous());

Sabremos si hemos llegado al principio de la lista cuando el método .hasPrevious() nos devuelva false.

Java » Iterar un ArrayList

noviembre 9, 2014 por Víctor Cuervo Sin Comentarios Imprimir Imprimir

Para ver los elementos que contiene un ArrayList podemos recorrer sus elementos mediante un simple bucle for. Otra de las formas es iterar un ArrayList. Es decir, crear un elemento Iterator que nos permita movernos por cada uno de los elementos del ArrayList.

Lo primero que necesitamos es crear el ArrayList.

  1. ArrayList<String> al = new ArrayList<String>();
  2.  
  3. // Añadir elementos a un ArrayList
  4. al.add("Victor");
  5. al.add("Luis");
  6. al.add("Elena");

Para obtener el iterador sobre el ArrayList llamaremos al método .iterator() del ArrayList y lo almacenaremos en un elemento Iterator.

  1. Iterator<String> it = al.iterator();

Para iterar un ArrayList vamos a movernos por el iterador mediante los métodos .next(). El método .next() realiza dos operaciones, por un lado obtener el elemento sobre el que está iterando y luego mover el puntero hasta el siguiente elemento.

  1. while(it.hasNext())
  2. System.out.println(it.next());

Realizaremos la operación de iterar un ArrayList hasta que no haya más elementos. Esto lo sabremos cuando el método .hasNext() nos devuelva false.

Vemos que con tres sencillas líneas hemos realizado un programa que nos permite iterar un ArrayList y mostrar todos sus elementos por pantalla.

Java » Recorrer un ArrayList

noviembre 2, 2014 por Víctor Cuervo Sin Comentarios Imprimir Imprimir

Un ArrayList es una lista de elementos los cual se puede recorrer hacía delante o hacia atrás, ya que sus elementos están enlazados entre sí. Si bien podemos recorrer un ArrayList de la forma tradicional en la que se recorren los array normales.

Para recorrer un ArrayList lo primero será crear un ArrayList.

  1. ArrayList<String> al = new ArrayList<String>();

Y, como no, rellenarlo de elementos:

  1. al.add("Victor");
  2. al.add("Luis");
  3. al.add("Elena");

Ahora vamos a recorrer un ArrayList como si fuese un array. Para ello tenemos que obtener el tamaño de un ArrayList mediante el método .size().

  1. int size=al.size();

Y ahora utilizaremos un bucle for para recorrer un ArrayList.

  1. for(int x=0;x<al.size();x++) {
  2. System.out.println(al.get(x));
  3. }

Para obtener el contenido de cada uno de los elementos vamos a apoyarnos en el método .get(), al cual pasaremos el indicador del índice de la posición que ocupa en el ArrayList. En este caso el índice lo encontramos en la variable x.

De esta forma tan sencilla hemos conseguido recorrer un ArrayList en Java. En posteriores artículos veremos como recorrer un ArrayList mediante iteradores, los cuales nos permiten recorrer hacía delante o hacía detrás.

Java » Añadir elementos al final de un ArrayList

octubre 22, 2014 por Víctor Cuervo Sin Comentarios Imprimir Imprimir

Ya hemos visto como insertar elementos en un ArrayList con el lenguaje Java, ahora vamos a ver como podemos añadir elementos al final de un ArrayList.

Para ello nos vamos a basar en tener elementos en una colección, con dicha colección podremos añadir elementos al final de un ArrayList. Así, lo primero será crear una colección con elementos. Por ejemplo un Vector:

  1. Vector<String> vector = new Vector<String>();
  2. vector.add("Irene");
  3. vector.add("María");

Ahora vamos a ver como sería nuestro ArrayList. Hemos creado ya un ArrayList al cual hemos insertado elementos para poder ver el efecto de añadir elementos al final de un ArrayList.

  1. ArrayList<String> al = new ArrayList<String>();
  2.  
  3. al.add("Victor");
  4. al.add("Luis");
  5. al.add("Elena");

Si mostramos el contenido por pantalla veremos que aparece:

{"Victor","Luis","Elena"}

Para añadir elementos al final de un ArrayList vamos a apoyarnos en el método .addAll. Dicho método recibe como parámetro la colección de elementos que hemos definido en el Vector y se ejecutará como método sobre nuestro ArrayList.

  1. al.addAll(vector);

Si ahora volvemos a recorrer nuestro ArrayList:

  1. for(int x=0;x<al.size();x++) {
  2. System.out.println(al.get(x));
  3. }

Lo que tenemos será el siguiente contenido:

{"Victor","Luis","Elena","Irene","María"}

Veremos que hemos añadido los elementos del Vector al final del ArrayList. El método .addAll nos ha servido para añadir elementos al final de un ArrayList de una forma muy sencilla.

Java » Insertar un elemento dentro de un ArrayList

octubre 20, 2014 por Víctor Cuervo 2 Comentarios Imprimir Imprimir

Un ArrayList se compone de una lista de elementos o nodos que están relacionados y los cuales podemos ir recorriendo. Y como representación de una lista podremos insertar un elemento dentro de un ArrayList.

Para poder insertar un elemento dentro de un ArrayList deberemos de saber que los elementos que hay dentro del ArrayList están numerados, siendo el 0 el índice del primer elemento.

Si creamos la siguiente ArrayList:

  1. ArrayList<String> al = new ArrayList<String>();
  2.  
  3. // Añadir elementos a un ArrayList
  4. al.add("Víctor");
  5. al.add("Luis");
  6. al.add("Elena");

Tendremos los siguientes índices:

[0] => "Víctor"
[1] => "Luis"
[2] => "Elena"

Para insertar un elemento dentro de un ArrayList vamos a ayudarnos del método .add. Este método es el mismo que utilizamos para insertar elementos en un ArrayList. Pero en este caso vamos a hacer uso del índice.

Y es que el índice será el valor que pasaremos como primer parámetro del método .add. Si se obvia dicho valor se añadirá el elemento al final de la lista.

  1. al.add(1,"Fernando");

El anterior código se utiliza insertar un elemento dentro de un ArrayList, en concreto en la posición 1. Quedándonos nuestra ArrayList de la siguiente forma:

[0] => "Víctor"
[1] => "Fernando"
[2] => "Luis"
[3] => "Elena"

Como podemos ver desplaza todos los elementos, incluido el elemento que se encontraba en dicha posición.

Si ahora queremos insertar un elemento al principio del ArrayList bastará con que indiquemos el índice 0.

  1. al.add(0,"Virginia");

Ahora nuestro ArrayList se quedará de la siguiente forma:

[0] => "Virginia"
[1] => "Víctor"
[2] => "Fernando"
[3] => "Luis"
[4] => "Elena"

Ya hemos visto como utilizar el método .add para insertar un elemento dentro de un ArrayList.