Java ArrayList.

Estructura dinmica de datos

DECLARACIN Y CREACIN DE UN ARRAYLIST

De forma general un ArrayList en Java se crea de la siguiente forma:

ArrayList nombreArray = new ArrayList();
Esta instruccin crea el ArrayList nombreArray vaco.
Un arrayList declarado as puede contener objetos de cualquier tipo.
Por ejemplo:
ArrayList a = new ArrayList();
a.add("Lenguaje");
a.add(3);
a.add('a');
a.add(23.5);
Los elementos del arrayList a son:
Lenguaje 2 a 23.5
Es decir, un ArrayList puede contener objetos de tipos distintos.
En este ejemplo, el primer objeto que se aade es el String Lenguaje. El resto no son
objetos. Son datos de tipos bsicos pero el compilador los convierte automticamente
en objetos de su clase envolvente(clase contenedora o wrapper) antes de aadirlos
al array.
Un array al que se le pueden asignar elementos de distinto puede tener alguna
complicacin a la hora de trabajar con l. Por eso, una alternativa a esta declaracin es
indicar el tipo de objetos que contiene. En este caso, el array solo podr contener
objetos de ese tipo.
De forma general:
ArrayList<tipo> nombreArray = new ArrayList<tipo>();
tipo debe ser una clase. Indica el tipo de objetos que contendr el array.
No se pueden usar tipos primitivos. Para un tipo primitivo se debe utilizar su clase
envolvente.
Por ejemplo:
ArrayList<Integer> numeros = new ArrayList<Integer>();
Crea el array numeros de enteros.

MTODOS DE ARRAYLIST

Algunos mtodos que proporciona ArrayList son:

MTODO

DESCRIPCIN

size()

Devuelve el nmero de elementos (int)

add(X)

Aade el objeto X al final. Devuelve true.

add(posicin, X)

Inserta el objeto X en la posicin indicada.

get(posicion)

Devuelve el elemento que est en la posicin

indicada.

remove(posicion)

Elimina el elemento que se encuentra en la

posicin
indicada.
eliminado.

Devuelve

el

elemento

remove(X)

Elimina la primera ocurrencia del objeto

Devuelve true si el elemento est en la lista.

clear()

Elimina todos los elementos.

set(posicin, X)

Sustituye el elemento que se encuentra en la

posicin indicada por el objeto X. Devuelve el
elemento sustituido.

contains(X)

Comprueba si la coleccin contiene al objeto X.

Devuelve true o false.

indexOf(X)

Devuelve la posicin del objeto X. Si no existe

devuelve -1

Los puedes consultar todos en:

http://docs.oracle.com/javase/7/docs/api/java/util/ArrayList.html

RECORRER UN ARRAYLIST
Podemos recorrerlo de forma clsica con un bucle for:
for(int i = 0;i<array.size();i++){
System.out.println(array.get(i));
}
Con un bucle foreach:
Si suponemos el array de enteros llamado numeros:
for(Integer i: numeros){
System.out.println(i);
}
Si el array contiene objetos de tipos distintos o desconocemos el tipo:
for(Object o: nombreArray){
System.out.println(o);
}
Utilizando un objeto Iterator.
http://docs.oracle.com/javase/7/docs/api/java/util/Iterator.html
La ventaja de utilizar un Iterador es que no necesitamos indicar el tipo de objetos que
contiene el array.
Iterator tiene como mtodos:
hasNext: devuelve true si hay ms elementos en el array.
next: devuelve el siguiente objeto contenido en el array.
Ejemplo:
ArrayList<Integer> numeros = new ArrayList<Integer>();
..
//se insertan elementos
.....

X.

Iterator it = numeros.iterator(); //se crea el iterador it para el array numeros

while(it.hasNext())
//mientras queden elementos
System.out.println(it.next()); //se obtienen y se muestran

EJEMPLOS DE USO DE ARRAYLIST

