Arrays en Java

Introducción

En este artículo, exploraremos en detalle los arrays en Java, una estructura de datos fundamental en la programación.

Aprenderemos cómo crear, manipular y aplicar arrays en programas Java, y entenderemos cómo nos permiten organizar y manejar conjuntos de datos de manera eficiente.

¿Qué es array en Java?

Un array en Java es una estructura de datos que permite almacenar una colección de elementos, todos del mismo tipo, en una única variable.

Los elementos de un array están organizados secuencialmente en memoria, y se pueden acceder a través de índices numéricos, comenzando por el índice 0 para el primer elemento, 1 para el segundo, y así sucesivamente.

Los arreglos son objetos en Java y tienen un tamaño fijo una vez que son creados. Sin embargo, existen otras estructuras de datos como ArrayList que permiten agregar y eliminar elementos dinámicamente.

Ventajas de utilizar arrays:

  • Permiten almacenar múltiples elementos del mismo tipo en una única variable.
  • Facilitan la organización y el manejo de conjuntos de datos relacionados.
  • Ofrecen un acceso rápido y eficiente a los elementos mediante índices numéricos.
  • Mejoran la legibilidad y la estructura del código al agrupar datos relacionados.

Algunos de los métodos más comunes en los arreglos son:

  • length: devuelve el número de elementos en el arreglo.
  • sort: ordena los elementos del arreglo.
  • fill: rellena el arreglo con un valor específico.
  • toString: devuelve una representación en cadena del arreglo.

Creación de arrays en Java

Crear un array en Java implica tres pasos: declarar la variable del array, asignarle memoria y, opcionalmente, inicializar sus elementos. Veamos cada uno de estos pasos con ejemplos detallados.

a) Declaración de arrays

Para declarar un array, utilizamos la siguiente sintaxis: tipo_de_dato[] nombre_del_array;

Ejemplo:


int[] numeros; // Declarando un array de enteros llamado "numeros"
String[] palabras; // Declarando un array de cadenas llamado "palabras"

Lenguaje del código: Java (java)

b) Asignación de memoria

Después de declarar el array, es necesario asignarle memoria, especificando su tamaño con la palabra clave new. La sintaxis es: nombre_del_array = new tipo_de_dato[tamaño];

Ejemplo:


numeros = new int[5]; // Asignando memoria para 5 elementos enteros en el array "numeros"
palabras = new String[3]; // Asignando memoria para 3 elementos de cadena en el array "palabras"

Lenguaje del código: Java (java)

También podemos declarar y asignar memoria en una sola línea:


int[] numeros = new int[5]; // Declarando y asignando memoria al array "numeros"
String[] palabras = new String[3]; // Declarando y asignando memoria al array "palabras"

Lenguaje del código: Java (java)

c) Inicialización de arrays

Podemos inicializar los elementos del array de varias maneras. A continuación, se presentan algunas de ellas:

  1. Inicialización individual de elementos:

numeros[0] = 10; // Asignando el valor 10 al primer elemento del array "numeros"
numeros[1] = 20; // Asignando el valor 20 al segundo elemento
// ...
palabras[0] = "Hola"; // Asignando la cadena "Hola" al primer elemento del array "palabras"
palabras[1] = "Mundo"; // Asignando la cadena "Mundo" al segundo elemento
// ...

Lenguaje del código: Java (java)
  1. Inicialización durante la declaración:

int[] numeros = {1, 2, 3, 4, 5}; // Declarando, asignando memoria e inicializando el array "numeros" con valores
String[] palabras = {"Java", "Array", "Ejemplo"}; // Declarando, asignando memoria e inicializando el array "palabras" con cadenas

Lenguaje del código: Java (java)
  1. Inicialización usando bucles:

for (int i = 0; i < numeros.length; i++) {
    numeros[i] = i * 10; // Asignando valores múltiplos de 10 a los elementos del array "numeros"
}

