Desliza para mostrar el menú

Arreglos

Almacenar información exclusivamente en variables no siempre es conveniente, ya que consumiría una cantidad significativa de memoria de pila y requeriría una gran cantidad de líneas de código.

La solución a este problema son los arreglos.

Exploremos la sintaxis básica para declarar un arreglo en Java:

Main.java


              1
            
dataType[] arrayName = new dataType[capacity];

Se puede utilizar cualquier tipo de dato al declarar un arreglo, incluyendo int, float, char y otros.

Es obligatorio especificar el tamaño del arreglo entre corchetes ([]). Consideremos un ejemplo de creación de un arreglo de tipo int con un tamaño de 5:

Main.java


              12345678910
            
package com.example;

public class Main {
    public static void main(String[] args) {
        // Declares a new int array with a length of 5
        int[] intArray = new int[5];
        // Prints the size of the array
        System.out.println(intArray.length);
    }
}

Como se puede observar, se utilizó algo nuevo con la salida en consola: una propiedad de arreglo.

Los arreglos tienen sus propias propiedades, a las cuales se accede utilizando la notación de punto (.). En el ejemplo, el arreglo intArray utiliza una de estas propiedades. La propiedad .length devuelve el tamaño del arreglo como un valor de tipo int. Esto también se puede escribir de otra manera:

Main.java


              123456789101112
            
package com.example;

public class Main {
    public static void main(String[] args) {
        // Declares a new int array with a length of 5
        int[] intArray = new int[5];
        // Declares a new int with the value of the array's size
        int length = intArray.length;
        // Prints the size of the array
        System.out.println(length);
    }
}

Ahora, examinemos tres métodos y propiedades fundamentales para trabajar con arreglos:

Arrays.sort(array): ordena los elementos del arreglo en orden ascendente;
Arrays.fill(array, value): asigna el valor especificado a todos los elementos del arreglo;
Arrays.toString(array): convierte el arreglo en una representación de cadena, facilitando la visualización de sus elementos.

Main.java


              1234567891011121314151617
            
package com.example;

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] array = {5, 2, 9, 1, 6};
        
        // Sort the array
        Arrays.sort(array);
        System.out.println("Sorted array: " + Arrays.toString(array));
        
        // Fill the array with the value 0
        Arrays.fill(array, 0);
        System.out.println("Array after filling: " + Arrays.toString(array));
    }
}

Primero, ordena el arreglo en orden ascendente utilizando Arrays.sort() y muestra el arreglo ordenado usando Arrays.toString(), que convierte el arreglo en un formato de cadena legible. Luego, todos los elementos del arreglo son reemplazados por 0 usando Arrays.fill(), y el arreglo actualizado se imprime en el mismo formato legible.

¿Cómo acceder a datos específicos en un arreglo?

Los arreglos en Java están indexados. Cada elemento del arreglo se encuentra en su celda y se le asigna un ID único. La numeración de los elementos dentro del arreglo comienza en 0. Supongamos que tenemos un arreglo de números del cero al nueve, por lo que contiene 10 elementos.

Analicemos un diagrama que ilustra cómo se organizan los elementos dentro del arreglo:

Si tenemos un arreglo con 10 elementos, el primer elemento se almacenará en el índice 0 y el último en el índice 9, porque la indexación comienza desde cero.

La práctica es siempre mejor que solo la teoría, así que exploremos un ejemplo de cómo agregar y eliminar elementos de un arreglo utilizando índices:

Main.java


              12345678910111213141516
            
package com.example;

public class Main {
    public static void main(String[] args) {
        // Declares a new int array with a length of 5
        int[] intArray = new int[5];
        // Fills the array with numbers from 1 to 5
        intArray[0] = 1;
        intArray[1] = 2;
        intArray[2] = 3;
        intArray[3] = 4;
        intArray[4] = 5;
        // Prints the fourth element of the array
        System.out.println(intArray[3]);
    }
}

Hemos llenado nuestro arreglo con elementos del uno al cinco especificando cada elemento con un índice. Sin embargo, este enfoque carece de elegancia y requiere muchas líneas de código. Exploremos un método alternativo para declarar un arreglo que ya viene prellenado:

Main.java


              12345678910
            
package com.example;

public class Main {
    public static void main(String[] args) {
        // Declares a new pre-filled int array with a length of 5
        int[] intArray = {1, 2, 3, 4, 5};
        // Prints the first element of the array
        System.out.println(intArray[0]);
    }
}