Ejemplo 1:
ArrayList<String> nombres = new ArrayList<String>();
nombres.add("Ana");
nombres.add("Luisa");
nombres.add("Felipe");
System.out.println(nombres); // [Ana, Luisa, Felipe]
nombres.add(1, "Pablo");
System.out.println(nombres); // [Ana, Pablo, Luisa, Felipe]
nombres.remove(0);
System.out.println(nombres); // [Pablo, Luisa, Felipe]
nombres.set(0,"Alfonso");
System.out.println(nombres); // [Alfonso, Luisa, Felipe]
String s = nombres.get(1);
String ultimo = nombres.get(nombres.size() - 1);
System.out.println(s + " " + ultimo); // Luisa Felipe
Ejemplo 2: Escribe un programa que lea nmeros enteros y los guarde en un
ArrayList hasta que se lea un 0 y muestra los nmeros ledos, su suma y su media.
import java.util.*;
public class ArrayList2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
ArrayList<Integer> numeros = new ArrayList<Integer>();
int n;
do {
System.out.println("Introduce nmeros enteros. 0 para acabar: ");
System.out.println("Numero: ");
n = sc.nextInt();
if (n != 0)
numeros.add(n);
}while (n != 0);
System.out.println("Ha introducido: " + numeros.size() + " nmeros:");
//mostrar el arrayList completo
System.out.println(numeros);
//recorrido usando un iterador para mostrar un elemento por lnea
Iterator it = numeros.iterator();
while(it.hasNext())
System.out.println(it.next());
//recorrido usando foreach para sumar los elementos

double suma = 0;
for(Integer i: numeros){
suma = suma + i;
}
System.out.println("Suma: " + suma);
System.out.println("Media: " + suma/numeros.size());

COPIAR UN ARRAYLIST
El nombre de un ArrayList contiene la referencia al ArrayList, es decir, la direccin de
memoria donde se encuentra el ArrayList, igual que sucede con los arrays estticos.
Si disponemos de un ArrayList de enteros llamado ventas:

La instruccin:
ArrayList<Integer> ventas1 = ventas;
No copia el array ventas en el nuevo array ventas1 sino que crea un alias:

De esta forma tenemos dos formas de acceder al mismo ArrayList: mediante la

referencia ventas y mediante la referencia ventas1.
Para hacer una copia podemos hacerlo de forma manual elemento a elemento o se
puede pasar la referencia del ArrayList original al constructor del nuevo:
ArrayList<Integer> ventas1 = new ArrayList<Integer>(ventas);

ARRAYLIST COMO PARMETRO DE UN MTODO

Un ArrayList puede ser usado como parmetro de un mtodo. Adems un mtodo
puede devolver un ArrayList mediante la sentencia return.
Ejemplo: Mtodo que recibe un ArrayList de String y lo modifica invirtiendo su
contenido:
import java.util.*;
public class ArrayList4 {
public static void main(String[] args) {
ArrayList<String> nombres = new ArrayList<String>();
nombres.add("Ana");
nombres.add("Luisa");
nombres.add("Felipe");
nombres.add("Pablo");
System.out.println(nombres);
nombres = invertir(nombres);
System.out.println(nombres);
}
public static ArrayList<String> invertir(ArrayList<String> nombres) {
// Crea una lista para el resultado del mtodo
ArrayList<String> resultado = new ArrayList<String>();
// Recorre la lista de nombres en orden inverso
for (int i = nombres.size() - 1; i >= 0; i--) {
// Aade cada nombre al resultado
resultado.add(nombres.get(i));
}
return resultado;
}
}

ARRAYS BIDIMENSIONALES UTILIZANDO ARRAYLIST

Un ArrayList es un array unidimensional, pero con ellos podemos simular arrays de dos
o ms dimensiones anidando ArrayLists.
Para crear una matriz lo que creamos es un ArrayList cuyos elementos son a su vez
ArrayList. Esto se puede extender sucesivamente y obtener arrays de ms
dimensiones.
Ejemplo:
Programa que lee las notas de 10 alumnos y las guarda en un ArrayList Bidimensional.
Cada alumno tiene un nmero indeterminado de notas. La lectura de notas de cada

