Programación

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== Los arrays ======

===== Arrays unidimensionales =====

Un array es una estructura de datos que permite almacenar un número indeterminado de variables del mismo tipo, que son referenciadas por el mismo identificador.

Dentro del array, cada valor ocupa una posición y se puede recuperar o modificar su valor combinando el identificador y dicha posición.

<figure>
{{ array.png }}
<caption>Array (fuente:geeksforgeeks.org)</caption></figure>

Como se puede observar en la figura, la primera posición del array es la posición 0. Como consecuencia, la última posición del array será igual a la longitud del mismo menos uno.

==== Declaración del array ====

El array se declara como una variable, indicando tipo e identificador, acompañado de los caracteres ''[''  y \verb '']'' que lo caracterizan, puesto que son los caracteres que se emplean para referirse a alguna posición del mismo.

Una vez declarado puede ser instanciado con la instrucción \verb new  seguido del tipo e indicando el número de elementos para los que se quiere reservar espacio en memoria, tal y como se indica a 
continuación. En este caso, para asignar valor a cada uno de los espacios que se han reservado se puede acceder al array e indicar la posición para la que se quiere asignar 

<code java>
String[] telefonos = new String[5];
telefonos[0] = "976123456";
</code>

También es posible inicializar los valores de un array aprovechando una estructura de bucle como ''for''  de forma que se puede asignar a cada elemento del mismo, posición por posición.

<code java>
String[] telefonos = new String[5];
for (int i = 0; i < telefonos.length; i++) {
    telefonos[i] = " . . . ";
}
</code>

También es posible crear un array asignando directamente los valores que queremos que contenga el mismo. En ese caso se declara un array con la capacidad justa para almacenar todos los valores especificados.

<code java>
String[] telefonos = {"976123456", "91123456", "986789876"}
</code>

Hay que tener en cuenta que pueden crear arrays de tipos primitivos y clases Java, y también de cualquier clase de las que hayas programado en el proyecto. En ese caso, se crea una estructura que almacena las referencias a todos los objetos que se creen en cada una de ellas.

<code java>
Moto[] misMotos = new Moto[10];
</code>

En cualquier caso, un array es una referencia a la estructura donde se almacenan sus valores (o sus referencias, si es un array de objetos), por lo que si se pasa como parámetro a un método, se pasará como referencia.

<figure>
{{ array1.jpg }}
<caption>Array unidimensional (fuente:geeksforgeeks.org)</caption></figure>

==== Utilización del array ====

La utilización del array es muy sencilla. Cada elemento del mismo, una vez indicada la posición, se puede tratar como una variable del mismo tipo que el array, por lo que las operaciones que se pueden hacer con cada elemento son las mismas que se pueden hacer sobre variables individuales.

<code java>
Moto[] misMotos = new Moto[10];
// Poblar el array . . .
. . .
for (int i = 0; i < misMotos.length; i++) {
    misMotos[i].pasarRevision();    // podemos invocar al método de cada elemento del array
}
</code>

También se puede declarar una variable para tomar la referencia del emento del array. A veces es más cómodo para acceder a los métodos del objeto.

<code java>
Moto[] misMotos = new Moto[10];
// Poblar el array . . .
. . .
for (int i = 0; i < misMotos.length; i++) {
    Moto moto = misMotos[i];
    if (!moto.estaRevisada()) {
        moto.pasarRevision();
    }
}
</code>

Los arrays se pueden pasar como parámetro a un método, y lo harán por referencia:

<code java>
int[] numeros = new int[5];
for (int i = 0; i < numeros.length; i++) {
    numeros[i] = 10;
}
incrementar(numeros);
System.out.println(numeros[3]);     // 11
. . .
. . .
public void incrementar(int[] valores) {
    for (int i = 0; i < valores.length; i++) {
        valores[i]++;
    }
}
</code>

===== Arrays bidimensionales =====

Los arrays bidimensionales, también llamados matrices, son arrays en dos dimensiones. En la práctica se puede interpretar como un array unidimensional en el que hay almacenado otro array en cada elemento del primero.

<figure>
{{ array2.jpg }}
<caption>Array bidimensional (fuente:geeksforgeeks.org)</caption></figure>

Se declaran e inicializan de la misma manera que los arrays unidimensionales, pero esta vez hay que tratar con dos dimensiones. Al poderse interpretar como una matriz, la primera dimensión hará referencia a las filas, y la segunda a las columnas

