Formación informática

Java | Joomla | MySQL

Curso de Java – Tema 26.2: Arrays o arreglos unidimensionales o vectores

Array en JavaEs un grupo de datos en una misma unidad que forma una estructura de datos con un tamaño fijo determinado durante la instanciación del objeto. Por lo tanto, una vez creado su tamaño no varía. Es una especie de tabla dónde se guardan datos ordenados por el índice. Tiene métodos que se pueden usar. Todos los datos están guardados bajo el mismo nombre pero cada uno se diferencia por su posición dentro del array. Una peculiaridad muy importante es que el índice comienza por 0.

Un array es un tipo de estructura de datos, es una secuencia de ítems del mismo tipo. Cada ítem es accesible con su índice. Puede ser de un tipo primitivo (int, char,...) o de objetos (String, Alumno, Word,...).

Estructura de un array

La sintaxis genérica para declarar un objeto de tipo array es, los corchetes son un símbolo especial que indica que la variable contiene un array:

tipo_dato [] nombre_variable;
objeto [] nombre_variable;

Por ejemplo:

int[] values;
double[] notas;
String[] cadenas;

Se puede crear un objeto de tipo array de dos formas distintas, tras haberlo declarado. La primera es después de haberlo declarado en una sentencia anterior:

nombre_array = new tipo [número_de_elementos];

La segunda es declararlo y crearlo en la misma sentencia:

tipo_dato [] nombre_array = new tipo_datos [número_de_elementos];

Por ejemplo, en el siguiente código hemos declarado en un primer caso tabla de 100 elementos de tipo int mientras que en el segundo hemos creado un objeto array con 2 números.:

values = new int[100];
double[] notas = {10,5.5

Se pueden inicializar usando bucles for como resultado de alguna operación:

for(int i=0; i13; i++){
		numeros[i]=i*i+13;
	}

Propiedades de los arrays

Un array es una estructura estática: su tamaño no puede cambiar. No podemos reducirlo si ya no queremos un elemento o aumentarlo si queremos más elementos.

Al llamar a un método con sus argumentos de entrada, se copia el valor de estos argumentos, y son estas copias que se pasan al método y que se trabajan dentro del método.

Si intentamos acceder a un elemento mediante un índice fuera de rango, tendremos una excepción de tipo ArrayIndexOutOfBoundException.

Cada elemento individual de un array se relaciona con el nombre de la variable y un número (índice) que indica la posición que ocupa el elemento en el array. El número se pone entre corchetes y se llama subíndice. El subíndice puede ser una constante numérica o una expresión algebraica.

nombre_array [subíndice]

Una vez que se ha realizado cualquier tipo de cálculo con el contenido del array y se ha almacenado en variables locales, podemos acceder a ellas posteriormente.

Métodos más empleados

El tamaño máximo del array se puede saber mediante el método length, es decir, podemos saber el número de posiciones ocupadas en el array. Se usa para recorrer arrays y realizar operaciones con ellos.

Usos

Si tenemos que mostrar por línea de comandos el contenido dentro del array tenemos que hacerlo incluyendo en la sentencia System.out.println el siguiente código:

System.out.println (nombre_del_array [variable_que_recorre_array])

Para mostrar la posición que ocupa un elemento en el array tenemos que escribir:

System.out.println (nombre_del_array)
Recorrer y mostrar el contenido de un array

Para leer los elementos de un array el proceso consiste en recorrer mediante un bucle cada posición para mostrar su contenido, siendo la condición de finalización que el contador de vueltas i sea menor que la longitud del array. En cada vuelta se muestra el contenido. La sintaxis genérica es:

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

Para hacer operaciones con el contenido el proceso consiste en recorrer mediante un bucle cada posición para acceder a su contenido y hacer las operaciones requeridas mediante variables temporales y operadores de asignación, siendo la condición de finalización el que el contador de vueltas sea menor que la longitud del array. La sintaxis genérica es:

for(int i=0; inombres.length; i++){
suma += nombre_array[i];}

Si queremos que Java nos devuelva la suma de las posiciones, es decir, la suma de 0 más 1 más 2… así hasta recorrer todos los elementos del array, la sintaxis genérica es:

for(int i=0; inombres.length; i++){
suma += nombre_array;}

Para saber cuál es el mayor número almacenado en un array el proceso consiste en recorrer todas las posiciones del array para acceder a su contenido y realizar una comparación entre el valor asignado a una variable de comparación (numeroMayor) y el valor de cada posición del array (nombre_array[i]). En cada vuelta asignamos el mayor valor de los dos a la variable de comparación y guardamos la posición en la que está (posicionMayor). En la primera vuelta suponemos que el valor mayor está en la primera posición. Por lo tanto, necesitamos crear dos variables temporales; una del tipo de dato del contenido del array para hacer la comparación y otra de tipo entero para almacenar el valor de la posición. La sintaxis genérica sería:

tipo_dato_array numeroMayor;
int posicionMayor;
numeroMayor = nombre_array [0];
posicionMayor = 0
for (int contador = 1; contador  numeroMayor {
numeroMayor = nombre_array[i];
posicionMayor = x;
}
}

Un simple cambio nos permite obtener el valor menor de todos los almacenados en un array. Si se usa en un mismo método hay que tener cuidado con el nombre de las variables.

tipo_dato_array numeroMayor;
int posicionMenor;
numeroMenor = nombre_array [0];
posicionMenor = 0
for (int contador = 1; contador  nombre_array.length, contador++{
	if (nombre_array[i]  numeroMenor {
numeroMenor = nombre_array[i];
posicionMenor = x;
}
}

Un ejemplo completo es el siguiente código mediante el cual se crea un array que contendrá una serie de números y después se muestran por línea de comandos:

class ArrayDemo {
    public static void main(String[] args) {
        // declares an array of integers
        int[] anArray;

        // allocates memory for 10 integers
        anArray = new int[10];
           
        // initialize first element
        anArray[0] = 100;
        // initialize second element
        anArray[1] = 200;
        // and so forth
        anArray[2] = 300;
        anArray[3] = 400;
        anArray[4] = 500;
        anArray[5] = 600;
        anArray[6] = 700;
        anArray[7] = 800;
        anArray[8] = 900;
        anArray[9] = 1000;

        System.out.println("Element at index 0: "
                           + anArray[0]);
        System.out.println("Element at index 1: "
                           + anArray[1]);
        System.out.println("Element at index 2: "
                           + anArray[2]);
        System.out.println("Element at index 3: "
                           + anArray[3]);
        System.out.println("Element at index 4: "
                           + anArray[4]);
        System.out.println("Element at index 5: "
                           + anArray[5]);
        System.out.println("Element at index 6: "
                           + anArray[6]);
        System.out.println("Element at index 7: "
                           + anArray[7]);
        System.out.println("Element at index 8: "
                           + anArray[8]);
        System.out.println("Element at index 9: "
                           + anArray[9]);
    }
} 
Curso de Java – Tema 26.1: qué es una colección y qué tipos existen | Curso de Java – Tema 26.3: Arrays bidimensionales o matrices
Curso de Java - Índice Ejercicios Nivel Medio

Escribir un comentario

Aunque los comentarios no expresan la opinión del administrador del sitio web, éste si que tiene una responsabilidad legal sobre lo que aparece. Por lo tanto, habrá una labor de moderación de los mensajes. No se permitirán mensajes ofensivos ni publicidad


Código de seguridad
Refescar

Solicitamos su permiso para obtener datos estadísticos de su navegación en esta web, en cumplimiento del Real Decreto-Ley 13/2012, de 30 de marzo. Si continúa navegando consideramos que acepta el uso de cookies. . Más información