alumno acaba cuando se introduce un nmero negativo. Finalmente se muestran todas

las notas de todos los alumnos.
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
final int numAlumnos = 10; //nmero de alumnos
int i, j, nota, cont = 1;
//crear un ArrayList bidimensional de enteros vaco
//Realmente se crea un ArrayList de ArrayLists de enteros
ArrayList<ArrayList<Integer>> array = new ArrayList<ArrayList<Integer>>();
//Se leen las notas de cada alumno.
System.out.println("Introduzca notas. <0 para acabar");
for(i=0;i<numAlumnos;i++){
cont = 1;
System.out.println("Alumno " + (i+1) + ": ");
System.out.print("Nota " + cont + ": ");
nota = sc.nextInt();
//para cada alumno se aade una nueva fila vaca
//esto es necesario porque el arrayList se crea vaco
array.add(new ArrayList<Integer>());
while(nota>=0){
array.get(i).add(nota); //en la fila i se aade un nueva nota
cont++;
System.out.print("Nota " + cont + ": ");
nota = sc.nextInt();
}
}

//Mostrar todas las notas

System.out.println("Notas de alumnos");
for(i=0;i<array.size();i++){ //para cada alumno (para cada fila)
System.out.print("Alumno " + i + ": ");
for(j=0;j<array.get(i).size();j++){ //se recorre todas la columnas de la fila
System.out.print(array.get(i).get(j) + " "); //se obtiene el elemento i,j
}
System.out.println();
}

Arrays unidimensionales en Java

Concepto de Array o Arreglo:
Un array es una coleccin finita de datos del mismo tipo, que se almacenan en
posiciones consecutivas de memoria y reciben un nombre comn.
Por ejemplo, supongamos que queremos guardar las notas de los 20 alumnos de una
clase.
Para almacenar las notas utilizaremos un array de 20 elementos de tipo double y en
cada elemento del array guardaremos la nota de cada alumno
Podemos representar grficamente el array de notas de la siguiente forma:
Array notas:

1.
-

8.50

6.35

5.75

8.50

notas[0]

notas[1]

notas[2]

notas[3]

3.75

6.00

notas[17] notas[18]

7.40
notas[19]

Para acceder a cada elemento del array se utiliza el nombre del array y un ndice que
indica la posicin que ocupa el elemento dentro del array.
El ndice se escribe entre corchetes.
El primer elemento del array ocupa la posicin 0, el segundo la posicin 1, etc. En
un array de N elementos el ltimo ocupar la posicin N-1.
En el ejemplo anterior, notas[0] contiene la nota del primer alumno y notas[19]
contiene la del ltimo
Los ndices deben ser enteros no negativos.

CREAR ARRAYS UNIDIMENSIONALES

Para crear un array se deben realizar dos operaciones:

Declaracin
Instanciacin
Declarar de un array
En la declaracin se crea la referencia al array.
La referencia ser el nombre con el que manejaremos el array en el programa.
Se debe indicar el nombre del array y el tipo de datos que contendr.
De forma general un array unidimensional se puede declarar en java de cualquiera de
estas dos formas:
tipo [] nombreArray;
tipo nombreArray[];
tipo: indica el tipo de datos que contendr. Un array puede contener elementos de tipo
bsico o referencias a objetos.
nombreArray: es la referencia al array. Es el nombre que se usar en el programa para
manejarlo.
Por ejemplo:
int [] ventas; //array de datos de tipo int llamado ventas
double [] temperaturas; //array de datos de tipo double llamado temperaturas
String [] nombres; //array de datos de tipo String llamado nombres
Instanciar un array
Mediante la instanciacin se reserva un bloque de memoria para almacenar todos los
elementos del array.
La direccin donde comienza el bloque de memoria donde se almacenar el array se
asigna al nombre del array.
De forma general:

nombreArray = new tipo[tamao];

