Collections en Java | Collections Java

Bonjour! Au cours des dernières leçons, nous avons fait de grands progrès dans la maîtrise d'ArrayList. Cependant, pendant ce temps, nous n'avons effectué que les opérations les plus simples : supprimer, insérer, sortir sur la console. Bien sûr, ce n'est pas la fin de la liste des problèmes auxquels les développeurs sont confrontés lors de l'utilisation d'ArrayList . Vous vous souvenez de la conférence sur les tableaux et la classe Arrays ? Il a été développé par les créateurs de Java spécifiquement pour résoudre les problèmes courants rencontrés par les programmeurs lorsqu'ils travaillent avec des tableaux. Et ArrayList ? Il existe sûrement une liste de tâches typiques pour lui aussi. Ont-ils tous été implémentés dans une classe distincte, ou devrons-nous écrire manuellement le comportement souhaité à chaque fois ? Bien sûr, vous n’êtes pas obligé de tout écrire vous-même. Les opérations les plus courantes effectuées lors de l'utilisation de collections en Java ont déjà été implémentées dans une classe statique spéciale Collections.

Collections en Java

« Collections » est un nom générique pour plusieurs structures de données en Java. Les données peuvent être stockées de différentes manières. Jusqu'à présent, nous n'avons étudié que la classe ArrayList , où les données sont stockées dans un tableau. Nous ferons connaissance avec le reste des collections plus tard. Il suffit maintenant de comprendre que la classe Collections est conçue pour fonctionner non seulement avec ArrayList, mais aussi avec d'autres types de collections en Java (d'où, en fait, son nom). Alors, quelles tâches la classe Collections vous permet-elle de résoudre lorsque vous travaillez avec ArrayList ? La première et la plus évidente est le tri. Dans la conférence sur les tableaux, nous avons examiné un exemple avec des nombres, et regardons maintenant un exemple avec des chaînes. Pour trier le contenu des collections, la classe Collections implémente la méthode suivante sort():

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

   }
}

Conclusion:

[Венера, Земля, Марс, Меркурий, Нептун, Сатурн, Уран, Юпитер]

Les lignes ont été triées par ordre alphabétique ! Pourquoi par ordre alphabétique ? La classe Stringest programmée pour déterminer exactement comment les chaînes sont comparées les unes aux autres (précisément par ordre alphabétique). Pour les classes que vous créerez vous-même, vous pouvez implémenter votre propre mécanisme de comparaison, mais nous en reparlerons dans d'autres cours. De plus, la classe Collections vous permet de trouver l'élément minimum et maximum dans un fichier ArrayList. Cela se 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));

}

Conclusion:

7
1

Ceci, bien sûr, est beaucoup plus pratique que d'écrire manuellement du code pour parcourir tous les éléments et rechercher le plus grand/le plus petit élément :) Une autre méthode extrêmement utile est reverse(). Si nous devions « inverser » une liste pour que les éléments soient dans l’ordre inverse, comment procéderions-nous ? Il ne serait probablement pas si simple d'écrire un tel algorithme soi-même :) Heureusement, la méthode reverse()sait déjà comment faire cela. Par exemple, nous n'aimons pas la façon dont la méthode sort()a trié nos planètes par ordre alphabétique, et nous souhaitons changer l'ordre inverse - 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);

   }
}

Conclusion:

[Юпитер, Уран, Сатурн, Нептун, Меркурий, Марс, Земля, Венера]

D’ailleurs, on parle souvent ici de tri, d’ordre des éléments, etc. Et si notre tâche était exactement le contraire ? Par exemple, nous essayons de mettre en place un mécanisme de loterie. Nous avons ajouté 100 numéros à la bobine, qui devraient apparaître un par un à l'écran. Le premier participant à rayer tous les numéros de son ticket gagne. Il est très simple de mettre en œuvre un tel mécanisme en utilisant la méthode shuffle():

public class Main {

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

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

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

       Collections.shuffle(lottery);//mix
       System.out.println("Attention! The first 10 numbers appear from the drum!");
       for (int i = 0; i < 10; i++) {

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

   }
}

Conclusion:

Внимание! Из барабана появляются первые 10 чисел!
32
61
4
81
25
8
66
35
42
71

C'est si simple! Le problème est résolu et notre partie du jeu est écrite :) Imaginons maintenant une situation différente. Auparavant, nous avons créé une liste solarSystemavec les planètes répertoriées. Et cela semble nous convenir à tous, ne serait-ce que pour une chose : 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 de notre programme devrait être dans un état inchangé. La classe Collections a une méthode très intéressante - unmodifiableList(). Il crée une version immuable de la liste donnée. Il sera impossible d'y ajouter ou de supprimer un élément. Dans le cas de la liste des planètes du système solaire, c’est exactement ce dont nous avons besoin !

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

Exception in thread "main" java.lang.UnsupportedOperationException
	at java.util.Collections$UnmodifiableCollection.add(Collections.java:1075)
	at Main.main(Main.java:21)

Erreur : solarSystemVous ne pouvez plus rien ajouter ! La seule chose à laquelle vous devez faire attention dans ce cas est que le type de la variable doit être List<>, et non ArrayList<>(cette méthode renvoie un objet exactement de ce type, commun à tous les types de listes). Une autre situation courante pouvant survenir pendant le travail est que le programmeur a ajouté des éléments dans le mauvais ordre. Si cela se produisait et que Mercure et Neptune changeaient de place de manière inattendue, la méthode suivante nous aidera à corriger cette erreur swap():

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));// wrong planet order
       System.out.println(solarSystem);

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

   }
}

Nous avons transmis notre liste à la méthode swap(), ainsi que les indices des deux éléments à permuter. Attention : la méthode fonctionne spécifiquement avec des index, et non avec des liens. Par conséquent, nous avions besoin ici d’une méthode ArrayList.indexOf(). Conclusion:

[Нептун, Венера, Земля, Марс, Юпитер, Сатурн, Уран, Меркурий]

[Меркурий, Венера, Земля, Марс, Юпитер, Сатурн, Уран, Нептун]

Enfin, faisons connaissance avec une méthode très intéressante - disjoint(). Il vérifie si deux collections ont des intersections, c'est-à-dire au moins un élément identique. Sinon, renvoie true, si oui, renvoie false.

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, les éléments de nos deux listes sont complètement différents, donc le programme affiche true. C'est un cours tellement intéressant et très utile. Comme Arrays, il fait beaucoup de travail routinier et subalterne pour nous, nous permettant de nous concentrer sur autre chose. Lisez à ce sujet dans la documentation Oracle , il existe d'autres méthodes.