Java para programadores (7.1).Creando y empleando arrays

CUANDO VARIOS ELEMENTOS deben ser vistos juntos como una unidad, aparecen las estructuras de datos. Las estructuras de datos pueden ser bastantes complicadas, pero en la mayoría de los casos, consisten simplemente en una secuencia de elementos de datos. La estructura de datos correspondiente a esta variedad tan simple no puede ser otra que el array o los registros.

En Java, no se emplea el termino «registro» .. Un registro es básicamente lo mismo que un objeto Java pero que solo tiene variables instanciables (y no tienen métodos instanciables). Hay otros lenguajes que no soportan objetos en general, y en cambio soportan registros. Los elementos de datos de un registro– en Java es una variable instanciable– se llaman campos del registro. Cada elemento se referencia empleando un nombre de campo. En Java los nombres de campo son realmente el nombre de las instancias de las variables. La característica mas distintiva de un registro es que los campos se referencian por nombre, y cada campo puede ser de un tipo distinto. Por ejemplo, si la clase Persona se define como:

class Persona {
   String nombre;
   int numero_id;
   Date cumpleaños;
   int edad;
}

podríamos considerar el objeto Persona como un registro con cuatro campos. Los nombres de los campos serian: nombre, numero_id, cumpleaños, y edad. Observe que los campos son de distintos tipos :String, int y Date.

Dado que los registros son un tipo de objeto especial, no volveremos a hablar del tema.


Las series se parecen a los registros en que son una secuencia de elementos. Sin embargo, mientras que los elementos de un registro se referencian por nombre, los elementos de una serie están numerados, para referirnos a un elemento concreto, utilizaremos su número de posición. Además, todos los elementos de una serie deben ser del mismo tipo. Visto esto, podemos definir una serie como una secuencia numerada de elementos que todos son del mismo tipo. El numero de elementos de una serie se llama longitud de la serie. El numero de posición de un elemento de la serie se le llama índice (índex) del elemento.El tipo de un elemento individual se llama tipo base de la serie.

En Java, los elementos de una serie se empiezan a numerar en cero. Esto es, el índice del primer elemento de la serie es 0. Si la longitud de la serie es N, el índice del ultimo elemento de la serie será N-1. Una vez se crea la serie,no podemos cambiar su longitud.

Las series en Java son objetos. Esto tiene algunas consecuencias. Las series se crean usando el operador new. Las variables no pueden almacenar series, solo pueden referirse a series. Cualquier variable que pueda referirse a una serie, puede contener el valor null, significando entonces que en ese momento no se refiere a nada. Como cualquier objeto, una serie pertenece a una clase y como la mayoría, es una subclase de la clase Object.

No obstante, aun cuando las series son objetos, hay diferencias entre las series y otros tipos de objetos, y hay un conjunto de características del lenguaje para crear y usar las series.


Suponga que A es una variable que se refiere a una serie. Entonces el elemento K de A se referenciará como A[K]. El primer elemento es A[0], el segundo es A[1], y así sucesivamente. «A[K] » puede emplearse como si fuera una variable. Le puede asignar valores, puede usarlo en expresiones y puede pasarlo como parámetro a una subrutina. Todo esto lo veremos con mas detalle a continuación. Por ahora nos quedaremos con la sintaxis

array-variable [ integer-expression ]

Para referirnos a un elemento de la serie.

Aunque cada serie es miembro de alguna clase, la clase array nunca tiene que definirse. En cuanto un tipo existe, la correspondiente clase de Arrays existe de forma automática. Si el nombre del tipo es BaseType, el nombre asociado a la clase es BaseType[]. Esto es, un objeto perteneciente a la clase BaseType[] es un a serie de elementos donde cada elemento es un valor de tipo BaseType . Los corchetes. «[]», sirven para recordar la sintaxis para referirse a los elementos individuales de la serie. «BaseType[]» debe leerse como «serie de BaseType".

El tipo base de una serie puede ser cualquier tipo legal de Java, esto significa que puede ser cualquier tipo primitivo, una interface o una clase. Del tipo int se deriva la serie de tipos int[]. Cada elemento en la serie de tipo int[] es un valor de tipo int. De la clase llamada Shape se deriva la serie tipo Shape[]. Cada elemento de una serie tipo Shape[] es un valor del tipo de la clase, que pueden ser nulos o referirse a un objeto de la clase Shape.(Puede que sea interesante mencionar en este momento que si ClassA es una subclase de ClassB, entonces ClassA[] es automáticamente una subclase de ClassB[])


Vamos a intentar concretar un poco todo esto usando una serie de integers como ejemplo. Dado que int[] es una clase, podemos utilizarla para declarar variables. Por ejemplo:

int[] list;

crea una variable llamada list de tipo int[]. Esta variable es capaz de referirse a una serie de ints. pero el valor inicial es null. Tendremos que emplear el operador new para crear un objeto nuevo array, que podremos asignar a list. La sintaxis para usar new con series, es diferente a la que ha aprendido previamente para otras clases. Veamos el ejemplo:

list = new int[5];