nombreArray: es el nombre creado en la declaracin.
tipo: indica el tipo de datos que contiene.
tamao: es el nmero de elementos del array. Debe ser una expresin entera positiva.
El tamao del array no se puede modificar durante la ejecucin del programa.
new: operador para crear objetos. Mediante new se asigna la memoria necesaria para
ubicar el objeto. Java implementa los arrays como objetos.
Por ejemplo:
ventas = new int[5]; //se reserva memoria para 5 enteros y
//se asigna la direccin de inicio del array a ventas.
Lo normal es que la declaracin y la instanciacin se hagan en una sola instruccin:
tipo [] nombreArray = new tipo[tamao];
Por ejemplo: int [] ventas = new int[5];
El tamao del array tambin se puede indicar durante la ejecucin del programa, es
decir, en tiempo de ejecucin se puede pedir por teclado el tamao del array y crearlo:
Scanner sc = new Scanner(System.in);
System.out.print("Nmero de elementos del array: ");
int numeroElementos = sc.nextInt();
int [] ventas = new int[numeroElementos];
Si no hay memoria suficiente para crear el array, new lanza una excepcin
java.lang.OutOfMemoryError.
Diferencia entre la referencia y el contenido del array
Debe quedar clara la diferencia entre la referencia (manejador del array o nombre del
array) y el contenido del array.
El nombre del array contiene la direccin de memoria del contenido del array.

2.

INICIALIZAR ARRAYS UNIDIMENSIONALES

Un array es un objeto, por lo tanto, cuando se crea, a sus elementos se les asigna
automticamente un valor inicial:
Valores iniciales por defecto para un array en java:
0 para arrays numricos
'\u0000' (carcter nulo) para arrays de caracteres
false para arrays booleanos
null para arrays de String y de referencias a objetos.
Tambin podemos dar otros valores iniciales al array cuando se crea.

Los valores iniciales se escriben entre llaves separados por comas.

Los valores iniciales deben aparecer en el orden en que sern asignados a los
elementos del array.
El nmero de valores determina el tamao del array.
Por ejemplo:
double [] notas = {6.7, 7.5, 5.3, 8.75, 3.6, 6.5};
se declara el array notas de tipo double, se reserva memoria para 6 elementos y se les
asignan esos valores iniciales.
Ejemplos:
//creacin de un array de 4 elementos booleanos
boolean [] resultados = {true,false,true,false};
//creacin de un array de 7 elementos de tipo String
String [] dias = {"Lunes", "Martes", "Mircoles", "Jueves", "Viernes", "Sbado", "Domingo"};

3.

ACCEDER A LOS ELEMENTOS DE UN ARRAY

Para acceder a cada elemento del array se utiliza el nombre del array y un ndice que
indica la posicin que ocupa el elemento dentro del array.
El ndice se escribe entre corchetes.
Se puede utilizar como ndice un valor entero, una variable de tipo entero o una
expresin de tipo entero.
El primer elemento del array ocupa la posicin 0, el segundo la posicin 1, etc. En
un array de N elementos el ltimo ocupar la posicin N-1.
Un elemento de un array se puede utilizar igual que cualquier otra variable. Se puede
hacer con ellos las mismas operaciones que se pueden hacer con el resto de variables
(incremento, decremento, operaciones aritmticas, comparaciones, etc).
Por ejemplo:

Si se intenta acceder a un elemento que est fuera de los lmites del array (un
elemento con ndice negativo o con un ndice mayor que el que corresponde al ltimo
elemento del array) el compilador no avisa del error. El error se producir durante la
ejecucin.
En
ese
caso
se
lanza
una
excepcin
java.lang.ArrayIndexOutOfBoundsException.
Se puede saber el nmero de elementos del array mediante el atributo length.
Podemos utilizar length para comprobar el rango del array y evitar errores de acceso.
Por ejemplo, para asignar un valor a un elemento del array que se lee por teclado:
Scanner sc = new Scanner(System.in);
int i, valor;
int [] a = new int[10];
System.out.print("Posicin: ");
i = sc.nextInt();
System.out.print("Valor: ");
valor = sc.nextInt();
if (i>=0 && i < a.length) {
a[i] = valor;
}

