Manipulación con la clase Arrays

Manipulación de Arrays con la Clase Arrays de la API Estándar en Java

En Java, la clase Arrays ofrece una variedad de métodos estáticos para facilitar la manipulación de arrays. Esta clase proporciona métodos muy útiles para realizar operaciones como ordenar, buscar, copiar y rellenar arrays, entre otros. A continuación, veremos algunos de los métodos más importantes y cómo utilizarlos en la manipulación de arrays.

---

Método
Arrays.sort(array)	Ordena el array en orden ascendente
Arrays.binarySearch(array, key)	Realiza una búsqueda binaria en un array ordenado
Arrays.fill(array, value)	Llena un array con un valor específico
Arrays.copyOf(array, length)	Copia un array y ajusta su tamaño
Arrays.copyOfRange(array, start, end)	Copia un rango de elementos de un array
Arrays.equals(array1, array2)	Compara dos arrays
Arrays.deepEquals(array1, array2)	Compara dos arrays multidimensionales
Arrays.toString(array)	Convierte un array en una cadena
Arrays.deepToString(array)	Convierte un array multidimensional en una cadena

Arrays.sort()

El método Arrays.sort() permite ordenar los elementos de un array. Por defecto, ordena de menor a mayor si se trata de un array de tipos primitivos (como int, double, etc.), o de acuerdo con el orden natural de los objetos si se trata de arrays de objetos que implementan la interfaz Comparable.

Sintaxis:

Arrays.sort(array);

Ejemplo de ordenación de un array de enteros:

import java.util.Arrays;

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

        // Ordenar el array
        Arrays.sort(numbers);

        // Imprimir el array ordenado
        System.out.println(Arrays.toString(numbers));  // Salida: [1, 1, 2, 3, 4, 5, 6, 9]
    }
}

Arrays.binarySearch()

Este método permite buscar un elemento en un array ordenado, utilizando el algoritmo de búsqueda binaria. Si el elemento está presente, devuelve el índice de la primera ocurrencia, de lo contrario, devuelve un valor negativo.

Sintaxis:

int index = Arrays.binarySearch(array, key);

Ejemplo de búsqueda binaria:

import java.util.Arrays;

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

        // Buscar el elemento 4
        int index = Arrays.binarySearch(numbers, 4);

        // Imprimir el índice
        System.out.println(index);  // Salida: 3 (el índice del número 4 en el array)
    }

Arrays.fill()

El método Arrays.fill() se utiliza para llenar un array con un valor específico. Es útil cuando necesitas inicializar un array con un solo valor, ya sea en un array de tipos primitivos o en un array de objetos.

Sintaxis:

Arrays.fill(array, value);

Ejemplo de llenar un array:

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] numbers = new int[5];

        // Llenar el array con el valor 10
        Arrays.fill(numbers, 10);

        // Imprimir el array
        System.out.println(Arrays.toString(numbers));  // Salida: [10, 10, 10, 10, 10]
    }
}

Arrays.copyOf() y Arrays.copyOfRange()

• Arrays.copyOf() permite crear una copia de un array, y si el nuevo tamaño es mayor, rellena los elementos adicionales con el valor por defecto del tipo de datos.
• Arrays.copyOfRange() permite copiar una parte de un array especificando un rango de índices.

Sintaxis:

int[] newArray = Arrays.copyOf(originalArray, newLength);  // Copia todo el array
int[] subArray = Arrays.copyOfRange(originalArray, start, end);  // Copia un rango específico

Ejemplo de copia de un array:

import java.util.Arrays;

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

        // Copiar el array completo
        int[] copiedArray = Arrays.copyOf(numbers, 5);

        // Imprimir la copia
        System.out.println(Arrays.toString(copiedArray));  // Salida: [1, 2, 3, 4, 5]

        // Copiar un rango del array
        int[] rangeArray = Arrays.copyOfRange(numbers, 1, 4);

        // Imprimir la copia del rango
        System.out.println(Arrays.toString(rangeArray));  // Salida: [2, 3, 4]
    }
}

Arrays.equals() y Arrays.deepEquals()

• Arrays.equals() compara dos arrays de un solo nivel, verificando si tienen el mismo tamaño y si sus elementos son iguales.
• Arrays.deepEquals() es similar, pero se utiliza para arrays multidimensionales, ya que compara los elementos recursivamente.

Sintaxis:

boolean result = Arrays.equals(array1, array2);
boolean result = Arrays.deepEquals(array1, array2);

Ejemplo de comparación de arrays:

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] numbers1 = {1, 2, 3, 4, 5};
        int[] numbers2 = {1, 2, 3, 4, 5};
        int[] numbers3 = {5, 4, 3, 2, 1};

        // Comparar arrays
        System.out.println(Arrays.equals(numbers1, numbers2));  // Salida: true
        System.out.println(Arrays.equals(numbers1, numbers3));  // Salida: false
    }
}

Arrays.toString()

El método Arrays.toString() convierte un array en una cadena de texto representando los elementos del array. Es especialmente útil para imprimir arrays de manera legible.

Sintaxis:

String arrayAsString = Arrays.toString(array)

Ejemplo de conversión a cadena:

import java.util.Arrays;

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

        // Convertir el array en una cadena
        String result = Arrays.toString(numbers);

        // Imprimir la cadena
        System.out.println(result);  // Salida: [1, 2, 3, 4, 5]
    }
}

Arrays.deepToString()

Si tienes un array multidimensional, puedes usar Arrays.deepToString() para obtener una representación en cadena que incluya los elementos de las sublistas.

Sintaxis:

String result = Arrays.deepToString(array);

Ejemplo de impresión de un array bidimensional:

import java.util.Arrays;

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

        // Convertir el array multidimensional en una cadena
        String result = Arrays.deepToString(matrix);

        // Imprimir el resultado
        System.out.println(result);  // Salida: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
    }
}

---

La clase Arrays de Java es una herramienta poderosa para trabajar con arrays de manera más eficiente y facilita la manipulación de estos mediante métodos que ahorran tiempo y esfuerzo en el código.