Capítulo 8

ARRAYS

1. ARRAYS
Un array es un objeto en el que se puede almacenar un conjunto de datos
de un mismo tipo. Cada uno de los elementos del array tiene asignado un índice
numérico según su posición, siendo 0 el índice del primero.

Declaración
Un array debe declararse utilizando la expresión:

tipo [] variable_array;
o
tipo variable_array[];

Como se puede apreciar, los corchetes pueden estar situados delante de la

variable o detrás. Los siguientes son ejemplos de declaraciones de array:

int[]k;
String[]p;
char cads[];

Los arrays pueden declararse en los mismos lugares que las variables
estándar: como atributos de una clase o locales en el interior de un método. Como
ocurre con cualquier otro tipo de variable objeto, cuando un array se declara como
atributo se inicializa implícitamente al valor null.

Dimensionado de un array
Para asignar un tamaño al array se utiliza la expresión:

variable_array = new tipo [tamaño];

También se puede asignar tamaño al array en la misma línea de declaración

de la variable. Los siguientes son ejemplos de dimensionado de un array:

k=new int [5];

cads=new char[l0];
String [] noms=new String[10];

Cuando un array se dimensiona, todos sus elementos son inicializados

explícitamente al valor por defecto del tipo correspondiente, independientemente
de que la variable que contiene al array sea atributo o local.

Existe una forma de declarar, dimensionar e inicializar un array en una

Pág. 1
misma sentencia. La siguiente instrucción crea un array de cuatro enteros y los
inicializa a los valores indicados entre llaves:

int[] nums = {10, 20, 30, 40};

Acceso a los elementos de un array

El acceso a los elementos de un array se realiza utilizando la expresión:

variable _array [índice]

Donde índice representa la posición a la que se quiere tener acceso, y cuyo

valor debe estar comprendido entre 0 y tamaño-1.

Todos los objetos array exponen un atributo público, llamado length, que
permite conocer el tamaño al que ha sido dimensionado un array. Este atributo
resulta especialmente útil en aquellos métodos que necesitan recorrer todos los
elementos de un array, independientemente de su tamaño.

El siguiente bloque de código utiliza length para recorrer un array y

rellenarlo con números enteros pares consecutivos, empezando por el 0.

int [] nums=new int [10] ;

for (int i=0 ; i<nums.length; i++)
{
nums [i] =i*2 ;
}

El programa que se muestra a continuación calcula la suma de todos los

números almacenados en un array de enteros, mostrando además el mayor y el
menor de los números contenidos:

public class Principal

{
public static void main (String [] args)
{
int mayor, menor , suma;
int [] nums = {3,4,8,2};

suma = 0 ;
menor = nums [0];
mayor = nums [0];

//en las variables mayor y menor

//se obtendrá el mayor y el menor de los
//números buscados, respectivamente. Ambas se
//inicializan con cualquiera de los valores
//del array
//recorre el array en busca de los
extremos, //acumulando en suma cada uno de los
números
//contenidos en el array

for (int i=0 ; i<nums.length; i++)

{
if (nums[i] >mayor)
{

Pág. 2
 mayor =nums [i];
}
if (nums[i] <menor)
{
menor =nums[i];
}
suma+=nums[i];
}
System.out.println ("El mayor es "+ mayor);
System.out.println ("El menor es "+ menor);
System.out.println ("La suma es "+ suma);
}
}

Paso de un array como argumento de llamada a un método

Además de los tipos básicos los arrays también pueden utilizarse como
argumentos de llamada a métodos.

Para declarar un método que reciba como parámetro un array se emplea la

sintaxis:
tipo método (tipo variable_array[])
{
//código del método
}

El siguiente método recibe como parámetro un array de enteros:

void metodoEjemplo (int m[])
{
. . . .
}
En cuanto a la llamada, se utilizará la expresión:
objeto.método (variable_array);

A modo de ejemplo ilustrativo, la siguiente clase representa una versión del