<code java>
String[][] telefonos = new String[5][6];
telefonos[0][0] = "976123456";
</code>

También es posible inicializar los valores de un array aprovechando una estructura de bucle como ''for''  de forma que se puede asignar a cada elemento del mismo, posición por posición. En este caso será necesario anidar dos bucles para acceder a las dos dimensiones del array.

<code java>
String[][] telefonos = new String[5][6];
for (int i = 0; i < telefonos.length; i++) {
    for (int j = 0; j < telefonos[0].length; j++) {
        telefonos[i][j] = " . . . ";
    }
}
</code>

También es posible crear un array bidimensional asignando directamente los valores que queremos que contenga el mismo. En ese caso se declara un array con la capacidad justa para almacenar todos los valores especificados.

<code java>
String[] telefonos = {{"976123456", "91123456", "986789876"}, { . . .}, . . . }
</code>

Y, por supuesto, también podemos crear arrays bidimensionales de objetos:

<code java>
Moto[][] misMotos = new Moto[10][2];
</code>

===== Manipulaciones habituales con arrays =====

En Java disponemos de la clase \verb Arrays  que facilita algunas de las operaciones más comunes que se pueden llevar a cabo con los arrays:

  * ''Arrays.binarySearch()'' Busca en un array un elemento que se pasa como parámetro. Devolverá la posición donde lo encuentra o el valor ''-1''  si no existe. Hay que tener en cuenta que el array deberá de estar ordenado.

<code java>
int[] numeros = new int[10];
for (int i = 0; i < numeros.length; i++) {
    numeros[i] = i * 10;
}
int resultado = Arrays.binarySearch(numeros, 20);
System.out.println(resultado);  // 2
</code>

  * ''Arrays.copyOf()'' Permite copiar el array a otro de diferente longitud (mayor o menor), rellenando o truncando los valores nuevos o eliminados, respectivamente. Devuelve el array resultante
    
<code java>
int[] numeros = new int[5];
  
int[] masNumeros = Arrays.copyOf(numeros, 10);
System.out.println(masNumeros.length);  // 10
</code>

  * ''Arrays.equals()'' Comprueba si dos arrays son iguales. Devuelve un valor booleano indicando si son o no iguales
    
<code java>
int[] numeros = {1, 3, 4};
int[] otrosNumeros = {1, 3, 4};
    
System.out.println(Arrrays.equals(numeros, otrosNumeros)); // true
</code>

  * ''Arrays.fill()'' Rellena un array con el valor que se le pasa como parámetro
    
<code java>
int[] numeros = new int[3];

Arrays.fill(numeros, 5);
System.out.println(Arrays.toString(numeros));   // [5, 5, 5]
</code>

  * ''Arrays.sort()'' Ordena el array que se pasa como parámetro

<code java>
int[] numeros = {4, 10, 3, 6}
Arrays.sort(numeros);
System.out.println(Arrays.toString(numeros));   // [3, 4, 6, 10]
</code>

  * ''Arrays.toString()'' Devuelve una representación en ''String'' del array que se pasa como parámetro

<code java>
int[] numeros = {10, 20, 30, 5}
System.out.println(Arrays.toString(numeros));   // [10, 20, 30, 5]
</code>

===== Bucle for mejorado =====

En Java, existe lo que se conoce como bucle //for-each//. Es un tipo de bucle mejorado para el caso en que se quiera recorrer un array y acceder a cada uno de los elementos del mismo. Por eso, no es necesario utilizar variable auxiliar para el índice ni asignar cada elemento del array para trabajar sobre él, lo hará automáticamente la propia estructura del bucle:

<code java>
Moto[] motos = new Moto[10];
. . .
for (Moto moto : motos) {
    // Se ejecuta este método para todos los elementos del array
    moto.viajar("Zaragoza", "Madrid");
}
</code>

Y además, en el caso de que exista alguna excepción, siempre puede romperse el bucle (con ''break'') o saltarse alguna iteración (con ''continue''.

<code java>
Moto[] motos = new Moto[10];
. . .
for (Moto moto : motos) {
    // Si la moto no esta revisada pasamos a la siguiente
    if (!moto.estaRevisada()) {
        continue;
    }

    moto.viajar("Zaragoza", "Madrid");
    moto. . . .
    . . .
}
</code>

----


(c) 2019-{{date>%Y}} Santiago Faci