Arrays y ArrayLists en Java

JavaJavaBeginner
Practicar Ahora

💡 Este tutorial está traducido por IA desde la versión en inglés. Para ver la versión original, puedes hacer clic aquí

Introducción

En este laboratorio, profundizaremos en dos estructuras de datos fundamentales en Java: Arrays y ArrayLists. Estas estructuras nos permiten almacenar y manipular colecciones de datos, lo cual es crucial para muchas tareas de programación. Comenzaremos con el array básico y luego pasaremos al ArrayList más flexible. Al final de este laboratorio, podrás crear, manipular y trabajar con tanto arrays como ArrayLists en Java.

Cubriremos:

  1. Creación y uso de arrays
  2. Acceso y modificación de elementos de un array
  3. Introducción a los ArrayLists
  4. Adición, eliminación y acceso a elementos en ArrayLists
  5. Conversión entre arrays y ArrayLists

¡Comencemos a organizar nuestros datos!


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL java(("Java")) -.-> java/BasicSyntaxGroup(["Basic Syntax"]) java(("Java")) -.-> java/DataStructuresGroup(["Data Structures"]) java(("Java")) -.-> java/ObjectOrientedandAdvancedConceptsGroup(["Object-Oriented and Advanced Concepts"]) java/BasicSyntaxGroup -.-> java/data_types("Data Types") java/BasicSyntaxGroup -.-> java/variables("Variables") java/DataStructuresGroup -.-> java/arrays("Arrays") java/DataStructuresGroup -.-> java/arrays_methods("Arrays Methods") java/DataStructuresGroup -.-> java/collections_methods("Collections Methods") java/ObjectOrientedandAdvancedConceptsGroup -.-> java/arraylist("ArrayList") java/ObjectOrientedandAdvancedConceptsGroup -.-> java/generics("Generics") subgraph Lab Skills java/data_types -.-> lab-413820{{"Arrays y ArrayLists en Java"}} java/variables -.-> lab-413820{{"Arrays y ArrayLists en Java"}} java/arrays -.-> lab-413820{{"Arrays y ArrayLists en Java"}} java/arrays_methods -.-> lab-413820{{"Arrays y ArrayLists en Java"}} java/collections_methods -.-> lab-413820{{"Arrays y ArrayLists en Java"}} java/arraylist -.-> lab-413820{{"Arrays y ArrayLists en Java"}} java/generics -.-> lab-413820{{"Arrays y ArrayLists en Java"}} end

Creación y uso de arrays

Los arrays son una estructura de datos fundamental en Java que te permite almacenar múltiples elementos del mismo tipo. Imagina un array como una fila de cajas, donde cada caja puede contener un elemento de un tipo específico.

  1. Abramos el archivo llamado ArrayDemo.java en el directorio de tu proyecto.

    public class ArrayDemo {
        public static void main(String[] args) {
            // We'll add our code here
        }
    }

    Esta es la estructura básica de nuestro programa Java. El método main es donde comienza la ejecución de nuestro programa.

  2. Ahora, declaremos e inicialicemos un array de enteros. Agreguemos la siguiente línea dentro del método main:

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

    Esta línea crea un array de enteros llamado numbers e inicializa sus valores con 1, 2, 3, 4 y 5. Los corchetes [] le indican a Java que numbers es un array.

  3. Imprimamos los elementos de nuestro array. Agreguemos estas líneas después de la declaración del array:

    System.out.println("The elements of the array are:");
    for (int i = 0; i < numbers.length; i++) {
        System.out.println("Element at index " + i + ": " + numbers[i]);
    }

    Este código utiliza un bucle for para iterar a través del array. numbers.length nos da el tamaño del array, y numbers[i] accede al elemento en el índice i.

