Concatenación eficiente de arrays en Java

Java no ofrece una operación integrada de concatenación de arrays. Dado que los arrays tienen un tamaño fijo, combinar dos arrays requiere crear un array nuevo más grande y copiar los elementos. Este artículo explora tres métodos efectivos para lograr esto.

Tabla de contenido

• Usando addAll() de Apache Commons Lang
• Aprovechando System.arraycopy()
• Concatenación manual con bucles

Usando addAll() de Apache Commons Lang

La librería Apache Commons Lang proporciona el conveniente método addAll() dentro de su clase ArrayUtils. Esto simplifica significativamente la concatenación de arrays. Primero, agrega la dependencia a tu proyecto (por ejemplo, usando Maven):

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.12.0</version> <!-- Usar la última versión -->
</dependency>

Luego, úsalo de la siguiente manera:

import org.apache.commons.lang3.ArrayUtils;

public class ArrayConcatenation {
    public static void main(String[] args) {
        int[] array1 = {1, 2, 3};
        int[] array2 = {4, 5, 6};

        int[] concatenatedArray = ArrayUtils.addAll(array1, array2);

        for (int i : concatenatedArray) {
            System.out.print(i + " "); // Salida: 1 2 3 4 5 6
        }
    }
}

Este enfoque es limpio y eficiente, pero introduce una dependencia externa.

Aprovechando System.arraycopy()

El System.arraycopy() integrado de Java proporciona una solución nativa. Este método copia una porción de un array a otro. Requiere la creación manual de arrays y la gestión de índices:

public class ArrayConcatenation {
    public static void main(String[] args) {
        int[] array1 = {1, 2, 3};
        int[] array2 = {4, 5, 6};

        int[] concatenatedArray = new int[array1.length + array2.length];

        System.arraycopy(array1, 0, concatenatedArray, 0, array1.length);
        System.arraycopy(array2, 0, concatenatedArray, array1.length, array2.length);

        for (int i : concatenatedArray) {
            System.out.print(i + " "); // Salida: 1 2 3 4 5 6
        }
    }
}

Este método es eficiente y evita bibliotecas externas, pero es menos conciso.

Concatenación manual con bucles

Un enfoque más explícito, aunque menos eficiente, implica iterar a través de ambos arrays y poblar un nuevo array:

public class ArrayConcatenation {
    public static void main(String[] args) {
        int[] array1 = {1, 2, 3};
        int[] array2 = {4, 5, 6};

        int[] concatenatedArray = new int[array1.length + array2.length];

        for (int i = 0; i < array1.length; i++) {
            concatenatedArray[i] = array1[i];
        }
        for (int i = 0; i < array2.length; i++) {
            concatenatedArray[array1.length + i] = array2[i];
        }

        for (int i : concatenatedArray) {
            System.out.print(i + " "); // Salida: 1 2 3 4 5 6
        }
    }
}

Este método es sencillo y fácil de entender, lo que lo hace adecuado para principiantes. Sin embargo, es menos eficiente que los otros métodos, especialmente para arrays grandes.

El enfoque óptimo depende de tus prioridades: addAll() ofrece concisión, arraycopy() proporciona eficiencia sin bibliotecas externas, y el bucle manual ofrece claridad. Recuerda ajustar el código para diferentes tipos de arrays (por ejemplo, String[], double[]).