for (int i = 0; i < palabras.length; i++) {
    palabras[i] = "Palabra " + (i + 1); // Asignando "Palabra 1", "Palabra 2", ... a los elementos del array "palabras"
}

Lenguaje del código: Java (java)

La creación de un array en Java implica declarar la variable del array, asignarle memoria y, opcionalmente, inicializar sus elementos. La comprensión de estos pasos es fundamental para trabajar con arrays y organizar datos en nuestros programas de manera eficiente.

Tipos de arrays en Java

En Java, podemos crear arrays de diferentes tipos, como arrays de tipos primitivos, arrays de objetos y clases, y arrays multidimensionales.

A continuación, se presenta una descripción de cada uno de estos tipos, junto con ejemplos detallados.

a) Arrays de tipos primitivos

Los arrays de tipos primitivos permiten almacenar elementos de tipos básicos como int, double, char, boolean, etc.

Estos son algunos ejemplos:


int[] numeros = new int[5]; // Array de enteros
double[] precios = new double[3]; // Array de números decimales (double)
char[] letras = new char[10]; // Array de caracteres
boolean[] banderas = new boolean[2]; // Array de valores booleanos (verdadero/falso)

Lenguaje del código: Java (java)

b) Arrays de objetos y clases

Los arrays de objetos y clases permiten almacenar elementos que son instancias de clases personalizadas o clases predefinidas de Java, como String, Integer, Double, etc.

Ejemplo – Array de objetos de la clase String:


String[] nombres = new String[4]; // Array de objetos de la clase String
nombres[0] = "Alice";
nombres[1] = "Bob";
nombres[2] = "Carol";
nombres[3] = "David";

Lenguaje del código: Java (java)

Ejemplo – Array de objetos de una clase personalizada (Estudiante):


class Estudiante {
    String nombre;
    int edad;

    Estudiante(String nombre, int edad) {
        this.nombre = nombre;
        this.edad = edad;
    }
}

// Creación de un array de objetos de la clase Estudiante
Estudiante[] estudiantes = new Estudiante[3];
estudiantes[0] = new Estudiante("Juan", 20);
estudiantes[1] = new Estudiante("Ana", 22);
estudiantes[2] = new Estudiante("Luis", 19);

Lenguaje del código: Java (java)

c) Arrays multidimensionales

Los arrays multidimensionales son arrays cuyos elementos son, a su vez, otros arrays. El caso más común es el array bidimensional, también conocido como matriz.

Ejemplo – Array bidimensional de enteros (matriz de enteros):


int[][] matriz = new int[3][4]; // Creación de una matriz de 3 filas y 4 columnas

// Inicialización de la matriz con valores
matriz[0][0] = 1;
matriz[0][1] = 2;
matriz[0][2] = 3;
matriz[0][3] = 4;
matriz[1][0] = 5;
// ...

// Inicialización de la matriz con bucles
for (int i = 0; i < matriz.length; i++) {
    for (int j = 0; j < matriz[i].length; j++) {
        matriz[i][j] = (i * matriz[i].length) + j + 1;
    }
}

Lenguaje del código: Java (java)

Ejemplo – Array bidimensional de objetos de la clase String:


String[][] tablero = new String[3][3]; // Creación de un tablero de 3x3 para un juego de tres en raya

// Inicialización del tablero con guiones
for (int i = 0; i < tablero.length; i++) {
    for (int j = 0; j < tablero[i].length; j++) {
        tablero[i][j] = "-";
    }
}

// Imprimir el tablero en la consola
for (int i = 0; i < tablero.length; i++) {
    for (int j = 0; j < tablero[i].length; j++) {
        System.out.print(tablero[i][j] + " ");
    }
    System.out.println();
}

Lenguaje del código: Java (java)

Este ejemplo crea un tablero de 3×3 para un juego de tres en raya utilizando un array bidimensional de objetos de la clase String. Luego, inicializa el tablero con guiones y lo imprime en la consola.

