PDF de programación - Guardar objetos - Piensa en Java

9: Guardar objetos

Es un programa bastante simple que sólo tiene una cantidad fija de objetos cu-
yos periodos de vida son conocidos.

En general, los programas siempre estarán creando nuevos objetos, en base a algún criterio
que sólo se conocerá en tiempo de ejecución. No se sabrá hasta ese momento la cantidad o
incluso el tipo exacto de objetos necesarios. Para solucionar el problema de programación
general, hay que crear cualquier número de objetos, en cualquier momento, en cualquier
sitio. Por tanto, no se puede confiar en crear una referencia con nombre que guarde cada
objeto:

dado que, de hecho, nunca se sabrá cuántas se necesitarán.

Para solucionar este problema tan esencial, Java tiene distintas maneras de guardar los objetos (o
mejor, referencias a objetos). El tipo incrustado es el ar-ray, lo cual ya hemos discutido anterior-
mente. Además, la biblioteca de utilidades de Java tiene un conjunto razonablemente completo de
clases contenedoras (conocidas también como clases colección, pero dado que las bibliotecas de Java
2 usan el nombre Collection para hacer referencia a un subconjunto particular de la biblioteca, usa-
remos el término más genérico "contenedor"). Los contenedores proporcionan formas sofisticadas
de guardar e incluso manipular objetos.

Arrays

La mayoría de la introducción necesaria a los arrays se encuentra en la última sección del Capítulo 4,
que mostraba cómo definir e inicializar un array. El propósito de este capítulo es el almacenamiento
de objetos, y un array es justo una manera de guardar objetos. Pero hay muchas otras formas de guar-
dar objetos, así que, ¿qué hace que un array sea tan especial?

Hay dos aspectos que distinguen a los arrays de otros tipos de contenedores: la eficiencia y el
tipo. El array es la forma más eficiente que proporciona Java para almacenar y acceder al azar a
una secuencia de objetos (verdaderamente, referencias a objeto). El array es una secuencia li-
neal simple, que hace rápidos los accesos a elementos, pero se paga por esta velocidad: cuando
se crea un objeto array, su tamaño es limitado y no puede variarse durante la vida de ese objeto
array. Se podría sugerir crear un array de un tamaño particular y, después, si se acaba el espa-
cio, crear uno nuevo y mover todas las referencias del viejo al nuevo. Éste es el comportamien-
to de la clase ArrayList, que será estudiada más adelante en este capítulo. Sin embargo, debido
a la sobrecarga de esta flexibilidad de tamaño, un ArrayList es mucho menos eficiente que un
array.

302

Piensa en Java

La clase contenedora Vector de C++ no conoce el tipo de objetos que guarda, pero tiene un incon-
veniente diferente cuando se compara con los arrays de Java: el operador[] de vector de C++ no
hace comprobación de límites, por lo que se puede ir más allá de su final1. En Java, hay comproba-
ción de límites independientemente de si se está usando un array o un contenedor -se obtendrá
una excepción e n tiempo d e ejecución si se exceden los límites. Como se aprenderá en el
Capítulo 10, este tipo de excepción indica un error del programador, y por tanto, no es necesario
comprobarlo en el código. Aparte de esto, la razón por la que el vector de C++ no comprueba los 1í-
mites en todos los accesos es la velocidad -en
Java se tiene sobrecarga de rendimiento constante
de comprobación de límites todo el tiempo, tanto para arrays, como para contenedores.

Las otras clases contenedoras genéricas List, Set y Map que se estudiarán más adelante en este ca-
pítulo, manipulan los objetos como si no tuvieran tipo específico. Es decir, las tratan como de tipo
Object, la clase raíz de todas las clases de Java. Esto trabaja bien desde un punto de vista: es nece-
sario construir sólo un contenedor, y cualquier objeto Java entrará en ese contenedor. (Excepto por
los tipos primitivos -que pueden ser ubicados en contenedores como constantes, utilizando las cla-
ses envolturas primitivas de Java, o como valores modificables envolviendo la propia clase.) Éste es
el segundo lugar en el que un array es superior a los contenedores genéricos: cuando se crea un
array, se crea para guardar un tipo específico. Esto significa que se da una comprobación de tipos
en tiempo de compilación para evitar introducir el tipo erróneo o confundir el tipo que se espera.
Por supuesto, Java evitará que se envíe el mensaje inapropiado a un objeto, bien en tiempo de com-
pilación bien en tiempo de ejecución. Por tanto, no supone un riesgo mayor de una o de otra forma,
sino que es simplemente más elegante que sea el compilador el que señale el error, además de ser
más rápido en tiempo de ejecución, y así habrá menos probabilidades de sorprender al usuario final
con una excepción.

En aras de la eficiencia y de la comprobación de tipos, siempre merece la pena intentar usar un
array si se puede. Sin embargo, cuando se intenta solucionar un problema más genérico, los arrays
pueden ser demasiado restrictivos. Después de ver los arrays, el resto de este capítulo se dedicará
a las clases contenedoras proporcionadas por Java.

