ARREGLOS EN JAVA

Un array es una colección finita de datos del mismo tipo, que se almacenan en posiciones
consecutivas de memoria y reciben un nombre común.
Por ejemplo, supongamos que queremos guardar las notas de los 20 alumnos de una clase.
Para almacenar las notas utilizaremos un array de 20 elementos de tipo double y en cada
elemento del array guardaremos la nota de cada alumno.

Para acceder a cada elemento del arreglo se utiliza el nombre del arreglo y un índice que indica la
posición que ocupa el elemento dentro del arreglo.
El índice se escribe entre corchetes.
El primer elemento del arreglo ocupa la posición 0, el segundo la posición 1, etc. En un arreglo de
N elementos el último ocupará la posición N-1.

CREAR ARREGLOS UNIDIMENSIONALES

Para crear un arreglo se deben realizar dos operaciones:
• Declaración
• Instanciación

Declarar un arreglo
En la declaración se crea la referencia al arreglo.
La referencia será el nombre con el que manejaremos el arreglo en el programa.
Se debe indicar el nombre del arreglo y el tipo de datos que contendrá.
De forma general un arreglo unidimensional se puede declarar en java de cualquiera de estas dos
formas:
tipo [] nombreArray;
tipo nombreArray[];
tipo: indica el tipo de datos que contendrá. Un arreglo puede contener elementos de tipo
primitivo o referencias a objetos.
nombreArray: es la referencia al arreglo. Es el nombre que se usará en el programa para
manejarlo.

Por ejemplo:
int[] ventas; //arreglo de datos de tipo int llamado ventas
double[] temperaturas; //arreglo de datos de tipo double llamado temperaturas
String [] nombres; //arreglo de datos de tipo String llamado nombres

Instanciar un arreglo
Mediante la instanciación se reserva un bloque de memoria para almacenar todos los elementos
del arreglo.
La dirección donde comienza el bloque de memoria donde se almacenará el arreglo se asigna al
nombre del arreglo.

De forma general:
nombreArray = new tipo[tamaño];
nombreArray: es el nombre creado en la declaración.
tipo: indica el tipo de datos que contiene.

1
tamaño: es el número de elementos del arreglo. Debe ser una expresión entera positiva. El
tamaño del arreglo no se puede modificar durante la ejecución del programa.
new: operador para crear objetos. Mediante new se asigna la memoria necesaria para ubicar el
objeto. Java implementa los arreglos como objetos.

Por ejemplo:
ventas = new int[5]; //se reserva memoria para 5 enteros y
//se asigna la dirección de inicio del array a ventas.

Lo normal es que la declaración y la instanciación se hagan en una sola instrucción:

tipo [] nombreArray = new tipo[tamaño];

Por ejemplo:
int [] ventas = new int[5];

El tamaño del arreglo también se puede indicar durante la ejecución del programa, es decir, en
tiempo de ejecución se puede pedir por teclado el tamaño del array y crearlo:

Scanner sc = new Scanner(System.in);

System.out.print("Número de elementos del array: ");
int numeroElementos = sc.nextInt();
int [] ventas = new int[numeroElementos];

Si no hay memoria suficiente para crear el array, new lanza una excepción
java.lang.OutOfMemoryError.

Diferencia entre la referencia y el contenido del array

Debe quedar clara la diferencia entre la referencia (manejador del arreglo o nombre del arreglo) y
el contenido del arreglo.
El nombre del arreglo contiene la dirección de memoria del contenido del arreglo.

2
INICIALIZAR ARREGLOS UNIDIMENSIONALES
Un array es un objeto, por lo tanto, cuando se crea, a sus elementos se les asigna
automáticamente un valor inicial:

Valores iniciales por defecto para un array en java:

0 para arrays numéricos
'\u0000' (carácter nulo) para arrays de caracteres
false para arrays booleanos
null para arrays de String y de referencias a objetos.

También podemos dar otros valores iniciales al array cuando se crea.

Los valores iniciales se escriben entre llaves separados por comas.
Los valores iniciales deben aparecer en el orden en que serán asignados a los elementos del array.
El número de valores determina el tamaño del array.

