3

   

Estructuras de almacenamiento
 
 
Estructuras de almacenamiento 3-1

TABLA DE CONTENIDOS 
 
Declaración de Arrays ...................................................................................................... 2 
Inicialización de Arrays ................................................................................ 2 
Arrays Multidimensionales ........................................................................... 3 
3-2 Estructuras de almacenamiento

Declaración de Arrays 
Los  arrays  permiten  agrupar  varios  datos  u  objetos  del  mismo  tipo  o  clase  bajo  un  mismo 
nombre.  Por  tanto  hablaremos  de  arrays  de  enteros,  array  de  boolean,  array  de  double, 
array de String , etc… 
En  Java,  un  array  es  un  objeto  incluso  cuando  es  un  array  de  tipos  primitivos.  Al  ser  un 
objeto,  su  declaración  implica  solo  una  reserva  de  memoria  para  la  referencia.  Nunca  se 
especifica  el  tamaño  del  array  en  su  declaración.  Existen  dos  formas  distintas  de  declarar 
arrays: 
 
int i[]; // Estilo C/C++
int[] i; // Estilo alternativo

 
Con el estilo alternativo, Java permite mantener agrupado el tipo y nombre de la variable. 
Hay una diferencia entre estas dos definiciones:  
 en el primer caso los corchetes afectan sólo a la variable.   
 En el segundo al tipo.   
 Por ejemplo, si tenemos “int a[], b;” a es un array de enteros y b es una variable 
int.   
 Sin embargo, si tenemos “int[] a, b;” a y b son array de enteros. 
 
Inicialización de Arrays 
Para crear arrays se utiliza la palabra reservada ‘new’, (como en la creación de cualquier otro 
objeto).  En  este  momento  se  especifica  el  tamaño  del  array  y  se  realiza  la  reserva  de 
memoria. 
 
int[] i = new int[10];
Empleado2[] e = new Empleado2[10];
String [] nombres = new String[10];

 
El  primer  array  permite  almacenar  10  enteros.  Cada  una  de  las  posiciones  del  array  se 
inicializa a los valores por defecto, es decir, 0. En los otros casos, el array de Empleado2 y de 
String,  se  trata  de  objetos.  Se  realiza  una  reserva  de  memoria  para  mantener  diez 
referencias, pero no se crean los objetos. Cada uno de estos objetos tendrán que crearse de 
forma manual y hasta entonces, las referencias tendrán un valor nulo. 
Todos  los  arrays  se  indexan  desde  0  hasta  longitud  ‐1.  Cualquier  acceso  fuera  de  rango 
generará una excepción. 
Java permite una manera de inicializar arrays en el momento de su declaración: 
 
Estructuras de almacenamiento 3-3

int[] i = {1,2,3,4,5,6,7,8,9,10};
String[] s = {“Fernando”,”Carmen”,”Luis”,”Elena”};

Vemos un ejemplo para la carga en un array de 5 elementos de los números comprendidos 
entre el 0 y el 5. Y sacamos por pantalla el cuadrado de cada número almacenado. 
public class Unidimensional {

public static void main(String[] args) {

int [] tabla1;
tabla1 = new int[5];
for (int i=0;i<5;i++)
tabla1[i] = i*i;
for (int i = 0;i<5;i++)
System.out.println("el cuadrado de " + i +
“es: " + tabla1[i]);
}
}
el cuadrado de 0 es: 0
el cuadrado de 1 es: 1
el cuadrado de 2 es: 4
el cuadrado de 3 es: 9
el cuadrado de 4 es: 16

Fíjate en la los parámetros del método main. Ahora entiendes que es String[] args. 
Arrays Multidimensionales 
Java  permite  la  creación  de  arrays  de  arrays(y  arrays  de  arrays  de  arrays,  etc..).  Véase  el 
siguiente fragmento de código: 
 
int[][] dos = new int [2][2];
dos[0][0] = 1;
dos[0][1] = 2;
dos[1][0] = 3;
dos[1][1] = 4;

 
También existe la posibilidad de crear arrays multidimensionales irregulares: 
 
 
package cap4;

public class Arrays{

public static void main(String [] args){

int[][] v = new int[3][]; //el primer índice tiene 3 elementos

v[0] = new int[3]; //el elemento 1 tiene tres subelementos
v[0][0] = 11;
v[0][1] = 12;
v[0][2] = 13;

v[1] = new int[4]; // el segundo elemento tiene 4 subelementos

v[1][0] = 21;
v[1][1] = 22;
3-4 Estructuras de almacenamiento

v[1][2] = 23;
v[1][3] = 24;
v[2] = new int[5]; // el tercer elemento tiene 5 subelementos
v[2][0] = 31;
v[2][1] = 32;
v[2][2] = 33;
v[2][3] = 34;
v[2][4] = 35;

/* tambien válido asi

int v[][] = { {11,12,13}, {21,22,23,24}, {31,32,33,34,35}};
*/
// Lectura de una array bidimensional con "dos for" anidados
for(int i=0;i<v.length;i++){
for(int j=0;j<v[i].length;j++){
System.out.print(v[i][j] + " ");
}
System.out.println();
}
}
}
Resulatados
11 12 13
21 22 23 24
31 32 33 34 35

 
En el ejemplo se usa la propiedad length de los arrays, que permite conocer la longitud de un 
array. 
En el siguiente ejemplo se imprimen en pantalla los argumentos recibidos como parámetro 
en el método main: 
 
package cap4;

public class ArgumentosMain{

public static void main(String[] args){
if(args!=null && args.length>=2){
System.out.println("Los argumentos son: "+args[0]+" y "+args[1]);
}else{
System.out.println("No hay suficientes parámetros");
System.out.println("Ej: java cap4.ArgumentosMain Pepe 5");
}
}
}