1. Fundamentos de Informática (UNED – Grados Ingeniería)
ArrayList en Java2 usando BlueJ
Ejemplo:
Se puede observar en la lista:
• se llama ElementData.
• incluye, en este caso, tres
elementos “examen”, “cumple
Neleta” y “recoger a los
monstruitos”.
• La longitud indicada en length
=10 no nos tiene que preocupar
porque podrá crecer
automáticamente cuando se
necesite.
Definición:
La clase ArrayList facilita la creación y manipulación listas. Se encuentra en el paquete
java.util.ArrayList que deberemos importar antes de usar:
Tutor: Antonio Peris (Dénia)

2. Fundamentos de Informática (UNED – Grados Ingeniería)
La clase ArrayList es útil cuando implementamos un programa que agrupa datos de un
mismo tipo y no sabemos cuántos valores se agruparán. Una lista ofrece dos
ventajas significativas:
• puede crecer o disminuir cuanto sea necesario.
• ofrece métodos genéricos para las operaciones comunes, tal como insertar,
eliminar, ver elementos y otros más... (buscar en google con estos parámetros:
arraylist java site:oracle.com)
Declaración de una Lista:
Se escribe el tipo de los elementos dentro de < > y el nombre de la propia lista. De la
siguiente forma:
private ArrayList <String> notas;
En este caso, String es el tipo de dato que se guardará dentro de la lista y notes es el
nombre asignado a esta agrupación.
La única restricción es que NO podemos utilizar tipos primitivos: int, float, char,
double,... Para superar el problema se emplea el autoboxing.
=
import java.util.ArrayList;
public class LibretaAnotaciones
{
private ArrayList<String> notas;
public LibretaAnotaciones()
{
notas = new ArrayList<String>();
}
}
Ya tenemos hecha la libreta de anotaciones. Ahora, habrá que gestionar las anotaciones
con algunos métodos genéricos que nos ofrece la clase ArrayList.
Tutor: Antonio Peris (Dénia)

3. Fundamentos de Informática (UNED – Grados Ingeniería)
Métodos más utilizados con un objeto ArrayList :
add: añade un elemento
Existen dos formas:
• Añadir al final de la lista, método: public boolean add(E e). Ejemplo:
public void guardaNota(String nota)
{
notas.add(nota);
}
Antes Después de notas.add(“recoger
monstruitos”);
• Añadir en un lugar concreto y resto de elementos posteriores incluidos en la lista
pasarán a la siguientes posiciones consecutivas. Método: public void add(int
index,E element). El parámetro index será la posición de la lista a añadir el valor el
elemento indicado por element. Ejemplo:
public void guardaNota(int posicion, String nota)
{ notas.add(posicion,nota); }
Antes Después de notas.add( 1 ,"cumple Neleta");
Tutor: Antonio Peris (Dénia)

4. Fundamentos de Informática (UNED – Grados Ingeniería)
get: retorna un elemento.
El método public E get(int index). El parámetro index será la posición del elemento
solicitado de la lista. Ejemplo:
public String leeNota(int numNota)
{
return notas.get(numNota);
}
}
Lista Retorno de notas.leeNota (1);
remove: elimina un elemento
El método public E remove(int index). El parámetro index será la posición del elemento a
borrar de la lista. El resto de elementos siguientes avanzarán una posición de la lista,
evitando que hayan huecos en ella. Ejemplo:
public void borraNota(int numNota)
{
notas.remove(numNota);
}
Antes Después de notas.remove( 1 );
Tutor: Antonio Peris (Dénia)

5. Fundamentos de Informática (UNED – Grados Ingeniería)
set: cambia un elemento
El método public E set(int index, E element). El parámetro index será la posición del
elemento a cambiar, el valor nuevo será indicado en el parámetro element. Ejemplo:
public void modificaNota(int numNota, String nuevoValor)
{
notas.set(numNota,nuevoValor);
}
Antes Después de notas.modificaNota(2,”recoger a los
niños” );
size: longitud del arrayList
El método public int size(). Se utiliza para saber el tamaño de la lista. Ejemplo:
public int numeroDeNotas()
{
return notas.size();
}
Lista Retorno de notas.numeroDeNotas();
Tutor: Antonio Peris (Dénia)

6. Fundamentos de Informática (UNED – Grados Ingeniería)
Recorrer una lista
Existen dos formas:
Toda la lista:
Mediante un bucle que recorra todo el ArrayList: empieza por el elemento 0 y acaba
en el último elemento. Si está vacía no imprime nada.
for ( TipoDeObjetoDelArray nombreVariable ParaElBucle : nombreDelArrayList )
{ ...
sentencias a ejecutar
...
}
Ejemplo:
public void imprimeNotas()
{
for (String notaLocal : notas){
System.out.println(notaLocal);
}
}
Lista Impresión por el terminal
Tutor: Antonio Peris (Dénia)