Por ejemplo:
double [] notas = {6.7, 7.5, 5.3, 8.75, 3.6, 6.5};
Se declara el array notas de tipo double, se reserva memoria para 6 elementos y se les asignan
esos valores iniciales.

Ejemplos:
//creación de un array de 4 elementos booleanos
boolean [] resultados = {true,false,true,false};

//creación de un array de 7 elementos de tipo String

String [] dias = {"Lunes", "Martes", "Miércoles", "Jueves", "Viernes",
"Sábado", "Domingo"};

ACCEDER A LOS ELEMENTOS DE UN ARRAY

Para acceder a cada elemento del array se utiliza el nombre del array y un índice que indica la
posición que ocupa el elemento dentro del array.
El índice se escribe entre corchetes.
Se puede utilizar como índice un valor entero, una variable de tipo entero o una expresión de tipo
entero.
El primer elemento del array ocupa la posición 0, el segundo la posición 1, etc. En un array de N
elementos el último ocupará la posición N-1.
Un elemento de un array se puede utilizar igual que cualquier otra variable. Se puede hacer con
ellos las mismas operaciones que se pueden hacer con el resto de variables (incremento,
decremento, operaciones aritméticas, comparaciones, etc).
Por ejemplo:

3
Si se intenta acceder a un elemento que está fuera de los límites del array (un elemento con índice
negativo o con un índice mayor que el que corresponde al último elemento del array) el
compilador no avisa del error. El error se producirá durante la ejecución. En ese caso se lanza una
excepción java.lang.ArrayIndexOutOfBoundsException.
Se puede saber el número de elementos del array mediante el atributo length.
Podemos utilizar length para comprobar el rango del array y evitar errores de acceso.

Por ejemplo, para asignar un valor a un elemento del array que se lee por teclado:

Scanner sc = new Scanner(System.in);

int i, valor;
int [] a = new int[10];
System.out.print("Posición: ");
i = sc.nextInt();
System.out.print("Valor: ");
valor = sc.nextInt();
if (i >= 0 && i < a.length) {
a[i] = valor;
}

4
RECORRER UN ARRAY UNIDIMENSIONAL
Para recorrer un array se utiliza una instrucción iterativa (normalmente una instrucción for,
aunque también puede hacerse con while o do..while) utilizando una variable entera como índice
que tomará valores desde el primer elemento al último o desde el último al primero.
Por ejemplo, el siguiente fragmento de programa Java declara un array de 7 elementos de tipo
double y le asigna valores iniciales. A continuación recorre el array, utilizando la instrucción for,
para mostrar por pantalla el contenido del array.

double[] notas = {2.3, 8.5, 3.2, 9.5, 4, 5.5, 7.0}; //array de 7 elementos
for (int i = 0; i < 7; i++) {
System.out.print(notas[i] + " "); //se muestra cada elemento del array
}

Para evitar errores de acceso al array es recomendable utilizar length para recorrer el array
completo.
Por ejemplo:

double[] notas = {2.3, 8.5, 3.2, 9.5, 4, 5.5, 7.0}; //array de 7 elementos
for (int i = 0; i < notas.length; i++) {
System.out.print(notas[i] + " "); //se muestra cada elemento del array
}

Ejemplo de recorrido de un array en java:

class Main {
public static void main(String[] args) {

// Creación del arreglo

int[] age = {12, 4, 5};

// recorrido del arreglo usando estructura repetitiva for

System.out.println("Usando estructura for:");

for(int i = 0; i < age.length; i++) {

System.out.println(age[i]);
}
}
}

Recorrer un Array en java con for-each. Bucle for para colecciones

A partir de java 5 se incorpora una instrucción for mejorada para recorrer arrays y contenedores
en general.
Permite acceder secuencialmente a cada elemento del array.

La sintaxis general es:

for(tipo nombreDeVariable : nombreArray){
......
}
tipo: indica el tipo de datos que contiene el array.
nombreDeVariable: variable a la que en cada iteración se le asigna el valor de cada elemento del
array. Está definida dentro del for por lo que solo es accesible dentro de él.