4.

RECORRER UN ARRAY UNIDIMENSIONAL

Para recorrer un array se utiliza una instruccin iterativa (normalmente una instruccin
for, aunque tambin puede hacerse con while o do..while) utilizando una variable
entera como ndice que tomar valores desde el primer elemento al ltimo o desde el
ltimo al primero.
Por ejemplo, el siguiente fragmento de programa Java declara un array de 7 elementos
de tipo double y le asigna valores iniciales. A continuacin recorre el array, utilizando la
instruccin for, para mostrar por pantalla el contenido del array.
double[] notas = {2.3, 8.5, 3.2, 9.5, 4, 5.5, 7.0}; //array de 7 elementos
for (int i = 0; i < 7; i++) {
System.out.print(notas[i] + " "); //se muestra cada elemento del array
}
Para evitar errores de acceso al array es recomendable utilizar length para recorrer el
array completo.
Por ejemplo:
double[] notas = {2.3, 8.5, 3.2, 9.5, 4, 5.5, 7.0}; //array de 7 elementos
for (int i = 0; i < notas.length; i++) {
System.out.print(notas[i] + " "); //se muestra cada elemento del array
}
Ejemplo de recorrido de un array en java:
Programa que lee por teclado la nota de los alumnos de una clase y calcula la nota
media del grupo. Tambin muestra los alumnos con notas superiores a la media. El
nmero de alumnos se lee por teclado.
Este programa crea un array de elementos de tipo double que contendr las notas de
los alumnos. El tamao del array ser el nmero de alumnos de la clase.
Se realizan 3 recorridos sobre el array, el primero para asignar a cada elemento las
notas introducidas por teclado, el segundo para sumarlas y el tercero para mostrar los
alumnos con notas superiores a la media.
import java.util.*;
public class Recorrido2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);

int numAlum, i;
double suma = 0, media;
do {
System.out.print("Nmero de alumnos de la clase: ");
numAlum = sc.nextInt();
} while (numAlum <= 0);
double[] notas = new double[numAlum]; //se crea el array
// Entrada de datos. Se asigna a cada elemento del array
// la nota introducida por teclado
for (i = 0; i < notas.length; i++) {
System.out.print("Alumno " + (i + 1) + " Nota final: ");
notas[i] = sc.nextDouble();
}
// Sumar todas las notas
for (i = 0; i < notas.length; i++) {
suma = suma + notas[i];
}
// Calcular la media
media = suma / notas.length;
// Mostrar la media
System.out.printf("Nota media del curso: %.2f %n", media);
// Mostrar los valores superiores a la media
System.out.println("Listado de notas superiores a la media: ");
for (i = 0; i < notas.length; i++) {
if (notas[i] > media) {
System.out.println("Alumno numero " + (i + 1)+ " Nota final: " + notas[i]);
}
}

}
}
Recorrer un Array en java con foreach. Bucle for para colecciones
A partir de java 5 se incorpora una instruccin for mejorada para recorrer arrays y
contenedores en general.
Permite acceder secuencialmente a cada elemento del array.
La sintaxis general es:
for(tipo nombreDeVariable : nombreArray){
.
}
tipo: indica el tipo de datos que contiene el array.
nombreDeVariable: variable a la que en cada iteracin se le asigna el valor de cada
elemento del array. Esta definida dentro del for por lo que solo es accesible dentro de
l.
nombreArray: es el nombre del array que vamos a recorrer.
Mediante este bucle solo podemos acceder a los elementos del array. No podemos
hacer modificaciones en su contenido.
Ejemplo: El siguiente programa crea un array temperatura de 10 elementos. Lee por
teclado los valores y a continuacin los muestra por pantalla.
import java.util.*;
public class Recorrerforeach1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
double [] temperatura = new double[10];
int i;