Acceso a elementos de un array en Java

Para acceder a los elementos de un array en Java, utilizamos índices numéricos. Los índices en un array comienzan en 0 para el primer elemento, 1 para el segundo y así sucesivamente hasta la longitud del array menos 1 para el último elemento.

A continuación, se muestran ejemplos de cómo acceder a los elementos de diferentes tipos de arrays.

a) Acceso a elementos de un array de tipos primitivos


int[] numeros = {10, 20, 30, 40, 50};

int primerNumero = numeros[0]; // Accediendo al primer elemento del array
int segundoNumero = numeros[1]; // Accediendo al segundo elemento del array
int ultimoNumero = numeros[numeros.length - 1]; // Accediendo al último elemento del array

System.out.println("Primer número: " + primerNumero);
System.out.println("Segundo número: " + segundoNumero);
System.out.println("Último número: " + ultimoNumero);

Lenguaje del código: Java (java)

b) Acceso a elementos de un array de objetos y clases


String[] nombres = {"Alice", "Bob", "Carol", "David"};

String primerNombre = nombres[0]; // Accediendo al primer elemento del array
String segundoNombre = nombres[1]; // Accediendo al segundo elemento del array
String ultimoNombre = nombres[nombres.length - 1]; // Accediendo al último elemento del array

System.out.println("Primer nombre: " + primerNombre);
System.out.println("Segundo nombre: " + segundoNombre);
System.out.println("Último nombre: " + ultimoNombre);

Lenguaje del código: Java (java)

c) Acceso a elementos de un array multidimensional


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

int primerElemento = matriz[0][0]; // Accediendo al primer elemento de la matriz
int elementoCentral = matriz[1][1]; // Accediendo al elemento central de la matriz
int ultimoElemento = matriz[matriz.length - 1][matriz[0].length - 1]; // Accediendo al último elemento de la matriz

System.out.println("Primer elemento: " + primerElemento);
System.out.println("Elemento central: " + elementoCentral);
System.out.println("Último elemento: " + ultimoElemento);

Lenguaje del código: Java (java)

Obtener la longitud de un array

Para obtener la longitud de un array (es decir, la cantidad de elementos que contiene), utilizamos la propiedad length.

Ejemplo:


int[] numeros = {10, 20, 30, 40, 50};
int longitud = numeros.length; // Obteniendo la longitud del array "numeros"

System.out.println("La longitud del array 'numeros' es: " + longitud);

Lenguaje del código: Java (java)

Para obtener la longitud de un array multidimensional, aplicamos la propiedad length a las dimensiones correspondientes.

Ejemplo:


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

int filas = matriz.length; // Obteniendo el número de filas de la matriz
int columnas = matriz[0].length; // Obteniendo el número de columnas de la matriz

System.out.println("La matriz tiene " + filas + " filas y " + columnas + " columnas.");

Lenguaje del código: Java (java)

Este ejemplo muestra cómo obtener la cantidad de filas y columnas en una matriz (array bidimensional) utilizando la propiedad length. En este caso, la matriz tiene 3 filas y 3 columnas.

Manipulación de Arrays en Java

En esta sección, veremos cómo manipular arrays en Java a través de diversos ejemplos prácticos y bien documentados.

Recorrido de arrays usando bucles (for, for-each, while)

  • Bucle for:

int[] numeros = {1, 2, 3, 4, 5};

for (int i = 0; i < numeros.length; i++) {
    System.out.println("Elemento en el índice " + i + ": " + numeros[i]);
}

Lenguaje del código: Java (java)

En este ejemplo, utilizamos un bucle for para recorrer el array de números. La variable i representa el índice del elemento actual. Accedemos a cada elemento del array utilizando numeros[i].

  • Bucle for-each:

int[] numeros = {1, 2, 3, 4, 5};

for (int numero : numeros) {
    System.out.println("Elemento: " + numero);
}