crea una serie de cinco enteros. De forma mas general, «new BaseType[N]» crea una serie perteneciente a la clase BaseType[]. El valor N entre corchetes define la longitud de la serie, esto es, el numero de elementos que se pueden almacenar. Observe que la serie sabe la longitud que tiene. La longitud de la serie es algo semejante a una instancia de variable del objeto array, y de hecho, la longitud de la serie list puede referenciarse como list.length (Sin embargo, no esta permitido cambiar el valor de list.length. ósea que no es una instancia normal). La situación creada por la instrucción «list = new int[5];" puede pintarse de una forma semejante a esto

Curso de Java. Imagen de un array

Observe que la serie de enteros recién creada se llena automáticamente con ceros. En Java, la creación de una serie siempre provoca que se llenen todos sus elementos con el valor por defecto.

Los elementos de list pueden referenciarse como list[0], list[1], list[2], list[3], y list[4]. (Observe que el índice del ultimo elemento es menor en una unidad a list.length). Sin embargo, existen formas mucho mas generales de indicar un elemento de una serie. Para indicar un elemento, los corchetes pueden contener cualquier expresión que como resultado genere un entero. Por ejemplo, si indx es una variable de tipo int, entonces list[indx] y list[2*indx+7] son referencias a elementos de una serie sintácticamente correctos. Y el bucle siguiente, imprime todos los enteros de la serie list en la salida estándar:

        for (int i = 0; i < list.length; i++) {
           System.out.println( list[i] );
        }

La primera vez que se pasa por el bucle, i es 0, y list[i] se refiere a list[0]. La segunda vez que pasa, i es 1 y list[i] se refiere a  list[1]. El bucle finaliza después de imprimir list[4], cuando i vale 5 y la condición de continuación «i<list.length" se deja de cumplir. Esto es un ejemplo típico del uso de los bucles para tratar series. Comentaré mas ejemplos de procesos de series en la siguiente sección.

Si piensa por un momento que es lo que puede hacer el ordenador cuando encuentra una expresión como «list[k]» mientras ejecuta un programa, vera que hay dos cosas que pueden provocar un error. La expresión intenta acceder a un elemento especifico referenciado por la variable list. Pero suponga que el valor de list es nulo. En este caso, list no se refiere a ninguna serie,por lo que el uso de  «list[k]» es erróneo. . Esto es un ejemplo de «null pointer error». Incluso aunque list se refiera a una serie es posible que el valor de K este fuera del rango de índices correcto . Esto pasa si k<0 o si k>=list.length En este caso, de nuevo, no es correcto el empleo de «list[k]«. Este error es «array índex out of bounds» . Cuando emplee en su programa series, deberá tener mucho cuidado de no cometer ninguno de estos dos errores.

Para una serie variable, igual que para cualquier variable, puede declararla e inicializarla en una sola pasada. Por ejemplo,

int[] list = new int[5];

La nueva serie se llenara con el valor adecuado según el tipo base (cero para int y null para los tipos de clase, por ejemplo). Sin embargo, Java también facilita la manera de inicializar una serie con una  lista de valores. Esto es una forma de inicializar una serie. Por ejemplo:

int[] list = { 1, 4, 9, 16, 25, 36, 49 };

crea una nueva serie que contiene siete valores 1, 4, 9, 16, 25, 36, y 49, y deja en list una referencia a la nueva serie. El valor de list[0] será 1, el valor de list[1] será  2, y así sucesivamente. La longitud de list es 7 dado que los valores facilitados al inicializador fueron 7.

Una serie de inicialización toma la forma de una serie de valores, separados por comas y encerrados entre llaves. La longitud de la serie no es necesario especificarla, ya que viene implícita en el numero de elementos de la lista de valores. Los elementos inicializadores no tienen porque ser constantes. Pueden ser variables, o expresiones, siempre que generen los tipos apropiados. Por ejemplo, la siguiente declaración crea una serie de ocho Colors. Alguno de los colores se definen con expresiones de la forma «new Color(r,g,b)":

        Color[] palette =
                   {
                     Color.black,
                     Color.red,
                     Color.pink,
                     new Color(0,180,0),  // verde oscuro
                     Color.green,
                     Color.blue,
                     new Color(180,180,255),  // azul brillante
                     Color.white
                   }

Una nota final: Por razones históricas, la declaración

int[] list;

puede ser escrita como

int list[];

que es la sintaxis usada en los lenguajes C y C++. Sin embargo esta sintaxis alternativa no tiene mucho sentido en el contexto de Java y probablemente, lo mejor es olvidarla. Después de todo, se intenta declarar una variable de un cierto tipo, y el nombre del tipo es «int[]«. Es mas lógico seguir la sintaxis «nombre_tipo nombre_variable;»  que es la habitual.

Acerca de Miguel Garcia

Programador, Desarrollador web, Formador en distintas areas de informatica y director de equipos multidisciplinares.
Esta entrada fue publicada en Formacion, Java y etiquetada , , . Guarda el enlace permanente.

Una respuesta a Java para programadores (7.1).Creando y empleando arrays

  1. Pingback: Java - Un resumen organizado....o no.Recursos para formacion

Deja un comentario

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.