for(i = 0; i<temperatura.length;i++){
System.out.print("Elemento " + i + ": ");
temperatura[i] = sc.nextDouble();
}
for(double t: temperatura){
System.out.print(t + " ");
}
System.out.println();
}

Java Ejercicios Bsicos de Arrays Resueltos 1

Relacin
1.

Calcular

N
la

media

1:
de

una

Ejercicios
serie

de

nmeros

1
que

se

y
leen

por

2
teclado.

Programa Java que lea por teclado 10 nmeros enteros y los guarde en un array. A
continuacin calcula y muestra por separado la media de los valores positivos y la de
los valores negativos.

/*
* Programa que lea por teclado 10 nmeros enteros y los guarde en un array.
* A continuacin calcula y muestra la media de los valores positivos y la de los
valores negativos.
*/
import java.util.*;
public class Media1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int i;
int pos = 0, neg = 0; //contadores de los nmeros positivos y negativos
int[] numeros = new int[10]; //array que contendr los nmeros ledos por
teclado
double sumaPos = 0, sumaNeg = 0; //acumuladores para las sumas de positivos
y negativos
//lectura de datos y llenar el array
System.out.println("Lectura de los elementos del array: ");
for (i = 0; i < 10; i++) {
System.out.print("numeros[" + i + "]= ");
numeros[i]=sc.nextInt();
}
//recorrer el array para sumar por separado los nmeros positivos
// y los negativos
for (i = 0; i < 10; i++) {
if (numeros[i] > 0){ //sumar positivos
sumaPos += numeros[i];
pos++;
} else if (numeros[i] < 0){ //sumar negativos
sumaNeg += numeros[i];
neg++;
}
}

//Calcular y mostrar las medias

if (pos != 0) {
System.out.println("Media de los valores positivos: " + sumaPos / pos);
} else {
System.out.println("No ha introducido numeros positivos");
}
if (neg != 0) {
System.out.println("Media de los valores negativos: " + sumaNeg / neg);
} else {
System.out.println("No ha introducido numeros negativos");
}
}
}

2. Programa Java que lea 10 nmeros enteros por teclado y los guarde en un array.
Calcula y muestra la media de los nmeros que estn en las posiciones pares del array.
Considera la primera posicin del array (posicin 0) como par.

/*
*
*
*
*/

Leer
en
que

10
un

array.
estn

nmeros
Calcular
en

enteros
la
las

y
media
posiciones

import

guardarlos
de
los
pares.
java.util.*;

public

class

Arrays1_2

public static void main(String[] args) {

Scanner
int[]
double media = 0;

sc

=
int

new

numeros

//lectura
de
datos
System.out.println("Lectura
de
for
(i
=
0;
System.out.print("numeros["
numeros[i]
}

y
los
i

Scanner(System.in);
i;
new
int[10];

llenar
el
array
elementos
del
array:
");
<
10;
i++)
{
+
i
+
"]=
");
=
sc.nextInt();

//Recorrer
el
array
y
calcular
la
media
for
(i
=
0;
i
<
10;
i++)
{
if
(i
%
2
==
0){ //si
la
posicin
actual
es
par
media = media + numeros[i]; //se suma el valor de esa posicin
}
}

"+

//Calcular
y
mostrar
la
media
System.out.println("Media de los valores que se encuentran en posiciones pares:
media/5);
}

}
Siguiente relacin de ejercicios bsicos de arrays

59 comentarios:
1.
Annimo17 de noviembre de 2012, 16:35
muy buenos tus programas.... gracias :)
Responder
Respuestas

1.
Annimo25 de abril de 2015, 7:00
En el ejercicio N 1 se presenta un error en el calcula de la media ya que "int pos
= 0, neg = 0; //contadores de los nmeros positivos y negativos" la variable
estan inicializadas a cero(0)y al pasar por el for solo se incrementan hasta (9)
dando un error en la media ( sumaPos / pos), o sea para 10 elementos no divide
por (10) sino que divide por ( 9).