En esta entrada les hablaré sobre los arreglos unidimensionales, la estructura de datos más simple pero básica para el tratamiento de datos a una mayor escala en un programa.

Una gran parte del procesamiento de la información es precisamente la información. Ya sea en su etapa inicial, en su forma de datos, como en su etapa final, en forma de información, son el motivo de que existan las tecnologías de la información. Y hay incontables ocasiones en que como programadores se nos olvida eso, y nos enfocamos más en el “cómo” se hacen las cosas, que en el “con qué”.

Estructuras de datos.

En una entrada previa hablé sobre los datos como primer elemento del procesamiento de la información.  Ahora introduzco el concepto de estructura de datos antes de hablar de los arreglos.

Una estructura de datos es una forma de almacenar, representar y organizar un conjunto de datos. En la figura 1 puedes observar la clasificación de las estructuras de datos. Como puedes ver, existen desde las estructuras de datos más simples, capaces de almacenar un solo valor a la vez como las variables y las constantes. Después, dentro del grupo de estructuras de datos complejas tenemos a aquellas organizaciones que nos permiten almacenar un conjunto de datos, como las estructuras de datos estáticas y las estructuras de datos dinámicas.

Figura 1. Clasificación de las estructuras de datos.

Las estructuras estáticas pueden almacenar un conjunto de tamaño definido, es decir, el tamaño del conjunto no puede crecer dinámicamente en tiempo de ejecución. En cambio, las estructuras dinámicas pueden almacenar un conjunto de datos no homogéneos (es decir, contener diversos tipos de datos), y este conjunto puede crecer de forma dinámica en tiempo de ejecución. Esto quiere decir que el tamaño del conjunto cambiará según las condiciones que se den durante la ejecución del programa.

Arreglos Unidimensionales.

Como ya comenté, la estructura más básica es el arreglo. Al arreglo también se le conoce con el nombre de vector o array. Según Deitel & Deitel:

“Un arreglo es un grupo de posiciones de memoria contiguas, todas las cuales tienen el mismo nombre y el mismo tipo”

Un arreglo es una estructura de datos que puede almacenar un conjunto de datos de un mismo tipo. Los datos se almacenan en forma contigua. Observa en la figura 2 la diferencia entre un arreglo y una variable estática simple. Mientras que la variable x sólo puede almacenar un único valor a la vez, el arreglo z puede contener un conjunto de n datos del mismo tipo.  Sin embargo, tanto x como z son variables.

Figura 2. Diferencia entre una variable simple y un arreglo.

Declaración y creación.

Para utilizar un arreglo, como toda variable en Java, debe ser primero declarado. La forma general te la muestro en la figura 3.

Figura 3. Declaración de un arreglo.

Los corchetes nos indican que se tratará de un arreglo y no de una variable simple. En el caso de los arreglos, la declaración por sí sola no crea inmediatamente el espacio de almacenamiento, por lo que es necesario mediante el operador new indicar el número de casillas de memoria que utilizará el arreglo. (De ahí su carácter de estructura de datos estática) Esto implica que es necesario crear el arreglo, como se te muestra en la figura 4, en la cual se supone que el arreglo tuvo que haber sido declarado con anterioridad.

Figura 4. Construcción de un arreglo.

Con respecto al tamaño del arreglo:

• Debe ser un valor entero
• Puede expresarse con una constante numérica (5, 10, 2000, etc.):

arreglo = new int[100];

• También puede expresarse con una constante simbólica:

public static final constante = 10;
…
arreglo = new int[constante];

• Y también puede usarse una variable entera, siempre y cuando, ya haya sido inicializada antes de la creación del arreglo:

int t = 10;
arreglo = new int[t];

Una vez que se ha asignado tamaño de almacenamiento al arreglo se dice que ha sido “construido”, y, por lo tanto, se puede emplear en el programa. Cuando esto sucede, todos los elementos en el arreglo se inicializan a cero en el caso de haber sido declarado int, float o double; false en el caso del tipo boolean o null en el caso de ser un arreglo de referencias.

¿En una sola instrucción?

La declaración y construcción del arreglo se puede realizar en líneas separadas o en una sola línea de código. A veces puede ser por el estilo del programador, pero también puede ser conveniente hacerlo por separado.

Por ejemplo, considera que estarás usando un arreglo para almacenar la respuesta de varias personas encuestadas a la pregunta: ¿Qué prefiere, Android o iOS? Si declaras y construyes el arreglo de la siguiente forma:

String[] respuestas = new String[10];

Estarás limitado únicamente a 10 personas encuestadas. Por otro lado, algo como esto:

String[] respuestas = new String[t];

Sería incorrecto si a t aún no se le ha inicializado.

Para este tipo de situaciones, en donde no sabes con exactitud cuántos elementos de un arreglo necesitas, podemos hacer un poco de “trampa” para saltarnos el carácter estático de los arreglos si declaramos primero el arreglo y después lo construimos. Algo como esto:

String[] respuestas;
int t;
…
// Solicitamos el valor de t
respuestas = new String[t];

Aunque parece igual a lo mostrado arriba la diferencia radica en que para cuando construimos el arreglo, t ya tiene un valor, y por lo tanto, ya se puede utilizar para asignarle un tamaño al arreglo de respuestas.

Inicialización.

Por supesto que puedes inicializar un arreglo leyendo sus valores desde el teclado. Pero además puedes inicializarlo en tiempo de edición como te muestro a continuación:

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

En el ejemplo se declaró un arreglo de enteros sin dimensión, la cual tomará del número de elementos contenidos entre las { }. De esta forma, su tamaño es 10, y sus  elementos son:

arreglo[0] = 1
arreglo[1] = 2
arreglo[2] = 3
arreglo[3] = 4
arreglo[4] = 5
arreglo[5] = 6
arreglo[6] = 7
arreglo[7] = 8
arreglo[8] = 9
arreglo[9] = 10

De esta forma puedes inicializar arreglos de cualquier tipo de datos, como por ejemplo:

String[] nombres = { "Sinforoso", "Filomena", "Pancrasia", "Anacleto", "Tiburcio", "Petra"}; // Un arreglo de cadenas de texto
char[]  caracteres = {'#', '@', '?', '*', '/', '-', '&']}; // Un arreglo de caracteres
boolean[] valores = {true, true, true, false, true, false, false, true, false}; // Un arreglo de valores booleanos.

Y así estás declarando, construyendo e inicializando arreglos usando sólo una instrucción.

La propiedad length

Todo arreglo declarado y construido apropiadamente es de hecho un objeto especial. Los objetos en Java tienen métodos y propiedades. En el caso de un arreglo de cualquier tipo de elementos, su única propiedad es length, la cual contiene el número de elementos en el arreglo.

Ten en cuenta que length es propiedad del arreglo, por lo tanto:

• No puede usarse “sola“, como una variable, sino siempre acompañada del nombre del arreglo seguido por un punto y la propiedad lenght:

x = numeros.length;

• Siempre existe al existir el arreglo, de forma automática.
• No podemos modificar su valor, puesto que los arreglos son estructuras de datos estáticas, que definen su tamaño al inicio de su construcción, y no dinámicamente como otras estructuras.
• Siempre representa un valor entero, el cual puede incluso usarse como índice (sólo recuerda que la casilla indicada por length no  existe, pues este valor guarda el número de elementos, no las casillas que tiene el arreglo) :

x = numeros[numeros.length-1] // x guarda el último dato del arreglo numeros

• O como límite para los ciclos:

for (i=0; i<numeros.length; i++ )

Acceso a los elementos de un arreglo.

Una vez declarado y construido el arreglo, lo más simple que podemos hacer es acceder a los elementos de cada casilla del arreglo. Para ello, se requiere un índice, el cual es un valor entero que indica la posición del elemento en el arreglo. La posición es como la dirección de un elemento en el arreglo, como una dirección de una persona que vive en un edificio de departamentos. (De ahí mi decisión de usar la excelente foto de Carlos ZGZ para ilustrar el concepto de un arreglo).

int[] arreglo = new int[10];

Tiene 10 casillas, 10 elementos, 10 espacios para almacenar datos tipo int; pero sólo tiene hasta la dirección 9, porque su primera dirección es 0. Intentar acceder a la dirección 10 generará el error que te muestro en la figura 5.

Figura 5. Excepción por sobrepasar los límites de un arreglo.

Algo muy importante: cuando se trabaja con arreglos SIEMPRE debes especificar el índice que deseas utilizar. Observa la figura 6, en esta se muestra un error típico al manejar arreglos: olvidarnos del índice.

Figura 6. Error generado por olvidar el uso del índice de un arreglo.

Se declara el arreglo numeros, pero después no se especifica la dirección en donde se pretender almacenar el valor 8.  Si se desea que cada casilla de números valga 8, se debe utilizar un ciclo for para hacerlo (continúa leyendo, porque esto se explica más adelante).