Java array elements output
  1. Guardemos el archivo, luego compilemos y ejecutemos el programa:

    javac ~/project/ArrayDemo.java
    java -cp ~/project ArrayDemo

    Deberías ver una salida similar a esta:

    The elements of the array are:
    Element at index 0: 1
    Element at index 1: 2
    Element at index 2: 3
    Element at index 3: 4
    Element at index 4: 5
  2. Ahora, calculemos la suma de todos los elementos del array. Agreguemos este código después del bucle anterior:

    int sum = 0;
    for (int number : numbers) {
        sum += number;
    }
    System.out.println("The sum of the elements is: " + sum);

    Este código utiliza un bucle for mejorado (también conocido como bucle for-each) para iterar a través del array. Es una forma más sencilla de recorrer todos los elementos cuando no necesitas el índice.

  3. Finalmente, encontremos el valor máximo en el array. Agreguemos este código:

    int max = numbers[0];
    for (int i = 1; i < numbers.length; i++) {
        if (numbers[i] > max) {
            max = numbers[i];
        }
    }
    System.out.println("The maximum value in the array is: " + max);

    Este código comienza asumiendo que el primer elemento es el máximo, luego compara cada elemento subsiguiente con el máximo actual y actualiza el máximo si se encuentra un valor más grande.

  4. Guardemos, compilemos y ejecutemos el programa de nuevo. Deberías ver la salida adicional:

    The sum of the elements is: 15
    The maximum value in the array is: 5
Java array output example
  1. Los arrays en Java tienen un tamaño fijo, pero podemos modificar sus elementos. Cambiemos un elemento e imprimamos el array modificado. Agreguemos este código al final del método main:

    numbers[2] = 10;
    System.out.println("\nAfter modifying the third element:");
    for (int number : numbers) {
        System.out.print(number + " ");
    }
    System.out.println();

    Esto cambia el valor del tercer elemento (índice 2) a 10 y luego imprime el array modificado.

  2. Guardemos, compilemos y ejecutemos el programa una vez más. Deberías ver la salida adicional:

    After modifying the third element:
    1 2 10 4 5

¡Felicidades! Ahora has creado un array, accedido a sus elementos, realizado cálculos con sus valores y modificado un elemento. Recuerda, los arrays en Java tienen un tamaño fijo, lo que significa que una vez que creas un array, no puedes cambiar su longitud. Sin embargo, puedes cambiar los valores de sus elementos.

Introducción a los ArrayLists

Ahora que hemos trabajado con arrays, introduzcamos los ArrayLists. Los ArrayLists son parte del Java Collections Framework y proporcionan una forma más flexible de trabajar con listas de objetos. A diferencia de los arrays, los ArrayLists pueden crecer o reducir su tamaño de forma dinámica.

  1. Abre el archivo llamado ArrayListDemo.java en el directorio de tu proyecto.

    import java.util.ArrayList;
    
    public class ArrayListDemo {
        public static void main(String[] args) {
            // We'll add our code here
        }
    }

    Observa la declaración import en la parte superior. Esto le dice a Java que queremos usar la clase ArrayList en nuestro programa.

  2. Ahora, creemos un ArrayList de Strings. Agrega esta línea dentro del método main:

    ArrayList<String> fruits = new ArrayList<>();

    Esto crea un ArrayList vacío que puede contener objetos String. La parte <String> se llama "genérico" y especifica el tipo de elementos que contendrá el ArrayList.

  3. Agreguemos algunos elementos a nuestro ArrayList. Agrega estas líneas:

    fruits.add("Apple");
    fruits.add("Banana");
    fruits.add("Cherry");

    El método add() agrega elementos al final de la lista.

  4. Ahora, imprimamos nuestro ArrayList. Agrega este código:

    System.out.println("Fruits in the list:");
    for (String fruit : fruits) {
        System.out.println(fruit);
    }

    Esto utiliza un bucle for mejorado para iterar a través del ArrayList, similar a lo que hicimos con los arrays.

    Consejo: Puedes compilar y ejecutar tu programa en cualquier momento para ver la salida. O bien, puedes seguir agregando más código y ejecutarlo todo al final.

  5. Los ArrayLists tienen muchos métodos útiles. Probemos algunos. Agrega este código:

    System.out.println("\nNumber of fruits: " + fruits.size());
    System.out.println("The second fruit is: " + fruits.get(1));

    size() devuelve el número de elementos en el ArrayList, y get(index) recupera el elemento en el índice especificado.

  6. También podemos reemplazar elementos en un ArrayList utilizando el método set(). Agrega este código:

    // Before: [Apple, Banana, Cherry]
    fruits.set(1, "Blueberry");    // Replaces "Banana" with "Blueberry"
    System.out.println("\nAfter replacing the second fruit:");
    System.out.println(fruits);     // [Apple, Blueberry, Cherry]

    set(index, element) reemplaza el elemento en el índice especificado con un nuevo elemento. El tamaño del ArrayList permanece igual.

  7. A diferencia de los arrays, los ArrayLists nos permiten insertar elementos en cualquier posición utilizando el método add(index, element). Esto es diferente de set() que vimos anteriormente. Veamos cómo funciona add():

    // Before: [Apple, Blueberry, Cherry]
    fruits.add(1, "Blackberry");
    System.out.println("\nAfter inserting Blackberry at index 1:");
    System.out.println(fruits);
    // After: [Apple, Blackberry, Blueberry, Cherry]

    Entendamos lo que sucedió:

    • add(1, "Blackberry") inserta "Blackberry" en el índice 1
    • Los elementos existentes en el índice 1 y posteriores (Blueberry, Cherry) se desplazan automáticamente una posición a la derecha
    • El tamaño del ArrayList aumenta en 1
    • Esto es diferente de set() que reemplazaría el elemento existente sin desplazar ni cambiar el tamaño

    Para ayudar a visualizar la diferencia:

    // Using add(index, element) - inserts and shifts
    fruits.add(1, "Blackberry");    // [Apple, Blackberry, Blueberry, Cherry]
    
    // Using set(index, element) - replaces without shifting
    fruits.set(1, "Blackberry");    // [Apple, Blackberry, Cherry]
  8. También podemos eliminar elementos de un ArrayList. Agrega este código:

    fruits.remove("Cherry");
    System.out.println("\nAfter removing Cherry:");
    System.out.println(fruits);

    Esto elimina la primera aparición de "Cherry" del ArrayList. Cuando se elimina un elemento, los elementos posteriores se desplazan a la izquierda para llenar el espacio.

  9. Finalmente, comprobemos si ciertos elementos están en nuestro ArrayList:

    System.out.println("\nDoes the list contain Apple? " + fruits.contains("Apple"));
    System.out.println("Does the list contain Cherry? " + fruits.contains("Cherry"));

    El método contains() comprueba si el ArrayList contiene un elemento específico y devuelve un valor booleano.

  10. Guarda el archivo, luego compila y ejecuta el programa:

    javac ~/project/ArrayListDemo.java
    java -cp ~/project ArrayListDemo

    Deberías ver una salida similar a esta:

    Fruits in the list:
    Apple
    Banana
    Cherry
    
    Number of fruits: 3
    The second fruit is: Banana
    
    After replacing the second fruit:
    [Apple, Blueberry, Cherry]
    
    After inserting Blackberry at index 1:
    [Apple, Blackberry, Blueberry, Cherry]
    
    After removing Cherry:
    [Apple, Blackberry, Blueberry]
    
    Does the list contain Apple? true
    Does the list contain Cherry? false