Lenguaje del código: Java (java)

El bucle for-each es una alternativa más concisa para recorrer arrays. En lugar de trabajar con índices, procesamos directamente cada elemento del array. Sin embargo, no tenemos acceso al índice del elemento actual.

  • Bucle while:

int[] numeros = {1, 2, 3, 4, 5};
int i = 0;

while (i < numeros.length) {
    System.out.println("Elemento en el índice " + i + ": " + numeros[i]);
    i++;
}

Lenguaje del código: Java (java)

En este ejemplo, utilizamos un bucle while para recorrer el array de números. Es similar al bucle for, pero la estructura de control es ligeramente diferente.

Búsqueda y filtrado de elementos en un array

  • Búsqueda de elementos:

int[] numeros = {10, 25, 32, 45, 18};
int numeroBuscado = 32;
boolean encontrado = false;

for (int numero : numeros) {
    if (numero == numeroBuscado) {
        encontrado = true;
        break;
    }
}

if (encontrado) {
    System.out.println("El número " + numeroBuscado + " está en el array.");
} else {
    System.out.println("El número " + numeroBuscado + " no se encuentra en el array.");
}

Lenguaje del código: Java (java)

En este ejemplo, buscamos un número específico en el array. Si lo encontramos, cambiamos el valor de la variable booleana encontrado a true y salimos del bucle.

  • Filtrado de elementos:

int[] numeros = {10, 25, 32, 45, 18};
int limite = 30;
ArrayList<Integer> filtrados = new ArrayList<>();

for (int numero : numeros) {
    if (numero > limite) {
        filtrados.add(numero);
    }
}

System.out.println("Números mayores a " + limite + ": " + filtrados);

Lenguaje del código: Java (java)

En este ejemplo, filtramos los números mayores a un límite específico utilizando un ArrayList para almacenar los elementos que cumplen con la condición.

Modificación y eliminación de elementos en un array

  • Modificación de elementos:

int[] numeros = {1, 2, 3, 4, 5};

for (int i = 0; i < numeros.length; i++) {
    numeros[i] *= 2;
}

System.out.println("Array modificado: " + Arrays.toString(numeros));

Lenguaje del código: Java (java)

En este ejemplo, modificamos cada elemento del array de números multiplicándolos por 2. Usamos un bucle for para acceder a cada elemento del array por su índice y actualizar su valor.

  • Eliminación de elementos:

Dado que los arrays en Java tienen una longitud fija, no es posible eliminar directamente un elemento de un array. Sin embargo, podemos crear un nuevo array sin el elemento que deseamos eliminar. En este caso, utilizaremos un ArrayList como estructura intermedia para facilitar el proceso.


int[] numeros = {1, 2, 3, 4, 5};
int numeroAEliminar = 3;
ArrayList<Integer> listaNumeros = new ArrayList<>();

for (int numero : numeros) {
    if (numero != numeroAEliminar) {
        listaNumeros.add(numero);
    }
}

int[] numerosActualizados = new int[listaNumeros.size()];
for (int i = 0; i < listaNumeros.size(); i++) {
    numerosActualizados[i] = listaNumeros.get(i);
}

System.out.println("Array original: " + Arrays.toString(numeros));
System.out.println("Array sin el número " + numeroAEliminar + ": " + Arrays.toString(numerosActualizados));

Lenguaje del código: Java (java)

En este ejemplo, creamos un ArrayList para almacenar los elementos del array original, excepto el número que deseamos eliminar. Luego, creamos un nuevo array de la longitud correcta y copiamos los elementos del ArrayList en el nuevo array.

Ten en cuenta que este enfoque no es el más eficiente, especialmente para arrays grandes. Si necesitas trabajar con estructuras de datos dinámicas, es recomendable utilizar ArrayLists u otras colecciones en lugar de arrays.

Arrays y funciones en Java