7. Fundamentos de Informática (UNED – Grados Ingeniería)
Hasta que se encuentre el elemento buscado:
El Iterador o repetidor es un objeto del mismo tipo que el contenido del ArrayList
que se utiliza acceder secuencialmente a los elementos del ArrayList,
Iterator<String> iterador = notas.iterator();
Iterator <TipoDeObjetoDelArray> nombreDelIterador = nombreDelArrayList.iterator();
Se requiere importar el iterador que nos servirá para movernos por la lista:
import java.util.Iterator;
Métodos del Iterador:
• hasNext() : devuelve true si la iteración tiene más elementos.
Según la figura superior, sería e l bastón .
• next() : devuelve el objeto en curso y, luego, automáticamente
va al siguiente elemento de la iteración. Según la figura
superior, sería la acción de subir y el valor del escalón .
Tutor: Antonio Peris (Dénia)

8. Fundamentos de Informática (UNED – Grados Ingeniería)
public void subeEscalera(){
ArrayList <String> escalera;
escalera = new ArrayList<String>();
escalera.add("escalon1"); escalera.add("escalon2"); escalera.add("escalon3");
Iterator<String> iterador = escalera.iterator();
System.out.println("¿Hay más escalones? "+ iterador.hasNext());
while (iterador .hasNext() ) {
System.out.println("subo "+ iterador .next() + "n");
System.out.println("¿Hay más escalones? "+ iterador.hasNext());
}
}
Con lo visto hasta ahora, este mecanismo es similar al for visto anteriormente. Esto
es, recorrerá todo el ArrayList. Vamos a establecer las condiciones adicionales
de finalización del recorrido:
▪ Llegue al final de la lista sin encontrar el elemento (similar al for). Ejemplo
anterior.
▪ Encuentra el elemento: se le añade una nueva condición (en el ejemplo
siguiente, encuentra “escalon2”)
public void subeEscaleraEscalon2(){
ArrayList <String> escalera;
escalera = new ArrayList<String>();
escalera.add("escalon1"); escalera.add("escalon2"); escalera.add("escalon3");
Iterator<String> iterador = escalera.iterator();
boolean encontrado=false;
String it; // variable para utilizar el iterador sin incrementarlo
System.out.println("¿Hay más escalones? "+ iterador.hasNext());
while (iterador.hasNext() && !encontrado){
it=iterador.next(); // incrementa el iterador y almacena en i t
System.out.println("subo "+ it + "n");
if (it.contains("escalon2")){
encontrado=true;
System.out.println("Encontrado elemento: no continúa");
}
System.out.println("¿Hay más escalones? "+ iterador.hasNext());
}
}
Tutor: Antonio Peris (Dénia)

9. Fundamentos de Informática (UNED – Grados Ingeniería)
Resultado por terminal del método anterior subeEscaleraEscalon2():
Ejemplo de la iteración paso a paso sin bucles:
public void iterandoPasoApaso(){
Iterator<String> iterador = notas.iterator();
//siguiente elemento
System.out.println("tttraza elemento iterador.hasNext() "+ iterador.hasNext());
// traza por el elemento que accede y, luego, va al siguiente
System.out.println("ttraza elemento iterador.next() "+ iterador.next());
System.out.println("n");
//siguiente elemento
System.out.println("tttraza elemento iterador.hasNext() "+ iterador.hasNext());
// traza por el elemento que accede y, luego, va al siguiente
System.out.println("ttraza elemento iterador.next() "+ iterador.next());
System.out.println("n");
//siguiente elemento
System.out.println("tttraza elemento iterador.hasNext() "+ iterador.hasNext());
// traza por el elemento que accede y, luego, va al siguiente
System.out.println("ttraza elemento iterador.next() "+ iterador.next());
System.out.println("n");
// si se añadiese un elemento más, como no existe, daría un error/excepción
}
Tutor: Antonio Peris (Dénia)

10. Fundamentos de Informática (UNED – Grados Ingeniería)
De una manera genérica:
// inicialización del iterador o repetidor
Iterator <TipoDeObjetoDelArray> nombreVariableParaElBucle =
nombreDelArrayList.iterator();
// iniciado de las varibles u objetos temporales para uso dentro del bucle
boolean encontrado=false;
TipoDeObjetoDelArray it;
// bucle que recorrerá el ArrayList mientras se cumplan las dos condiciones
while (nombreVariableParaElBucle.hasNext() && !encontrado) {
it = nombreVariableParaElBucle.next()
¿ it es el elemento buscado?
…....
.. . …
}
Ejemplo con la libreta de anotaciones:
public void buscaNota(String patronBusqueda) {
// recuerda que hay que importar el Iterador
// inicialización
Iterator<String> iterador = notas.iterator();
boolean encontrado=false;
String it;
//bucle de búsqueda. Comprueba:
// - Quedan más elementos en la lista
// - No lo ha encontrado
while (iterador.hasNext() && !encontrado) {
it=iterador.next();
// traza por el elemento que accede
System.out.println(“traza elemento”+ it);
// comprueba si el elemento de la lista contiene
// el patrón de búsqueda
if (it.contains(patronBusqueda)){
System.out.println("encontrado: " + it);
encontrado= true;
}
}
System.out.println("Fin de búsqueda");
}
Tutor: Antonio Peris (Dénia)

