clase de arreglos

¡Hola de nuevo! :) En la lección de hoy, hablaremos sobre la clase Arrays en Java. En la última lección, llegamos a conocer una estructura de datos de este tipo llamada matriz. Aprendimos cómo crearlos y llenarlos con datos. Y observamos cómo se almacenan en la memoria. Hoy veremos algunas tareas y ejemplos de cómo trabajar con arreglos que verá a menudo en el trabajo real. Por ejemplo, imagina esta situación: tenemos una matriz de 10 números aleatorios.

int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

Nuestra tarea es ordenar esta matriz en orden ascendente: de menor a mayor. Al final, debería verse así: [-234, -2, 16, 26, 35, 43, 92, 99, 167] ¿ Cómo hacemos eso? Esta tarea no es trivial. Nunca hemos hecho esto antes :/ ¿Alguna idea? Intenta adivinar. Aquí hay una solución:

• Ir a través de todos los elementos de la matriz. Compara cada elemento con el siguiente ([0] con [1], [1] con [2], [2] con [3], etc.). Si el elemento actual es mayor que el siguiente, los intercambiamos y luego pasamos al siguiente elemento. Si no, déjalos como están y sigue adelante.
• Por lo tanto, después del primer paso por los elementos, se garantiza que el valor más grande (167) estará en la última celda.
• Ahora repasaremos todos los elementos nuevamente, pero esta vez comenzaremos con el índice [0] hasta el penúltimo elemento (el número más grande ya está en su lugar) y haremos las mismas comparaciones e intercambios. Después de este pase, en la penúltima celda, tendremos el segundo valor más grande (99).
• Repita este proceso tantas veces como elementos de la matriz tengamos.

Tenemos la idea. Ahora solo falta escribir el código. Se parece a esto:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       for (int i = numbers.length - 1; i > 0; i--) {
           for (int j = 0; j < i; j++) {
           /* Compare the elements in pairs.
             If they are not in the right order,
             then swap them */
               if (numbers[j] > numbers[j + 1]) {
                   int tmp = numbers[j];
                   numbers[j] = numbers[j + 1];
                   numbers[j + 1] = tmp;
               }
           }
       }

   }
}

Uh... Parece un poco complicado -_- Incluso si el principio general es comprensible, todavía tenemos que escribir bastante código para resolver una tarea tan simple. De acuerdo, ¿quizás nos hemos sobreestimado a nosotros mismos? La tarea que hemos abordado probablemente todavía sea demasiado complicada para nosotros. Intentemos algo más simple. Por ejemplo, tome la misma matriz de números.

int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

Nuestra tarea es copiar su contenido a otra matriz.

int [] numbersCopy = new int[10];

Piense en cómo lo haría usando lo que ya sabe sobre matrices. Por ejemplo, podría recorrer la matriz de números en un bucle y escribir secuencialmente sus elementos en numbersCopy :

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = new int[10];

       for (int i = 0; i < numbers.length; i++) {

           numbersCopy[i] = numbers[i];
       }

   }
}

Bueno, eh, ¡aquí básicamente lo hemos hecho! Parece que hemos solucionado el problema. Sin embargo, si necesita hacer esto con frecuencia, su código tendrá un montón de bucles idénticos. De hecho, estas (y otras) tareas han sido resueltas durante mucho tiempo por los creadores de Java. No necesitamos "reinventar la rueda" y codificar nuestra propia solución. Hay una clase estática especial ( Arrays ) para ayudarlo a realizar tareas comunes cuando trabaja con matrices. Se han agregado a esta clase métodos para realizar las tareas más comunes a las que se enfrentan los programadores de Java. Por ejemplo, la tarea de ordenar una matriz, que tratamos de manejar, se resuelve en una sola línea:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       Arrays.sort(numbers);

       System.out.println(Arrays.toString(numbers));

   }
}

