Declarción, construcción e inicialización de

 
Arreglos.
SEMANA 2
 

 
 
 

 
 

 
   

 
 
 

 
 
 
 

 
 
 

 
 
 
 

 
 
  

   

Como parte del primer objetivo de evaluación del examen, el tema de declaración e
inicialización de arreglos es de gran importancia. Podría pensarse que todo está dicho
acerca de este tema, pero de nuevo es importante recalcar que el examen evalúa, en
profundidad, cada una de las características del lenguaje, esto se hace evidente en
preguntas que involucran detalles que normalmente pasarían desapercibidos en un
desarrollo de una aplicación común. Así es que no sobra dedicarle el tiempo suficiente
a estudiar la siguiente lectura, experimentando con la información aquí contenida, y de
esta forma tener las herramientas suficientes para analizar y resolver correctamente los
problemas planteados en las preguntas del examen. Ponga a prueba la información que
adquiere aquí en un programa real, pruebe todas las posibilidades y pregúntese, ¿será
que esto se puede hacer?, escriba un programa y compruébelo usted mismo.

Como se sabe, los arreglos son objetos en java que pueden usarse para administrar
múltiples variables de un mismo tipo. Los arreglos en sí mismos son representados en
Java como objetos, independientemente de si las variables que contienen son de un
tipo primitivo o referenciado. Por tanto, se ha de tener especial cuidado en aspectos
relativos al uso de estos objetos, tales como:

• Cómo crear variables que referencien arreglos (Declarar).

• Cómo crear o instanciar un arreglo (Construir).
• Cómo llenar un arreglo (inicializar).

Para cada punto, hay un conjunto de reglas que permite definir la manera correcta de
hacer las cosas, pero no definen estas, una sola forma de llevarlas a cabo. Existen
diferentes formas de realizar cada uno de estos aspectos, conocerlas e inferirlas a partir
de las reglas enunciadas es fundamental para obtener la certificación.

Declarando arreglos

Para declarar un arreglo se necesita, primero, indicar el tipo de los elementos que lo
conformarán, este puede ser cualquiera de los tipos primitivos, o referencia a objetos de
una clase. Para indicar que se desea trabajar con un arreglo y no con una variable
sencilla, se usan un par de corchetes ([ ]), los cuales pueden ser ubicados antes o
después del identificador del arreglo.

 
2  [ POLITÉCNICO GANCOLOMBIANO]
 

double []arreglo; 

double arreglo []; 
 

Estas dos declaraciones de un arreglo de reales tienen el mismo efecto, ambas son
válidas aunque se recomienda siempre escribir los corchetes antes del identificador
para favorecer la legibilidad del código. Puede o no utilizar uno o más espacios para
separar el tipo, nombre y los corchetes, por ejemplo, las siguientes declaraciones son
legales y equivalentes:

String[]arreglo; 

String[] arreglo; 
String []arreglo; 
String [] arreglo;
 

String arreglo[];
String arreglo [];

Ubicar antes o después del identificador no repercute funcionalmente en la declaración

de un solo arreglo, como en los ejemplos citados, pero sí tiene implicaciones en
declaraciones de múltiples arreglos en una sola sentencia, como veremos
posteriormente.

En cuanto a arreglos multidimensionales, las posibles combinaciones de los elementos

al declarar un arreglo pueden llegar a parecer algo extrañas, pero legales. Por ejemplo,
¿son legales todas las siguientes declaraciones?:

int [][] []multi; 
int[]multi[];

 
3
  

Son legales, la primera declara un arreglo de tres dimensiones, un arreglo en donde