En esta sección, exploraremos cómo utilizar arrays en combinación con funciones en Java a través de ejemplos prácticos y bien documentados.

  • Pasar arrays como argumentos a funciones

public class ArrayFunctions {
    public static void main(String[] args) {
        int[] numeros = {1, 2, 3, 4, 5};
        imprimirArray(numeros);
    }

    public static void imprimirArray(int[] array) {
        for (int numero : array) {
            System.out.print(numero + " ");
        }
        System.out.println();
    }
}

Lenguaje del código: Java (java)

En este ejemplo, creamos una función llamada imprimirArray que recibe un array de enteros como argumento. Luego, llamamos a esta función desde el método main y le pasamos el array numeros. La función imprimirArray imprime cada elemento del array en una línea.

  • Retornar arrays desde funciones

public class ArrayFunctions {
    public static void main(String[] args) {
        int[] numeros = {1, 2, 3, 4, 5};
        int[] numerosDobles = duplicarElementos(numeros);

        System.out.println("Array original: " + Arrays.toString(numeros));
        System.out.println("Array con elementos duplicados: " + Arrays.toString(numerosDobles));
    }

    public static int[] duplicarElementos(int[] array) {
        int[] resultado = new int[array.length];

        for (int i = 0; i < array.length; i++) {
            resultado[i] = array[i] * 2;
        }

        return resultado;
    }
}

Lenguaje del código: Java (java)

En este ejemplo, creamos una función llamada duplicarElementos que recibe un array de enteros y retorna un nuevo array con cada elemento duplicado.

Desde el método main, llamamos a esta función y le pasamos el array numeros. La función duplicarElementos crea un nuevo array llamado resultado, llena el array con los elementos duplicados y lo retorna.

  • Ejemplo de función con arrays multidimensionales

public class ArrayFunctions {
    public static void main(String[] args) {
        int[][] matriz = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };

        imprimirMatriz(matriz);
    }

    public static void imprimirMatriz(int[][] matriz) {
        for (int i = 0; i < matriz.length; i++) {
            for (int j = 0; j < matriz[i].length; j++) {
                System.out.print(matriz[i][j] + " ");
            }
            System.out.println();
        }
    }
}

Lenguaje del código: Java (java)

En este ejemplo, trabajamos con un array bidimensional, también conocido como matriz. Creamos una función llamada imprimirMatriz que recibe una matriz de enteros como argumento y la imprime en un formato tabular. Luego, llamamos a esta función desde el método main y le pasamos la matriz matriz.

Clases y métodos de utilidad para trabajar con Arrays

La clase java.util.Arrays proporciona varios métodos de utilidad que facilitan el manejo y la manipulación de arrays en Java.

A continuación, se presentan algunos ejemplos prácticos y bien documentados de cómo utilizar estos métodos en programas Java.

Método toString()

El método toString() se utiliza para convertir un array en una representación de cadena legible. Este método es útil cuando queremos imprimir o mostrar el contenido de un array.

Ejemplo:


import java.util.Arrays;

public class ArrayExample {
    public static void main(String[] args) {
        int[] numbers = {4, 7, 2, 8, 1};
        System.out.println("Array original: " + Arrays.toString(numbers));
    }
}

Lenguaje del código: Java (java)

Método sort()

El método sort() se utiliza para ordenar elementos de un array en orden ascendente. Este método es útil cuando necesitamos organizar los datos de un array en un orden específico.

Ejemplo:


import java.util.Arrays;

public class ArrayExample {
    public static void main(String[] args) {
        int[] numbers = {4, 7, 2, 8, 1};
        Arrays.sort(numbers);
        System.out.println("Array ordenado: " + Arrays.toString(numbers));
    }
}

Lenguaje del código: Java (java)

Método equals()

El método equals() se utiliza para comparar dos arrays y determinar si son iguales. Dos arrays son iguales si contienen el mismo número de elementos y todos los elementos correspondientes en los dos arrays son iguales.

Ejemplo:


import java.util.Arrays;