El método Arrays.sort() ordena la matriz. Y su algoritmo es mucho más eficiente que el código que escribimos. Salida de la consola: [-234, -2, 16, 26, 35, 43, 80, 92, 99, 167] Nota: Para convertir el arreglo en una cadena, usamos otro método de la clase Arrays : Arrays.toString() . Las matrices en Java no anulan el método toString() por sí mismas. Entonces, si simplemente escribes

System.out.println(numbers.toString());

se llamará a toString() de la clase Object . Para una matriz, la salida será algo como esto: [I@4554617c No entraremos en detalles ahora sobre por qué exactamente esta es la salida. Lo principal es que claramente no es lo que necesitamos. Pero Arrays.toString() hace precisamente lo que queremos. Por cierto, la copia también se logra fácilmente con la clase Arrays :

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = Arrays.copyOf(numbers, numbers.length);
       System.out.println(Arrays.toString(numbersCopy));

   }
}

Pasamos al método Arrays.copyOf() nuestra matriz original (de la que queremos copiar valores) y la longitud de la nueva matriz en la que estamos copiando datos. En este caso, indicamos números.longitud como la longitud, ya que queremos copiar todo el arreglo. Si quisiéramos copiar solo los primeros elementos, podemos especificar la longitud de una nueva matriz más pequeña:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = Arrays.copyOf(numbers, 4);
       System.out.println(Arrays.toString(numbersCopy));

   }
}

Aquí especificamos 4 como la longitud de la nueva matriz. En consecuencia, solo los primeros 4 elementos de los números se copiarán en la nueva matriz. Salida de la consola: [167, -2, 16, 99] Por cierto, Arrays también te permite copiar parte de una matriz desde el medio en lugar del principio de la matriz:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = Arrays.copyOfRange(numbers, 2,6);
       System.out.println(Arrays.toString(numbersCopy));

   }
}

Salida: [16, 99, 26, 92] Los números se copiaron en la nueva matriz desde la segunda matriz desde el segundo (inclusive) hasta el sexto (no inclusive) elemento. También es posible que necesitemos comparar dos matrices. Al igual que con el método toString() , las matrices en sí mismas no anulan el método equals() . Así que si tratamos de compararlos así

public class Main {

   public static void main(String[] args) {

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

       System.out.println(numbers.equals(numbers2));
   }
}

entonces obtenemos falso. Esto se debe a que se llamará a Object.equals() , que compara referencias. Y, obviamente, ¡son diferentes! Pero lo que necesitamos es comparar los contenidos de la matriz, no las referencias. La clase Arrays anula el método equals() para que haga exactamente lo que queremos:

public class Main {

   public static void main(String[] args) {

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

       System.out.println(Arrays.equals(numbers, numbers2));
   }
}

Salida: verdadero Por cierto, la clase Arrays no solo funciona con matrices ordinarias, sino también con matrices bidimensionales:

public class Main {

   public static void main(String[] args) {

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

       int[][] numbersCopy = Arrays.copyOf(numbers, numbers.length);

       System.out.println("Are these two-dimensional arrays equal?");
       System.out.println(Arrays.deepEquals(numbers, numbersCopy));

       System.out.println(Arrays.deepToString(numbersCopy));
   }
}

Salida: ¿Son iguales estas matrices bidimensionales? verdadero [[1, 2, 3], [4, 5, 6], [7, 8, 9]] Como puede ver, el método Arrays.copyOf() pudo copiar una matriz bidimensional. Y la clase tiene métodos especiales para comparar y mostrar arreglos bidimensionales: deepEquals y deepToString() . En el futuro, verá repetidamente (y se alegrará de ello) que los creadores de Java anticiparon muchas situaciones a las que se enfrentan con frecuencia los programadores e implementaron soluciones listas para usar en el lenguaje. Usar estas soluciones es mucho más fácil y conveniente que reinventar la rueda, ¿verdad? :) Asegúrese de leer la documentación de la clase Arrays en el sitio web de Oracle . ¡Buena suerte en tus estudios!