cada posición es un arreglo en donde, a su vez, cada posición contiene un arreglo
también. Recuerde que en Java se pueden declarar arreglos de n dimensiones. La
segunda también es legal, aunque no muy correcta debido a su poca legibilidad; se
trata de un arreglo bidimensional o matriz, un arreglo de arreglos. En estos casos es
interesante experimentar con la flexibilidad que ofrecen las reglas de declaración de
arreglos y comprobar hasta qué punto son legales las declaraciones, o qué tan extrañas
pueden llegar a ser sin perder la legalidad de la sentencia. Siempre tenga en cuenta
que una sentencia puede ser legal aun cuando parezca no tener sentido, tenga cuidado
en preguntas de este tipo, pues usted podría identificar un problema de compilación en
una pregunta, cuando solo se trata de una sentencia escrita de una forma un poco
retorcida pero legal.
A diferencia de algunos lenguajes de programación, en Java no es legal nunca incluir el
tamaño del arreglo en su declaración. Recuerde que en Java los arreglos son objetos y,
por tanto, no se les puede asignar un tamaño hasta que sean instanciados, es decir,
hasta el momento de su construcción. La siguiente sentencia constituye un error de
compilación en Java, aunque parezca legal para personas familiarizadas con otros
lenguajes de programación:

long arr[15];

Construyendo arreglos
 
Una vez declarada la referencia a un arreglo, se debe instanciar esta referencia, es
decir, crear el objeto en el heap, (el lugar de la memoria en donde todos los objetos son
almacenados). Existen diferencias a la hora de construir estos objetos, lo que a veces
nos hace olvidar que en realidad estamos trabajando con un objeto y no con primitivos.
Está implicada en este proceso de creación la palabra reservada new, como en las
construcciones de los objetos normales, aunque tratándose de arreglos estas
sentencias lucen un tanto diferentes. La única información necesaria para construir un
arreglo, es su tamaño, con esto Java sabrá exactamente cuánto espacio debe reservar
en memoria, sin esta información, no se podrá construir el arreglo.

Construyendo un arreglo simple   
 

 
4  [ POLITÉCNICO GANCOLOMBIANO]
 

La forma más común (aunque no la única), de construir un arreglo, es usando la

palabra reservada new, seguida del tipo de datos del arreglo, finalizando con un par de
corchetes en cuyo interior se especificará el tamaño del arreglo.

int[] arr; 
arr = new int[25]; 
 

Para construir un arreglo, se parte de su declaración, como se puede observar en el

ejemplo, una vez declarado, se procede a su construcción, en donde se instanciará el
objeto y se reservará el espacio suficiente en memoria para alojarlo. Para el caso del
ejemplo, se construirá un arreglo de enteros con capacidad para almacenar 25 valores.
Al tratarse de un arreglo que contiene datos de tipo primitivo, una vez construido cada
posición del arreglo debe contener un valor valido según su tipo. En este caso se creó
un arreglo de 25 enteros, luego cada una de las 25 posiciones debe contener un valor
entero, no existe la definición de un valor nulo en el conjunto de los enteros, por este
motivo el arreglo es inicializado automáticamente con ceros. Podríamos decir que la
expresión del ejemplo le está solicitando al compilador que cree un objeto de arreglo
que tenga la capacidad de almacenar 25 datos de tipo entero, que llene de ceros el
arreglo, y que asigne la referencia de este arreglo a la variable arr, para poder acceder
a él.
Es legal también declarar y construir un arreglo en una sola sentencia, por ejemplo:

int[] arr = new int[25]; 
 

Esta sentencia produce el mismo resultado que al hacer la declaración y la construcción

en sentencias separadas.
Hay que tener precaución respecto a la construcción e inicialización de arreglos que
contienen referencias a objetos. Por ejemplo:

Character[] chars = new Character[4]; 
 

Puede generar confusión el uso de la palabra reservada new, al parecer que se invoca
al constructor de la clase Character, pero en realidad se está construyendo únicamente
el arreglo que contendrá 4 referencias a objetos de la clase Character. Si se preguntara

 
5
  

por la cantidad de objetos que habría en el heap luego de ejecutar la anterior sentencia,
se espera que sea claro que solo hay uno, el objeto de arreglo, pues objetos de
Character aún no han sido construidos y, por tanto, no hay referencias que apunten a
objetos en el heap en este momento.
También es posible construir arreglos indicando directamente cuáles son los valores
que contendrá este, así se inicializa el arreglo con los valores suministrados, y el
tamaño se infiere de la cantidad de elementos que se provea. Trataremos en detalle
esta característica al profundizar en la inicialización de arreglos, más adelante.