¡Felicidades! Ahora has creado un ArrayList, agregado y eliminado elementos, accedido a elementos por índice y utilizado varios métodos de ArrayList. Has aprendido las diferencias importantes entre operaciones como add() que inserta y desplaza elementos, y set() que reemplaza elementos. Los ArrayLists ofrecen más flexibilidad que los arrays, ya que pueden crecer y reducirse según sea necesario. Esto los hace muy útiles cuando no sabes de antemano cuántos elementos trabajarás.

Conversión entre arrays y ArrayLists

A veces, es posible que necesites convertir entre arrays y ArrayLists. Java proporciona métodos convenientes para hacer esto. Exploremos cómo convertir un array en un ArrayList y viceversa.

  1. Abre el archivo llamado ConversionDemo.java en el directorio de tu proyecto.

    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    
    public class ConversionDemo {
        public static void main(String[] args) {
            // We'll add our code here
        }
    }

    Observa las declaraciones de importación en la parte superior. Estamos importando las clases que necesitaremos para nuestras conversiones.

  2. Comencemos convirtiendo un array en un ArrayList. Agrega este código dentro del método main:

    String[] colorArray = {"Red", "Green", "Blue"};
    List<String> colorList = Arrays.asList(colorArray);
    
    System.out.println("Array converted to ArrayList:");
    System.out.println(colorList);

    Arrays.asList() convierte un array en una List. Ten en cuenta que esto crea una lista de tamaño fijo respaldada por el array original.

  3. Modifiquemos el ArrayList y veamos qué sucede con el array original. Agrega este código:

    colorList.set(1, "Yellow");
    
    System.out.println("\nAfter modifying the ArrayList:");
    System.out.println(colorList);
    System.out.println("Original array after ArrayList modification:");
    System.out.println(Arrays.toString(colorArray));

    Arrays.toString() es un método conveniente para imprimir un array.

  4. Ahora, convertamos un ArrayList en un array. Agrega este código:

    ArrayList<Integer> numberList = new ArrayList<>();
    numberList.add(1);
    numberList.add(2);
    numberList.add(3);
    
    Integer[] numberArray = numberList.toArray(new Integer[0]);
    
    System.out.println("\nArrayList converted to array:");
    System.out.println(Arrays.toString(numberArray));

    Usamos el método toArray() de ArrayList para convertirlo en un array. Pasamos new Integer[0] como argumento, que actúa como una sugerencia para el tipo y el tamaño del array que se va a crear.

  5. Finalmente, modifiquemos el array y veamos si afecta al ArrayList. Agrega este código:

    numberArray[0] = 100;
    System.out.println("\nAfter modifying the array:");
    System.out.println("Array: " + Arrays.toString(numberArray));
    System.out.println("ArrayList: " + numberList);
  6. Guarda el archivo, luego compila y ejecuta el programa:

    javac ~/project/ConversionDemo.java
    java -cp ~/project ConversionDemo

    Deberías ver una salida similar a esta:

    Array converted to ArrayList:
    [Red, Green, Blue]
    
    After modifying the ArrayList:
    [Red, Yellow, Blue]
    Original array after ArrayList modification:
    [Red, Yellow, Blue]
    
    ArrayList converted to array:
    [1, 2, 3]
    
    After modifying the array:
    Array: [100, 2, 3]
    ArrayList: [1, 2, 3]