programa anterior en el que se calculaban la suma, el mayor y el menor de los
números almacenados en un array de números. En este caso, se desglosa el código
de las operaciones sobre el array en tres métodos a los que se les pasa como
parámetro el array de enteros:
public class Principal{
public static void main (String [] args) {
int mayor, menor, suma;
int [ ] nums = {3,4,8,2};
//Llamada a los métodos
suma= sumar (nums);
menor=calculoMenor (nums);
mayor=calculoMayor (nums);
System.out.println ("El mayor es "+ mayor);
System.out.print In ("El menor es "+ menor);
System.out.println ("La suma es "+ suma);
}
static int sumar (int números []){
int s=0;
for(int i=0 ; i<numeros.length; i++) {

Pág. 3
 s+=numeros[i];
}
return s;
}
static int calculoMayor (int números []){
int may=numeros[0];
for(int i=0; i<numeros.length;i++){
if (nums[i] >may) {
may=nums [i];
}
}
return may;
}
static int calculoMenor (int números []){
int men=numeros [0] ;
for (int i=0 ; i<numeros.length; i++) {
if (nums [i] <men) {
men=nums [i];
}
}
return men;
}

Array como tipo de devolución de un método

También un array puede ser devuelto por un método tras la ejecución del
mismo. El formato de un método de esas características será el siguiente:

tipo [] método (parámetros) {

.....
return variable _array;
}

El siguiente método devuelve un array con los cinco números enteros

siguientes al número recibido como parámetro:

int [] getNumeros (int n) {

int [] nums=new int [5];
for (int i=0 ; i<nums.length;i++){
nums[i] =n+i+l;
}
return nums;
}

Recorrido de arrays con for-each

A partir de la versión Java 5, el lenguaje Java incorpora una variante de la
instrucción for, conocida como for-each, que facilita el recorrido de arrays y
colecciones para la recuperación de su contenido, eliminando la necesidad de
utilizar una variable de control que sirva de índice para acceder a las distintas
posiciones. Aunque se utiliza un nuevo nombre para identificar esta instrucción
(for-each), la palabra reservada para su implementación sigue siendo for.

Pág. 4
 En el caso de un array, el formato de la nueva instrucción for-each sería:

for(tipo variable:var_array){
//instrucciones
}

donde, tipo variable representa la declaración de una variable auxiliar del mismo
tipo que el array, variable que irá tomando cada uno de los valores almacenados en
éste con cada iteración del for, siendo var_array la variable que apunta al array.

Por ejemplo, supongamos que tenemos el siguiente array:

int [] nums = {4, 6, 30, 15};

Y queremos mostrar en pantalla cada uno de los números almacenados en

el mismo. Utilizando la versión tradicional de for, la forma de hacerlo sería:
for (int i=0; i<nums.length; i++){
System.out.println (nums [i]);
}

Utilizando la nueva instrucción for-each, la misma operación se realizará

de la siguiente forma:
for(int n:nums) {
System.out.println(n);
}

Obsérvese cómo, sin acceder de forma explícita a las posiciones del array,
cada una de éstas es copiada automáticamente a la variable auxiliar n al
principio de cada iteración.

Como ejemplo ilustrativo, a continuación se presenta una nueva versión del

programa anterior que realiza la suma de los elementos de un array. En este caso se
han utilizado bucles for-each sin índices en vez de for tradicionales:

public class Principal {

public static void main (String [] args) {
int mayor, menor, suma;
int [ ] nums = {3,4,8,2};
//Llamada a los métodos
suma=sumar (nums);
menor=calculoMenor(nums);
mayor=calculoMayor(nums);
System.out.println("El mayor es "+ mayor);
System.out.println("El menor es "+ menor);
System.out.println("La suma es "+ suma);
}
static int sumar (int números []){
int s = 0;
for(int n: números ){
s+=n;
}
return s ;
}
static int calculoMayor (int números []){
Pág. 5
 int may=numeros [0];
for(int n:numeros){
if (n>may) {
may=n;
}
}

return may;
}
static int calculoMenor (int números []){
int men=numeros [0];
for(int n: números ){
if (n<men) {
men=n;
}
}
return men;
}
}

Recordemos que el código anterior solamente funcionará con la

versión 5 de Java SE o posteriores.

2. ARRAYS MULTIDIMENSIONALES
Los arrays Java pueden tener más de una dimensión, por ejemplo, un array
de enteros de dos dimensiones se declararía:
int [] [] k;

A la hora de asignarle tamaño se procedería como en los de una dimensión,

indicando en los corchetes el tamaño de cada dimensión:
k= new int[3][5];

Igualmente, para acceder a cada una de las posiciones del array se utilizaría
un índice por dimensión:
k[l] [3] =28;

Si imaginamos un array de dos dimensiones como una tabla organizada en

filas y columnas, el array anterior tendría el aspecto indicado siguiente.

k
0 1 2 3 4
0
1 28
2

Array bidimensional

Recorrido de un array multidimensional

Para recorrer un array multidimensional podemos utilizar la instrucción for
tradicional, empleando para ello tantas variables de control como dimensiones
tenga el array. La siguiente instrucción almacenaría en cada una de las posiciones
del array k, definido anteriormente, la suma de sus índices:
Pág. 6
 for (int i=0;i<k.length;i++) //recorre primera dimensión
for (int j=0; j<k.[i].length ; j++) //recorre segunda
dimensión
k[i][j]=i+j;

Igualmente, se puede utilizar también una instrucción for-each para

recuperar el contenido de un array multidimensional, simplificando enormemente
dicha tarea. El siguiente ejemplo mostraría en pantalla los valores almacenados en
el array k anterior:
for (int [] n:k) //recorre primera dimensión
for (int p:n) //recorre segunda dimensión
System.out.println(“valor: “+p);

Arrays multidimensionales irregulares

Es posible definir un array multidimensional en el que el número de
elementos de la segunda y sucesivas dimensiones sea variable, indicando
inicialmente sólo el tamaño de la primera dimensión:

int [] [] irreg = new int [2] [];

Un array de estas características equivale a un array de arrays, donde cada

elemento de la primera dimensión almacenará su propio array:

irreg[0]= new int[4];

irreg[1]= new int[6];

La figura siguiente ilustra gráficamente la situación.

Irreg

Array bidimensional con dimensiones de diferente tamaño

Un array de estas características sería complicado de recorrer empleando

un bucle for normal, en cambio, mediante for-each su recorrido sería exactamente
igual que con los arrays multidimensionales estándar. El siguiente ejemplo
recorrería el array anterior:
for(int[] n:irreg) //recorre primera dimensión
for(int p:n) //recorre segunda dimensión
System.out.println{"valor: "+p);

3. MÉTODOS CON NUMERO VARIABLE DE ARGUMENTOS

Cuando hemos explicado el funcionamiento del paso de parámetros al
invocar a un método, se dijo que el número de argumentos utilizados en la llamada
viene determinado por el número de parámetros que el método acepta. Esto
significa que si, por ejemplo, un método tiene declarados dos parámetros, la
llamada al método deberá efectuarse con dos argumentos.

Pág. 7
 A partir de la versión Java 5 es posible definir métodos que reciban un
número variable de argumentos, para ello es necesario declarar un parámetro que
recoja todos los argumentos de número variable. La declaración de un parámetro
de estas características debe hacerse utilizando el siguiente formato:

tipo ... nombre_parámetro

Por ejemplo, un parámetro declarado de la siguiente forma en un método:

String ... cadenas

representaría cualquier número de argumentos de tipo String.

Un parámetro declarado de esta manera es realmente un array en el que se

almacenan los argumentos recibidos y cuyos valores deben ser todos del mismo
tipo.

El siguiente método corresponde a un método que calcula la suma de todos

los números recibidos en el parámetro:
//puede ser invocado con cualquier número de
//argumentos de tipo entero
public int sumador (int ... varios){
int s=0;
for(int i:varios){
s+=i;
}
return s;

El siguiente programa utiliza el método sumado() para realizar diversos

cálculos de sumas enteras:

public class Cálculos {

public static void main (String []args){
System.out.println ( sumador (3,7,9,11)); //30
System.out.println (sumador (25,4,6)); //30
System.out.println (sumador (8,19));//27
}
public static int sumador (int ... varios){
int s=0;
for (int i:varios){
s+=i;
}
return s;
}
}

Un método puede declarar tanto parámetros estándares como parámetros

para número variable de argumentos. En estos casos, los segundos deben aparecer
declarados al final de la lista de parámetros:
public void método1(int k, String s, int ... nums){} //correcto
public void metodo2(int p, String ... cads, long f){} //incorrecto

Pág. 8
 La definición de métodos con un número variable de argumentos resulta
muy útil para todas aquellas situaciones en donde la cantidad de datos que deba
recibir el método en la llamada no esté determinada.

Pág. 9