Construyendo arreglos multidimensionales 

Al crear un arreglo multidimensional, se está solicitando construir un arreglo en donde

cada una de sus posiciones es a su vez otro arreglo. Se puede pensar como un arreglo
de arreglos. Un objeto arreglo que contiene objetos arreglo en cada una de sus
posiciones. El siguiente ejemplo declara y construye un arreglo de dos dimensiones,
comúnmente conocido como matriz, que aloja datos de tipo entero:

int[][] matrix = new int[10][5]; 

Como se sabe, la sentencia crea un arreglo de diez elementos, pero cada uno de estos
elementos es otro arreglo en sí mismo de tamaño 5. Esto es natural en la programación
en Java, pero qué sucede si modificamos un poco la declaración:

int[][] matrix = new int[3][]; 

¿Es legal esta sentencia?, si es así, ¿Qué tipo de estructura se está declarando?
Como se mencionó anteriormente, el único dato necesario para construir un arreglo es
el tamaño que tendrá el arreglo. Sucede lo mismo en este ejemplo: se desea construir
un arreglo (independientemente que este contenga a su vez más arreglos), así que lo
único necesario para crearlo es proveer su tamaño. Una declaración y construcción de
este tipo es legal, pero aún falta construir cada uno de los arreglos contenidos, por esto
aún no se puede usar el objeto. Hasta ahora se le ha indicado al compilador que
necesitamos trabajar con un arreglo que contiene tres arreglos, pero no se ha
especificado qué tamaño tendrá cada uno de esos arreglos porque no se han

 
6  [ POLITÉCNICO GANCOLOMBIANO]
 

construido. Como esto es legal, se puede llegar a construcciones un tanto extrañas

como la siguiente:

int[][] matrix = new int[3][]; 
matrix[0] = new int[3]; 

matrix[1] = new int[2]; 
matrix[2] = new int[1]; 
 

Perfectamente legal, se le está indicando al compilador que de los tres arreglos que
contendrá el arreglo matrix, el primero tendrá un tamaño de tres elementos, el segundo
de dos y el tercero solo tendrá uno. Si representamos la estructura gráficamente como
es costumbre asociando el primer índice a las filas y el segundo a las columnas,
tendríamos una matriz como esta:

0 1 2

0 0 0 0

0 0

Inicializando arreglos

 
7
  

 
Inicializar hace referencia a asignar valores a los elementos del arreglo, los valores
dependerán del tipo declarado para el arreglo, ya sea de tipo primitivo, o de objetos.
Cuando se trata de arreglos de tipos primitivos, al momento de construir el arreglo, este
se inicializa con valores por defecto, sin que el programador tenga que especificarlo
explícitamente.

• Para primitivos byte, short, int y long, el valor por defecto es 0.

• Para primitivos double y float, el valor por defecto es 0,0.
• Para primitivos boolean, el valor por defecto es false.
• Para primitivos char, el valor por defecto es el carácter nulo '\u0000', (no
confundir con el carácter que representa el número cero ‘0’ ‘\u0030’).
Cuando se trabaja con arreglos que contienen objetos, se debe tener en cuenta que
realmente el arreglo no contiene objetos, contiene referencias a estos objetos. Por eso
inmediatamente después de construir un arreglo de referencias a objetos, estas
referencias inicialmente no están referenciando nada, este tipo de referencias vacías en
Java tienen su representación con la palabra clave null. Por tanto, un arreglo de
referencias a objetos recién construido, se inicializará con referencias nulas.
De esta forma, ¿Cuál será el resultado de ejecutar las siguientes sentencias?:

String [] cadenas = new String [3]; 
String mayusculas = cadenas[0].toUpperCase(); 
 

Esto resultaría en una excepción de tipo NullPointerException, pues al construir el