public class ArrayExample {
    public static void main(String[] args) {
        int[] array1 = {4, 7, 2, 8, 1};
        int[] array2 = {4, 7, 2, 8, 1};
        int[] array3 = {1, 2, 7, 4, 8};

        boolean isEqual = Arrays.equals(array1, array2);
        System.out.println("¿Son array1 y array2 iguales? " + isEqual);

        isEqual = Arrays.equals(array1, array3);
        System.out.println("¿Son array1 y array3 iguales? " + isEqual);
    }
}

Lenguaje del código: Java (java)

Método fill()

El método fill() se utiliza para asignar un valor específico a todos los elementos de un array. Este método es útil cuando necesitamos inicializar un array con un valor predeterminado.

Ejemplo:


import java.util.Arrays;

public class ArrayExample {
    public static void main(String[] args) {
        int[] numbers = new int[5];
        Arrays.fill(numbers, 42);
        System.out.println("Array lleno de 42s: " + Arrays.toString(numbers));
    }
}

Lenguaje del código: Java (java)

Método copyOf()

El método copyOf() se utiliza para crear una copia de un array con una longitud específica. Este método es útil cuando necesitamos duplicar un array o ajustar su tamaño.

Ejemplo:


import java.util.Arrays;

public class ArrayExample {
    public static void main(String[] args) {
        int[] originalArray = {4, 7, 2, 8, 1};
        int[] copiedArray = Arrays.copyOf(originalArray, originalArray.length);
        System.out.println("Copia del array original: " + Arrays.toString(copiedArray));
    }
}

Lenguaje del código: Java (java)

Método binarySearch()

El método binarySearch() se utiliza para buscar un elemento en un array ordenado. Este método utiliza el algoritmo de búsqueda binaria, lo que significa que es muy eficiente en términos de tiempo de ejecución.

Devuelve el índice del elemento buscado si se encuentra, de lo contrario, devuelve un valor negativo.

Ejemplo:


import java.util.Arrays;

public class ArrayExample {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 4, 7, 8};
        int target = 7;
        int index = Arrays.binarySearch(numbers, target);
        
        if (index >= 0) {
            System.out.println("Elemento " + target + " encontrado en el índice: " + index);
        } else {
            System.out.println("Elemento " + target + " no encontrado en el array.");
        }
    }
}

Lenguaje del código: Java (java)

Método deepEquals()

El método deepEquals() se utiliza para comparar dos arrays multidimensionales y determinar si son iguales.

Dos arrays multidimensionales son iguales si contienen el mismo número de elementos en cada dimensión y todos los elementos correspondientes en los dos arrays son iguales.

Ejemplo:


import java.util.Arrays;

public class ArrayExample {
    public static void main(String[] args) {
        int[][] matrix1 = {{1, 2}, {3, 4}};
        int[][] matrix2 = {{1, 2}, {3, 4}};
        int[][] matrix3 = {{4, 3}, {2, 1}};

        boolean isEqual = Arrays.deepEquals(matrix1, matrix2);
        System.out.println("¿Son matrix1 y matrix2 iguales? " + isEqual);

        isEqual = Arrays.deepEquals(matrix1, matrix3);
        System.out.println("¿Son matrix1 y matrix3 iguales? " + isEqual);
    }
}

Lenguaje del código: Java (java)

Método deepToString()

El método deepToString() se utiliza para convertir un array multidimensional en una representación de cadena legible. Este método es útil cuando queremos imprimir o mostrar el contenido de un array multidimensional.

Ejemplo:


import java.util.Arrays;

public class ArrayExample {
    public static void main(String[] args) {
        int[][] matrix = {{1, 2}, {3, 4}, {5, 6}};
        System.out.println("Array multidimensional: " + Arrays.deepToString(matrix));
    }
}

Lenguaje del código: Java (java)

Estos ejemplos ilustran cómo los métodos de utilidad proporcionados por la clase java.util.Arrays pueden facilitar el trabajo con arrays en Java.