Introducción de datos a un arreglo.

La forma general para introducir un dato a una casilla específica de un arreglo se muestra en la figura 7.

Figura 7. Forma general para introducir datos en un arreglo.

A partir de esta forma general se pueden presentar algunas variaciones como:

• El índice puede ser una constante numérica:

arreglo[3] = 9;

• El índice puede ser una variable tipo int:

arreglo[i] = 9;  // donde i es una variable entera e inicializada

• O  también  un valor constante numérico que se encuentre dentro de los límites de tamaño del arreglo:

arreglo[2] = true // si arreglo es de tipo boolean, y el tamaño del arreglo es al menos de 3

• El valor almacenado en cada una de las casillas puede ser una variable cuyo tipo sea igual al tipo del arreglo:

arreglo[3] =  x;

• O puede ser una operación cuyo resultado sea compatible con el tipo del arreglo:

arreglo[4] = x%y; //arreglo debe ser tipo int para poder almacenar este resultado

• Además, el índice puede también ser el resultado de una operación entera:

arreglo[i*2] = 12;

Recuperación de los elementos de un arreglo.

Se pueden “recuperar” los valores almacenados en un arreglo simplemente indicando el nombre de la variable y el índice de la casilla deseada. A continuación, muestro algunos ejemplos:

x = arreglo[2]; // A la variable x se le asigna el contenido de la casilla 2 del arreglo
y = arreglo[i];   // A la variable y se le asigna el contenido de la casilla i del arreglo
arreglo1[4] = arreglo2[3]; // A la casilla 4 del arreglo1  se le asigna el contenido de la casilla 3 del arreglo2
x = arreglo1[1] + arreglo2[99]; // La variable x almacena la suma del contenido de la casilla 1 del arreglo1 con el contenido de la casilla 99 del arreglo2.
arreglo[k] += 15; // Al contenido actual de la casilla k de arreglo se le añade 15.
arreglo[0]--; // El contenido actual de la casilla 0 de arreglo se decrementa en 1.
x = arreglo[arreglo.length-1]; // x almacena el último valor de arreglo

Agilizando la manipulación de los arreglos

Cuando se requiere realizar una misma tarea sobre cada uno de los elementos del arreglo, lo más recomendable es utilizar un ciclo para recorrer cada una de sus casillas.

Uso de la estructura for para manipular arreglos

Debido a que el índice de un arreglo puede ser una variable entera que se incrementa o decrementa de 1 en 1, el ciclo for es el más adecuado para esta tarea. Por ejemplo, si necesitamos que todos los elementos de un arreglo sean inicializados a -1, el código mostrado en la figura 8 realiza el trabajo.

Figura 8. Ejemplo de inicialización de todos los elementos de un arreglo.

El código que muestro a continuación imprime el contenido del arreglo x:

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

Uso del for extendido.

Java introdujo desde la versión 5, una modificación a la clásica estructura de control for; a la que se le llama for extendido o for:each. Esta versión del for es especialmente útil para recorrer un arreglo. La forma general de esta estructura la puedes observar en la figura 9.

Figura 9. Sintaxis del for extendido (for:each) en java.

Simplemente expresa una forma corta, abreviada de utilizar el for para hacer un recorrido por cada uno de los elementos del arreglo. El código que se mostró en la sección anterior para imprimir cada uno de los elementos del arreglo, también puede ser escrito de la siguiente forma, utilizando el for extendido:

for (int i : arreglo)
   System.out.println(i);

Lo que hace diferente al for extendido del for clásico es que en el primero no tienes que usar al índice para acceder a un elemento específico del arreglo, sino a la variable declarada dentro del for. Si observas el ejemplo, en lugar de escribir:

System.out.println(arreglo[i]);

Utilizamos:

System.out.println(i);

En donde i es la variable que tendrá el elemento de arreglo[i].

El for:each es una forma más elegante de recorrer arreglos. Al no tener un contador explícito, este ciclo se puede entender como:

“Haz esto a cada elemento en este conjunto” (Stack Overflow)

En lugar de:

“Haz esto x veces”

Si consideras que este artículo ha sido útil, no olvides compartirlo en tus redes sociales.

¿Te puedo ayudar? Déjame tu comentario y/o pregunta y con gusto responderé a tus preguntas.

¡Hasta la próxima entrada y gracias por leerme!

Guardar

Guardar

Guardar

Guardar

Guardar

Guardar

Guardar

Guardar

Guardar

Guardar