Esta demostración muestra cómo se pueden convertir arrays y ArrayLists entre sí. Es importante tener en cuenta la diferencia en el comportamiento:

  • Cuando conviertes un array en una List usando Arrays.asList(), la List resultante está respaldada por el array original. Esto significa que los cambios en la List se reflejarán en el array y viceversa.
  • Cuando conviertes un ArrayList en un array usando toArray(), creas un nuevo array que es independiente del ArrayList. Los cambios en este nuevo array no afectarán al ArrayList original.

Comprender estas conversiones y su comportamiento es crucial cuando se trabaja con diferentes tipos de colecciones en Java, especialmente cuando se interactúa con APIs o bibliotecas que pueden preferir un tipo sobre el otro.

Resumen

En este laboratorio, hemos explorado dos estructuras de datos fundamentales en Java: Arrays y ArrayLists. Repasemos lo que hemos aprendido:

  1. Arrays:

    • Creamos e inicializamos arrays utilizando la sintaxis int[] numbers = {1, 2, 3, 4, 5};
    • Aprendimos cómo acceder a los elementos de un array utilizando la notación de índice, como numbers[0]
    • Iteramos a través de los arrays utilizando tanto bucles for tradicionales como bucles for mejorados
    • Realizamos cálculos con los elementos de los arrays, como encontrar la suma y el valor máximo
    • Vimos que los arrays tienen un tamaño fijo, pero podemos modificar sus elementos
  2. ArrayLists:

    • Creamos ArrayLists utilizando ArrayList<String> fruits = new ArrayList<>();
    • Aprendimos cómo agregar elementos con add(), eliminar elementos con remove() y acceder a elementos con get()
    • Utilizamos métodos como size(), set() y contains() para trabajar con ArrayLists
    • Vimos que los ArrayLists pueden crecer y reducirse dinámicamente, ofreciendo más flexibilidad que los arrays
  3. Conversión entre Arrays y ArrayLists:

    • Convertimos arrays en ArrayLists utilizando Arrays.asList()
    • Convertimos ArrayLists en arrays utilizando el método toArray()
    • Observamos los diferentes comportamientos al modificar las colecciones convertidas

Los arrays y los ArrayLists son herramientas esenciales en la programación Java. Los arrays son excelentes para trabajar con un número fijo de elementos y pueden ser más eficientes en términos de uso de memoria. Por otro lado, los ArrayLists ofrecen más flexibilidad y un conjunto amplio de métodos para manipular la colección.

A medida que continúes tu viaje en Java, encontrarás que utilizas tanto arrays como ArrayLists con frecuencia. La elección entre ellos a menudo depende de tus necesidades específicas: si conoces el número exacto de elementos con los que trabajarás, un array podría ser preferible. Si necesitas una colección dinámica que pueda crecer o reducirse, o si necesitas los métodos adicionales que proporcionan los ArrayLists, entonces un ArrayList sería la mejor opción.