Los arrays son objetos

de primera clase

Independientemente del tipo de array con el que se esté trabajando, el identificador de array es, de
hecho, una referencia a un objeto verdadero que se crea en el montículo. Éste es el objeto que man-
tiene las referencias a los otros objetos, y puede crearse implícitamente como parte de la sintaxis de
inicialización del atributo, o explícitamente mediante una sentencia new. Parte del objeto array (de
hecho, el único atributo o método al que se puede acceder) es el miembro length de sólo lectura
que dice cuántos elementos pueden almacenarse en ese array objeto. La sintaxis TI' es el otro ac-
ceso que se tiene al array objeto.

' Es posible. sin embargo, preguntar por el tamaño del vector, y el método at( ) si que hará comprobación de límites.

9: Guardar objetos

303

El ejemplo siguiente muestra las distintas formas de inicializar un array, y cómo se pueden asignar
las referencias array a distintos objetos array. También muestra que los arrays de objetos y los
arrays de tipos primitivos son casi idénticos en uso. La única diferencia es que los arrays de objetos
almacenan referencias, mientras que los arrays de primitivas guardan los valores primitivos direc-
tamente.

/ / : cO9:TerminoArray.java
/ / Inicialización y reasignación de arrays.

class Mitologia { } / / Una pequeña criatura mítica

public class TerminoArray {

public static void main (String[] args) {

/ / Arrays de objetos:
Mitologia[] a; / / Referencia Null
Mitologia[l b = new Mitologia[5] ; / / Referencias Null
Mitologia [ ] c = new Mitologia [4] ;
for (int i = O; i < c.length; i+t)

c[i] = new MitologiaO;

/ / Inicialización de agregados:
Mitologia [ ] d =

{

new Mitologia ( ) , new Mitologia ( ) , new Mitologia ( )

1;
/ / Inicialización dinámica de agregados:
a = new Mitologia[] {

new Mitologia ( ) , new Mitologia ( )

1;
System.out.println("a.length=" + a.length);
System.out .println ("b. length = " + b. length) ;
/ / Las referencias internas del array se
/ / inicializan automáticamente a null:
for (int i = O; i < b. length; i++)

System.out .println ("b [ " + i + "1 =" + b[il);
System. out .println ("c. length = " + c. length) ;
System. out .println ("d. length = " + d. length) ;
a = d;
System.out .println ("a. length = " + a. length) ;

/ / Arrays de datos primitivos:
int [ ] e; / / Referencia null
i n t [ ] f = new int[5];
int[] g = new int[4];
for(int i = O; i < g.length; i++)

g[i] = i*i;

int[] h =

{ 11, 47, 93 } ;

304

Piensa en Java

/ / Error de compilación: variable e sin inicializar:
//!System.out.println("e.length=" + e.length);
System.out .println ("f. length = " + f. length) ;
/ / Los datos primitivos de dentro del array se
/ / inicializan automáticamente a cero:
for (int i = O; i < f .length; i++)

System.out .println ("f [ " + i +

"1 =" + f[il);
System.out .println ("9. length = " + g. length) ;
System.out .println ("h. length = " t h. length) ;
e = h;
System. out .println ("e. length = " + e. length) ;
e = new int[] { 1, 2 } ;
System.out.println("e.1ength = " + e.length);

1

1 / / / : -

He aquí la salida del programa:

b.length = 5
b [O] =null
b [1] =null
b [2] =null
b [ 3 ] =null
b [4] =null
c.length = 4
d.length = 3
a.length = 3
a.length = 2
f .length = 5
f [Ol=O
f [l]=O
f [2]=0
f [3] =o
f [4] =o
g.length = 4
h.length = 3
e.length = 3
e.length = 2

Inicialmente una simple referencia nuil (traducción errónea), y el compilador evita que se haga
nada con ella hasta que se haya inicializado adecuadamente. El array b se inicializa a un array de
referencias Mitología, pero, de hecho, no se colocan objetos Mitología en ese array. Sin embargo,
se sigue pudiendo preguntar por el tamaño del array, dado que b apuntó a un objeto legítimo. Esto
presenta un pequeño inconveniente: no se puede averiguar cuántos elementos hay en el array, pues-
to que length dice sólo cuántos elementos se pueden ubicar en el array; es decir, el tamaño del ob-
ieto array, no el número de objetos que alberga. Sin embargo, cuando se crea un objeto array sus

9: Guardar objetos

305

referencias se inicializan automáticamente a null, por lo que se puede ver si una posición concreta
del array tiene un objeto, comprobando si es o no null. De forma análoga, un array de tipos primi-
tivos se inicializa automáticamente a cero en el caso de los números, (char)O en el caso de carac-
teres, y false si se trata de lógi