arreglo, solo se solicitó crear un arreglo con capacidad de contener tres referencias a
objetos de clase String, pero estos aún no han sido creados, luego cada posición del
arreglo a esta altura contiene referencias null.
Para inicializar completamente un arreglo de este tipo se tendría que crear cada uno de
sus elementos:

String [] cadenas = new String [3]; 
cadenas[0] = new String (“Cadena 1”); 
cadenas[1] = new String (“Cadena 2”); 
cadenas[2] = new String (“Cadena 3”); 

 
8  [ POLITÉCNICO GANCOLOMBIANO]
 

O lo que es equivalente para el caso de la clase String:

String [] cadenas = new String [3]; 
cadenas[0] = “Cadena 1”; 
cadenas[1] = “Cadena 2”; 

cadenas[2] = “Cadena 3”;

Declarando, construyendo e inicializando arreglos en una

línea
 
Existe una forma reducida de construir un arreglo, incluyendo su declaración e
inicialización en una sola línea de código, como en el siguiente ejemplo:

int []arr = {3,6,7,9}; 
 

Se puede, por tanto, indicarle al compilador en una sola línea, que se desea declarar un
arreglo de enteros, de tamaño cuatro pues se infiere por la cantidad de elementos
separados por comas entre las llaves, y que se inicialice con los valores 3, 6, 7 y 9
respectivamente en sus posiciones. La referencia al arreglo quedará almacenada en la
variable arr.
Esta sentencia es equivalente al siguiente grupo de instrucciones:

int []arr; 
arr = new int[4]; 
arr[0] = 3; 

arr[1] = 6; 
arr[2] = 7; 
arr[3] = 9; 

 
9
  

Esto también es posible al trabajar con arreglos multidimensionales, por ejemplo, la

sentencia:

int [][] matrix = {{3, 4}, {8, 3}, {6, 2}}; 

Crea un arreglo de enteros bidimensional, compuesto por tres arreglos de dos

elementos cada uno. Tal vez sea más claro ver la instrucción escrita de la siguiente
forma:

int [][] matrix = { 
{3, 4},  

{8, 3},  
{6, 2} 
                   }; 

Recuerde que es posible inicializar los arreglos de un arreglo multidimensional con

diferentes tamaños, como por ejemplo:

int [][] matrix = {{3, 4, 1}, {8}, {6, 2, 5, 6}, {7, 4}}; 
 

Construcción e inicialización de un arreglo anónimo

 
Es posible construir y declarar un arreglo, sin necesidad de asignar este a una
referencia. El resultado puede ser usado ya sea para asignarlo a una referencia ya
declarada, o para pasarlo como argumento a un método sin necesidad de crear una
variable. Por ejemplo:
 
int []arr; 
arr = new int[] {6,3,2,1}; 

 
10  [ POLITÉCNICO GANCOLOMBIANO]
 

En este caso, parece no haber mucha diferencia, y los arreglos anónimos no parecen
tener mucha utilidad, pero por ejemplo, en el caso de tener el siguiente método:

public static void imprimirArr (int arr[]){ 

  System.out.println(java.util.Arrays.toString(arr)); 
} 
  

Podríamos usar arreglos anónimos para crear rápidamente un arreglo que serviría
únicamente como parámetro del método. En este caso el llamado al método usando
arreglos anónimos sería:

public static void main(String [] args){ 
   imprimirArr( new int[] {4,5,6,7,8,0}); 
} 
 

El tamaño nunca se especifica dentro de los corchetes ([ ]) al construir un arreglo

anónimo, pues este es inferido a partir de la cantidad de elementos que aparecen
dentro de las llaves ({ }).

Es el momento de aterrizar los conceptos, y el único modo para nuestros propósitos, es

codificando. Observe, pruebe y experimente con los conceptos aquí descritos. Resuelva
las preguntas de prueba de la unidad, y formule sus propias inquietudes. No olvide
completar las lecturas de la semana y participar en las actividades asignadas. En la
lectura de asignaciones se continuará detallando aspectos relativos a los arreglos en
cuánto asignación de referencias.

 
11