Clase de colecciones en Java

¡Hola! En las últimas lecciones, hemos hecho un gran progreso en nuestro dominio de ArrayList. Sin embargo, hasta ahora solo hemos realizado las operaciones más simples: quitar, insertar y mostrar. Por supuesto, esto no cubre la lista completa de tareas que los desarrolladores deben realizar cuando trabajan con ArrayList. ¿Recuerdas la lección sobre arreglos y la Arraysclase? Los creadores de Java diseñaron específicamente esta clase para manejar las tareas más comunes que enfrentan los programadores cuando trabajan con arreglos. Y que hay conArrayList? Seguramente, hay alguna lista de tareas comunes que deben realizarse con él. ¿Se han implementado todos en una clase específica o tenemos que escribir nuestra propia implementación cada vez? Por supuesto, no es necesario que escriba todo usted mismo. Las operaciones más comunes que involucran colecciones ya se han implementado en la Collectionsclase estática especial. En Java, un grupo de estructuras de datos se conoce comúnmente como una colección . Los datos se pueden almacenar de muchas maneras diferentes. Hasta ahora, solo hemos estudiado la ArrayListclase, donde los datos se almacenan en una matriz. Nos familiarizaremos con otras colecciones más tarde. Por ahora, basta con comprender que la Collectionsclase está diseñada para funcionar no solo conArrayList, pero también con otro tipo de colecciones (de ahí su nombre). Entonces, ¿en qué tareas Collectionsayuda realmente la clase cuando se trabaja con ArrayList? La primera y más obvia es la clasificación. En la lección sobre arreglos, consideramos un ejemplo con números. Ahora consideraremos un ejemplo con cadenas. La Collectionsclase implementa el sort()método para ordenar el contenido de las colecciones:

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       ArrayList<String> solarSystem = new ArrayList<>(Arrays.asList(mercury, venus, earth, mars,
               jupiter, saturn, uranus, neptune));
       Collections.sort(solarSystem);
       System.out.println(solarSystem);

   }
}

Salida: [Tierra, Júpiter, Marte, Mercurio, Neptuno, Saturno, Urano, Venus] ¡ Las cadenas están ordenadas alfabéticamente! Pero ¿por qué alfabéticamente? La Stringclase en realidad implementa la lógica que gobierna cómo se comparan las cadenas (que pasa a ser alfabéticamente). Para las clases que crea usted mismo, puede implementar su propia lógica de comparación, pero hablaremos de esto en otras lecciones. La Collectionsclase también lo ayuda a encontrar el elemento mínimo y máximo en un archivo ArrayList. Esto se hace usando los métodos min()y max():

public static void main(java.lang.String[] args) {

   ArrayList<Integer> numbers = new ArrayList<>(Arrays.asList(1,2,3,4,5,6,7));
   System.out.println(Collections.max(numbers));
   System.out.println(Collections.min(numbers));

}

Salida: 7 1 Naturalmente, esto es mucho más conveniente que escribir manualmente el código para iterar sobre todos los elementos y encontrar el elemento más grande/más pequeño :) Otro método muy útil es reverse(). Si tuviéramos que "voltear" la lista para que los elementos fueran en el orden opuesto, ¿cómo lo haríamos? Probablemente no sería tan fácil escribir un algoritmo de este tipo por ti mismo :) Afortunadamente, el reverse()método ya sabe cómo hacerlo. Supongamos que no nos gusta el hecho de que el sort()método ordenó alfabéticamente nuestros planetas y queremos invertir su orden: de la Z a la A:

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       ArrayList<String> solarSystem = new ArrayList<>(Arrays.asList(mercury, venus, earth, mars,
               jupiter, saturn, uranus, neptune));
       Collections.sort(solarSystem);
       Collections.reverse(solarSystem);
       System.out.println(solarSystem);

   }
}

Resultado: [Venus, Urano, Saturno, Neptuno, Mercurio, Marte, Júpiter, la Tierra] Hemos estado hablando mucho sobre la clasificación, el orden de los elementos, etc. Pero, ¿y si tuviéramos el objetivo opuesto? Por ejemplo, supongamos que estamos tratando de implementar un juego de bingo. Agregamos 100 números al tambor. Deben aparecer en la pantalla uno a la vez. El primer jugador en tachar todos los números de su boleto gana. Esto es fácil de implementar usando el shuffle()método:

public class Main {

   public static void main(java.lang.String[] args) {

       ArrayList<Integer> bingoDrum = new ArrayList<>(100);
       for (int i = 1; i <= 100; i++) {

           bingoDrum.add(i);// add the numbers 1 to 100 to the drum
       }

       Collections.shuffle(bingoDrum);// Mix it up
       System.out.println ("Your attention, please! Here are the first 10 numbers from the drum!");
       for (int i = 0; i < 10; i++) {

           System.out.println(bingoDrum.get(i));
       }

   }
}

Salida: ¡ Su atención, por favor! ¡Aquí están los primeros 10 números del tambor! 32 61 4 81 25 8 66 35 42 71 ¡Así de fácil! El problema está resuelto y nuestra parte del juego está escrita :) Ahora imaginemos una situación diferente. Anteriormente, creamos una solarSystemlista que contenía los planetas. Y parece que nos conviene en todos los sentidos menos en uno: ¡ puede eliminar elementos y agregar otros nuevos ! Claramente, este no es el comportamiento que esperamos: el sistema solar debería ser inmutable en nuestro programa. La Collectionsclase tiene un método muy interesante: unmodifiableList(). Crea una lista inmutable a partir de la lista pasada como argumento. No puede agregar o eliminar elementos de esta lista. Cuando se trata de la lista de planetas del sistema solar, ¡esto es exactamente lo que queremos!

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       List<String> solarSystem = Collections.unmodifiableList(new ArrayList<>(Arrays.asList(mercury, venus, earth, mars,
               jupiter, saturn, uranus, neptune)));
       solarSystem.add("Pluto");// Try to add a new element
   }
}

Salida: Excepción en el subproceso "principal" java.lang.UnsupportedOperationException en java.util.Collections$UnmodifiableCollection.add(Collections.java:1075) en Main.main(Main.java:21) Esto es un error: no puede agregar cualquier cosa a solarSystem! Lo único que debe prestar atención aquí es el hecho de que este método devuelve List<>(no ArrayList<>), ya que este tipo es común para todo tipo de listas. Otra situación bastante común que puede ocurrir fácilmente es que el programador agregue elementos en el orden incorrecto. Si esto sucede y encontramos que Mercurio y Neptuno están mezclados, podemos corregir este error usando el swap()método:

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       ArrayList<String> solarSystem = new ArrayList<>(Arrays.asList(neptune, venus, earth, mars
       , jupiter, saturn, uranus, mercury));// The planets are in the wrong order
       System.out.println(solarSystem);

       Collections.swap(solarSystem, solarSystem.indexOf(mercury), solarSystem.indexOf(neptune));
       System.out.println(solarSystem);

   }
}

Pasamos al swap()método nuestra lista y los índices de los dos elementos que necesitan ser intercambiados. Tenga en cuenta que el método funciona con índices, no con referencias. Entonces, aquí tuvimos que usar el ArrayList.indexOf()método. Salida: [Neptuno, Venus, Tierra, Marte, Júpiter, Saturno, Urano, Mercurio] [Mercurio, Venus, Tierra, Marte, Júpiter, Saturno, Urano, Neptuno] Finalmente, nos familiarizaremos con un método muy interesante: disjoint(). Comprueba si dos colecciones se cruzan, es decir, si tienen al menos un elemento idéntico . Si no lo hacen, devuelve verdadero. Si lo hacen, entonces devuelve falso.

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       ArrayList<String> solarSystemPart1 = new ArrayList<>(Arrays.asList(mercury, venus, earth, mars));
       ArrayList<String> solarSystemPart2 = new ArrayList<>(Arrays.asList(jupiter, saturn, uranus, neptune));

       System.out.println(Collections.disjoint(solarSystemPart1, solarSystemPart2));

   }
}

Como puede ver, nuestras dos listas tienen elementos completamente diferentes, por lo que el programa genera true . Esta es una clase interesante y muy útil. Como Arrays, hace mucho trabajo rutinario y tedioso para nosotros, permitiéndonos concentrarnos en otras cosas.