5
nombreArray: es el nombre del array que vamos a recorrer.

Mediante este bucle solo podemos acceder a los elementos del array. No podemos hacer
modificaciones en su contenido.

Ejemplo: El siguiente programa crea un array temperatura de 10 elementos. Lee por teclado los
valores y a continuación los muestra por pantalla.

public class Recorrerforeach1 {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

double [] temperatura = new double[10];
int i;

for(i = 0; i < temperatura.length; i++){

System.out.print("Elemento " + i + ": ");
temperatura[i] = sc.nextDouble();
}

for(double t: temperatura){
System.out.print(t + " ");
}
System.out.println();
}
}

ARREGLOS BIDIMENSIONALES / MATRICES EN JAVA

Un array en Java puede tener más de una dimensión. El caso más general son los arrays
bidimensionales también llamados matrices o tablas.
La dimensión de un array la determina el número de índices necesarios para acceder a sus
elementos.
Una matriz necesita dos índices para acceder a sus elementos. Gráficamente podemos representar
una matriz como una tabla de n filas y m columnas cuyos elementos son todos del mismo tipo.
La siguiente figura representa un array M de 3 filas y 5 columnas:

Pero en realidad una matriz en Java es un array de arrays.

6
Gráficamente podemos representar la disposición real en memoria del array anterior así:

La longitud del array M (M.length) es 3.

La longitud de cada fila del array (M[i].length) es 5.
Para acceder a cada elemento de la matriz se utilizan dos índices. El primero indica la fila y el
segundo la columna.

CREAR MATRICES EN JAVA

Se crean de forma similar a los arrays unidimensionales, añadiendo un índice.
Por ejemplo:
Matriz de datos de tipo int llamado ventas de 4 filas y 6 columnas:
int [][] ventas = new int[4][6];

Matriz de datos double llamado temperaturas de 3 filas y 4 columnas:

double [][] temperaturas = new double[3][4];

En Java se pueden crear arrays irregulares en los que el número de elementos de cada fila es
variable. Solo es obligatorio indicar el número de filas.

Por ejemplo:
int [][] m = new int[3][]; // Creación de matriz m de 3 filas

A cada fila se le puede asignar un número distinto de columnas:

m[0] = new int[3];
m[1] = new int[5];
m[2] = new int[2];

Gráficamente podemos representar la disposición real en memoria del array anterior así:

7
INICIALIZAR MATRICES
Un array es un objeto, por lo tanto, cuando se crea, a sus elementos se les asigna
automáticamente un valor inicial:
0 para arrays numéricos
'\u0000' (carácter nulo) para arrays de caracteres
false para arrays booleanos
null para arrays de String y de referencias a objetos

También podemos dar otros valores iniciales al array cuando se crea.

Los valores iniciales se escriben entre llaves separados por comas.
Los valores que se le asignen a cada fila aparecerán a su vez entre llaves separados por comas.
El número de valores determina el tamaño de la matriz.

Por ejemplo:
int [][] numeros = {{6,7,5},{3, 8, 4}, {1,0,2}, {9,5,2}};
Se crea la matriz numeros de tipo int, de 4 filas y 3 columnas, y se le asignan esos valores iniciales.

Asignando valores iniciales se pueden crear también matrices irregulares.

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

Crea una matriz irregular de 4 filas. La primera de 5 columnas, la segunda de 3, la tercera de 4 y la

cuarta de 2.

RECORRER MATRICES
Para recorrer una matriz se anidan dos bucles for. En general para recorrer un array
multidimensional se anidan tantas instrucciones for como dimensiones tenga el array.

Ejemplo de recorrido de una matriz en Java:

//Mostrar por pantalla todos los elementos de la matriz

class MultidimensionalArray {
public static void main(String[] args) {

int[][] a = {
{1, -2, 3},
{-4, -5, 6, 9},
{7},
};

for (int i = 0; i < a.length; ++i) {

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