11. Fundamentos de Informática (UNED – Grados Ingeniería)
Lista Búsqueda de “Neleta”
Tutor: Antonio Peris (Dénia)

12. Fundamentos de Informática (UNED – Grados Ingeniería)
Código completo:
import java.util.ArrayList;
import java.util.Iterator;
public class LibretaAnotaciones
{
private ArrayList<String> notas;
public LibretaAnotaciones()
{
notas = new ArrayList<String>();
notas.add("examen");
notas.add("cumple Neleta");
notas.add("recoger a los monstruitos");
}
public void guardaNota(String nota)
{
notas.add(nota);
}
public void guardaNota(int posicion, String nota)
{
notas.add(posicion,nota);
}
public int numeroDeNotas()
{
return notas.size();
}
public void borraNota(int numNota)
{
notas.remove(numNota);
}
public void modificaNota(int numNota, String nuevoValor)
{
notas.set(numNota,nuevoValor);
}
public void imprimeNotas()
{
for (String notaLocal : notas){
System.out.println(notaLocal);
}
}
Tutor: Antonio Peris (Dénia)

13. Fundamentos de Informática (UNED – Grados Ingeniería)
public void buscaNota(String patronBusqueda)
{
// recuerda que hay que importar el Iterador
// inicialización
Iterator<String> iterador = notas.iterator();
boolean encontrado=false;
//bucle de búsqueda. Comprueba:
// - Quedan más elementos en la lista
// - No lo ha encontrado
while (iterador.hasNext() && !encontrado) {
String it=iterador.next();
// traza por el elemento que accede
System.out.println("traza elemento "+ it);
// comprueba si el elemento de la lista contiene
// el patrón de búsqueda
if (it.contains(patronBusqueda)){
System.out.println("encontrado: " + it);
encontrado= true;
}
}
System.out.println("Fin de búsqueda");
}
public void iterando()
{
System.out.println("Inicio de biterando");
Iterator<String> iterador = notas.iterator();
int cont=0;
System.out.println("ttraza valor inicial iterador.hasNext() "+ iterador.hasNext());
System.out.println("empieza el bucle");
while (iterador.hasNext()) {
System.out.println("tvuelta número" + ++cont);
// traza por el elemento que accede
System.out.println("ttraza elemento iterador.Next() "+ iterador.next());
//siguiente elemento
System.out.println("tttraza elemento iterador.hasNext() "+ iterador.hasNext());
System.out.println("n");
}
System.out.println("Fin de bucle e iterando");
}
Tutor: Antonio Peris (Dénia)

14. Fundamentos de Informática (UNED – Grados Ingeniería)
public void iterandoPasoApaso()
{
Iterator<String> iterador = notas.iterator();
//siguiente elemento
System.out.println("¿tiene siguiente elemento? = iterador.hasNext()? "+ iterador.hasNext());
// traza por el elemento que accede
System.out.println("dame es siguiente elemento = iterador.Next() "+ iterador.next());
System.out.println("n");
System.out.println("¿tiene siguiente elemento? = iterador.hasNext()? "+ iterador.hasNext());
// traza por el elemento que accede
System.out.println("dame es siguiente elemento = iterador.Next() "+ iterador.next());
System.out.println("n");
System.out.println("n");
System.out.println("¿tiene siguiente elemento? = iterador.hasNext()? "+ iterador.hasNext());
// traza por el elemento que accede
System.out.println("dame es siguiente elemento = iterador.Next() "+ iterador.next());
System.out.println("n");
System.out.println("n");
}
public void iterandorBucleSimple()
{
Iterator<String> iterador = notas.iterator();
while (iterador.hasNext()){
//iterador.next();
System.out.println("elemento "+ iterador.next());
}
}
public void subeEscalera()
{
ArrayList <String> escalera;
escalera = new ArrayList<String>();
escalera.add("escalon1");
escalera.add("escalon2");
escalera.add("escalon3");
Iterator<String> iterador = escalera.iterator();
System.out.println("¿Hay más escalones? "+ iterador.hasNext());
while (iterador.hasNext()){
//iterador.next();
System.out.println("subo "+ iterador.next() + "n");
System.out.println("¿Hay más escalones? "+ iterador.hasNext());
}
}
Tutor: Antonio Peris (Dénia)

15. Fundamentos de Informática (UNED – Grados Ingeniería)
public void subeEscaleraEscalon2()
{
ArrayList <String> escalera;
escalera = new ArrayList<String>();
escalera.add("escalon1");
escalera.add("escalon2");
escalera.add("escalon3");
Iterator<String> iterador = escalera.iterator();
boolean encontrado=false;
String it; // variable para utilizar el iterador sin incrementarlo
System.out.println("¿Hay más escalones? "+ iterador.hasNext());
while (iterador.hasNext() && !encontrado){
it=iterador.next(); // incrementa el iterador
System.out.println("subo "+ it + "n");
if (it.contains("escalon2")){
encontrado=true;
System.out.println("Encontrado elemento: no continúa");
}
System.out.println("¿Hay más escalones? "+ iterador.hasNext());
}
}
}
Tutor: Antonio Peris (Dénia)