Classe de collections en Java

Salut! Au cours des dernières leçons, nous avons fait de grands progrès dans notre maîtrise de ArrayList. Cependant, jusqu'à présent, nous n'avons effectué que les opérations les plus simples : supprimer, insérer et afficher. Bien sûr, cela ne couvre pas la liste complète des tâches que les développeurs doivent effectuer lorsqu'ils travaillent avec ArrayList. Vous souvenez-vous de la leçon sur les tableaux et la Arraysclasse ? Les créateurs de Java ont spécifiquement conçu cette classe pour gérer les tâches les plus courantes auxquelles les programmeurs sont confrontés lorsqu'ils travaillent avec des tableaux. Et à propos deArrayList? Il existe sûrement une liste de tâches courantes qui doivent être effectuées avec. Ont-ils tous été implémentés dans une classe spécifique, ou devons-nous écrire notre propre implémentation à chaque fois ? Bien sûr, vous n'avez pas besoin de tout écrire vous-même. Les opérations les plus courantes impliquant des collections ont déjà été implémentées dans la Collectionsclasse statique spéciale. En Java, un groupe de structures de données est communément appelé une collection . Les données peuvent être stockées de différentes manières. Jusqu'à présent, nous n'avons étudié que la ArrayListclasse, où les données sont stockées dans un tableau. Nous nous familiariserons avec d'autres collections plus tard. Pour l'instant, il suffit de comprendre que la Collectionsclasse est conçue pour fonctionner non seulement avecArrayList, mais aussi avec d'autres types de collections (d'où son nom). Alors, à quelles tâches la Collectionsclasse aide-t-elle réellement lorsqu'elle travaille avecArrayList ? Le premier et le plus évident est le tri. Dans la leçon sur les tableaux, nous avons considéré un exemple avec des nombres. Considérons maintenant un exemple avec des chaînes. La Collectionsclasse implémente la sort()méthode de tri du contenu des collections :

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);

   }
}

Sortie : [Terre, Jupiter, Mars, Mercure, Neptune, Saturne, Uranus, Vénus] Les chaînes sont triées par ordre alphabétique ! Mais pourquoi par ordre alphabétique ? La Stringclasse implémente en fait la logique qui régit la façon dont les chaînes sont comparées (qui se trouve être alphabétiquement). Pour les classes que vous créez vous-même, vous pouvez implémenter votre propre logique de comparaison, mais nous en parlerons dans d'autres leçons. La Collectionsclasse vous aide également à trouver l'élément minimum et maximum dans un fichier ArrayList. Ceci est fait en utilisant les méthodes min()et 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));

}

Résultat : 7 1 Naturellement, c'est beaucoup plus pratique que d'écrire manuellement le code pour parcourir tous les éléments et trouver l'élément le plus grand/le plus petit :) Une autre méthode très utile est reverse(). Si nous devions « retourner » la liste pour que les éléments soient dans l'ordre inverse, comment ferions-nous ? Ce ne serait probablement pas si facile d'écrire un tel algorithme par vous-même :) Heureusement, la reverse()méthode sait déjà comment faire. Supposons que nous n'aimions pas le fait que la sort()méthode ait trié nos planètes par ordre alphabétique, et que nous souhaitions inverser leur ordre : de Z à 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);

   }
}

Sortie : [Vénus, Uranus, Saturne, Neptune, Mercure, Mars, Jupiter, Terre] Nous avons beaucoup parlé de tri, d'ordre des éléments, etc. Mais si nous avions l'objectif inverse ? Par exemple, supposons que nous essayons de mettre en œuvre un jeu de bingo. Nous ajoutons 100 numéros au tambour. Ils doivent apparaître à l'écran un par un. Le premier joueur à barrer tous les numéros de son ticket gagne. Ceci est facile à mettre en œuvre en utilisant la shuffle()méthode :

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));
       }

   }
}

Sortie : Votre attention, s'il vous plaît ! Voici les 10 premiers numéros du tambour ! 32 61 4 81 25 8 66 35 42 71 C'est aussi simple que ça ! Le problème est résolu, et notre partie du jeu est écrite :) Imaginons maintenant une situation différente. Auparavant, nous avons créé une solarSystemliste contenant les planètes. Et il semble nous convenir à tous points de vue sauf un : vous pouvez y supprimer des éléments et en ajouter de nouveaux ! Ce n'est clairement pas le comportement auquel nous nous attendons : le système solaire devrait être immuable dans notre programme. La Collectionsclasse a une méthode très intéressante : unmodifiableList(). Il crée une liste immuable à partir de la liste passée en argument. Vous ne pouvez pas ajouter ou supprimer des éléments de cette liste. Lorsqu'il s'agit de la liste des planètes du système solaire, c'est exactement ce que nous voulons !

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
   }
}

Sortie : Exception dans le thread "main" java.lang.UnsupportedOperationException à java.util.Collections$UnmodifiableCollection.add(Collections.java:1075) à Main.main(Main.java:21) Ceci est une erreur : vous ne pouvez pas ajouter quoi que ce soit à solarSystem! La seule chose à laquelle vous devez prêter attention ici est le fait que cette méthode retourne List<>(pas ArrayList<>), car ce type est commun à toutes sortes de listes. Une autre situation assez courante qui peut facilement se produire est que le programmeur ajoute des éléments dans le mauvais ordre. Si cela se produit et que nous constatons que Mercure et Neptune sont mélangés, nous pouvons corriger cette erreur en utilisant la swap()méthode :

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);

   }
}

Nous passons à la swap()méthode notre liste et les indices des deux éléments à permuter. Notez que la méthode fonctionne avec des indices, pas des références. Donc, ici, nous avons dû utiliser la ArrayList.indexOf()méthode. Sortie : [Neptune, Vénus, Terre, Mars, Jupiter, Saturne, Uranus, Mercure] [Mercure, Vénus, Terre, Mars, Jupiter, Saturne, Uranus, Neptune] Enfin, nous nous familiariserons avec une méthode très intéressante : disjoint(). Il vérifie si deux collections se croisent, c'est-à-dire si elles ont au moins un élément identique . Si ce n'est pas le cas, il renvoie true. S'ils le font, alors ça retourne faux

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));

   }
}

Comme vous pouvez le voir, nos deux listes ont des éléments complètement différents, donc le programme affiche true . C'est une classe intéressante et très utile. Comme Arrays, il fait beaucoup de travail routinier et fastidieux pour nous, nous permettant de nous concentrer sur d'autres choses.