Familiarizarse con estos métodos y aplicarlos en situaciones adecuadas puede mejorar significativamente la eficiencia y la legibilidad de nuestros programas.

Arraylists: una alternativa dinámica a los Arrays

Los arrays en Java son estructuras de datos de tamaño fijo, lo que significa que una vez creados, no se pueden cambiar en tamaño. Aunque son útiles en muchos casos, a veces necesitamos estructuras de datos más flexibles y dinámicas.

Aquí es donde entran las ArrayLists, que son parte del framework de Colecciones de Java y ofrecen un enfoque más dinámico para manejar conjuntos de datos.

Introducción a las colecciones y la clase java.util.ArrayList

Java ofrece un conjunto de clases e interfaces predefinidas en su framework de Colecciones, que nos permite manejar grupos de objetos de manera eficiente y flexible.

Una de estas clases es ArrayList, que es una implementación de la interfaz List y proporciona una estructura de datos similar a un array, pero con capacidad para cambiar de tamaño de manera dinámica.

Creación y manipulación de ArrayLists

Para comenzar a utilizar ArrayLists en Java, primero debemos importar la clase java.util.ArrayList. Luego, podemos crear instancias de ArrayList y manipularlas utilizando sus métodos proporcionados.


import java.util.ArrayList;

public class EjemploArrayList {
    public static void main(String[] args) {
        // Creación de un ArrayList de Strings
        ArrayList<String> nombres = new ArrayList<>();

        // Añadir elementos al ArrayList
        nombres.add("Ana");
        nombres.add("Luis");
        nombres.add("Carlos");

        // Acceder a elementos del ArrayList
        String primerNombre = nombres.get(0); // Ana

        // Eliminar elementos del ArrayList
        nombres.remove(1); // Elimina "Luis"

        // Iterar sobre un ArrayList usando un bucle for-each
        for (String nombre : nombres) {
            System.out.println(nombre);
        }

        // Cambiar el valor de un elemento del ArrayList
        nombres.set(0, "Maria");

        // Obtener el tamaño de un ArrayList
        int tamaño = nombres.size(); // 2
    }
}

Lenguaje del código: Java (java)

Comparación entre Arrays y ArrayLists en Java

Ambos arrays y ArrayLists tienen sus ventajas y desventajas. A continuación, se presentan algunas diferencias clave:

  • Arrays:
    • Tamaño fijo: útil cuando se conoce el número exacto de elementos.
    • Rendimiento ligeramente mejor debido a la falta de métodos adicionales y administración de memoria.
    • Puede contener tipos de datos primitivos.
  • ArrayLists:
    • Tamaño dinámico: útil cuando se desconoce el número exacto de elementos o cuando se requiere cambiar el tamaño.
    • Rendimiento ligeramente inferior en comparación con los arrays debido a la administración adicional de memoria y métodos.
    • No puede contener tipos de datos primitivos directamente (utilizar clases envolventes como Integer, Double, etc.).

En general, es importante considerar las necesidades específicas de nuestro proyecto al decidir entre usar arrays o ArrayLists. Si requerimos una estructura de datos de tamaño fijo y un rendimiento óptimo, los arrays pueden ser una opción adecuada.

Sin embargo, si necesitamos una estructura de datos más flexible que pueda cambiar de tamaño dinámicamente, las ArrayLists serán una mejor opción.

Referencias

Aquí tienes una lista de recursos y referencias útiles para aprender más sobre Arrays en Java:

  1. Documentación oficial de Oracle sobre Arrays en Java:
  2. Blogs y sitios web:

Estos recursos cubren diferentes aspectos de los Arrays en Java y ofrecen ejemplos y ejercicios prácticos para mejorar tu comprensión del tema.

Asegúrate de estudiar estos recursos y practicar con ejercicios para familiarizarte completamente con el uso de Arrays en Java.