2.3 - Tableaux et collections

## Tableaux Les tableaux permettent de stocker un **nombre fixe** de données Ils sont indexés à partir de 0. ![[dev-java-array-structure.png|360x150]] Source : https://dev.java/learn/language-basics/arrays/ ```java String[] strings = new String[]{"Foo", "Bar",}; // Syntaxe compacte String[] otherStrings = {"Foo", "Bar",}; String foo = strings[0]; // -> "Foo" strings[1] = "bar"; strings[10] = "bar"; // -> ArrayIndexOutOfBoundsException int[] array = new int[10]; int[] numbers = { 100, 200, 300, 400, 500, 600, 700, 800, 900, 1000 }; String[] texts; // -> null ``` ### A plusieurs dimensions ```java int[][] array2D = new int[][]{ {1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}, {11, 12, 13, 14, 15}, {16, 17, 18, 19, 20}, {21, 22, 23, 24, 25}, }; int number = array2D[2][3]; // 14 ``` <div style="page-break-after: always;"></div> ### Parcourir un tableau Avec une boucle classique ```java int[] numbers = {10, 20, 30, 40, 50}; for (int i = 0; i < numbers.length; i++) { int number = numbers[i]; System.out.println("Indice " + i + " : " + number); } ``` Avec une boucle améliorée ```java int[] numbers = {10, 20, 30, 40, 50}; for (int number : numbers) { System.out.println("Nombre : " + number); } ``` ```java String[] couleurs = {"bleu", "vert", "rouge"}; for (String couleur : couleurs) { System.out.println("Couleur : " + couleur); } ``` ### Utilitaires `Arrays` ```java import java.util.Arrays; ``` ```java int[] numbers = new int[5]; Arrays.fill(numbers, 42); ``` Il existe plein d'autres fonctions utilitaires sur les tableaux. ```java int[] array1 = new int[]{1, 2}; int[] array2 = new int[]{2, 2}; int comparison = Arrays.compare(array1, array2); System.out.println(comparison); // -1 // Cela signifie que le tableau 1 {1, 2} // est inférieur au tableau 2 {2, 2} ```  https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/Arrays.html <div style="page-break-after: always;"></div> ## Les collections Java Pour aller au delà des tableaux, Java propose des collections implémentant la plupart des algorithmes classiques de structures de données. Ces outils permettent de stocker, parcourir, et manipuler des ensembles d'objets. C'est présenté dans l'API Java par une hiérarchie de types. ![[dev-java-collection-hierarchy.png|320x292]] Source : https://dev.java/learn/api/collections-framework/organization/ Les collections contrairement aux tableaux ont des tailles dynamiques Elles font partie du package Java.util et il faut les inclure au début du programme. <div style="page-break-after: always;"></div> ## `List` Une `List` est une collection qui permet l'accès et la modification indexée de ses éléments. `List`est compatible avec `Iterable` et `Collection`. Elle possède de nombreuses méthodes permettant l'accès et la modification **indexée** (position de l'objet dans la liste). ```java List<String> list = new ArrayList<String>(); list.addAll(1,collection); String elementALindex1 = list.get(1); list.set(1,"A"); int indexOfA = list.indexOf("A"); int lastIndexOfA = list.lastIndexOf("A"); List<String> sousListe = list.subList(0, 2); ``` C'est un [[Glossaire - Programmation#Type générique|type générique]]. C'est à dire qu'il faut indiquer le type de données qu'elle contient en l'indiquant entre `< >`. Ex. ```java // Liste de chaines de caractères List<String> textes = new ArrayList<String>(); // Liste de nombre entiers List<Integer> entiers = new ArrayList<Integer>(); ``` > [!danger] Ne fonctionne qu'avec les types référence > > Le code suivant ne compile pas : > ```java > List<int> entiersPrimitifs = new ArrayList<int>(); > ``` > > Il faut écrire le code suivant à la place : > ```java > List<Integer> entiersReference = new ArrayList<Integer>(); > ``` > <div style="page-break-after: always;"></div> ### `ArrayList` Une `ArrayList` est une `List` qui permet de stocker une liste d’objets de [[Glossaire - Programmation#Type référence (Java)|type référence]] (dont des valeurs `null`). `ArrayList` est **modifiable**. Une `ArrayList` possède de nombreuses méthodes permettant l'accès et la modification **indexée** (position de l'objet dans la liste). **Contrairement aux tableaux**, sa taille est variable. ```java import java.util.ArrayList; ``` ```java List<String> chasseurs = new ArrayList<String>() ; chasseurs.add("Bébert"); chasseurs.add("Robert"); chasseurs.add("Gérard"); System.out.println(chasseurs); // [Bébert, Robert, Gérard] // Ajout en index 3 chasseurs.add(2,"Dédé"); System.out.println(chasseurs); // [Bébert, Robert, Dédé, Gérard] // Remplacement en index 3 chasseurs.set(2,"André"); System.out.println(chasseurs); // [Bébert, Robert, André, Gérard] ``` Autres façons de déclarer une `ArrayList` dans une variable ```java Collection<String> names = new ArrayList<>() ; List<String> names = new ArrayList<>() ; var names = new ArrayList<String>() ; // Non recommandé, utiliser plutôt un type plus faible ArrayList<String> names = new ArrayList<String>() ; ``` https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/util/ArrayList.html ### `List` non modifiable ```java List<String> chasseurs; chasseurs= List.of("Bébert", "Robert", "Gérard"); chasseurs=Collections.EMPTY_LIST; ArrayList<String> arrayList = new ArrayList<>(); arrayList.add("Bébert"); chasseurs=Collections.unmodifiableList(arrayList); ``` <div style="page-break-after: always;"></div> ## `Set` Le type `Set` correspond à une collection dont **chaque élément est unique**. `Set`est compatible avec `Iterable` et `Collection`. Quelques types compatibles avec `Set` ```java Set<String> set; set = new HashSet<>(); set = new TreeSet<>(); set = new LinkedHashSet<>(); ``` ### `HashSet` HashSet est une implémentation de `Set` qui détermine l'unicité de ses éléments par sa valeur (et par le résultat de la méthode `hashcode()` de l'objet contenu. ```java Set<String> chasseurs = new HashSet<>() ; chasseurs.add("Bébert"); chasseurs.add("Robert"); chasseurs.add("Gérard"); chasseurs.add("Gérard"); chasseurs.add("Gérard"); chasseurs.add("Gérard"); System.out.println(chasseurs); // [Gérard, Robert, Bébert] // Pas d'ordre particulier ``` ```java Set<String> chasseurs = new LinkedHashSet<>() ; chasseurs.add("Bébert"); chasseurs.add("Robert"); chasseurs.add("Gérard"); chasseurs.add("Gérard"); System.out.println(chasseurs); // [Bébert, Robert, Gérard] // Dans l'ordre d'apparition ``` <div style="page-break-after: always;"></div> ### `TreeSet` `TreeSet` est un set basé sur une structure d'arbre qui trie des éléments comparables dans l'ordre naturel (déterminé par leur méthode `compareTo()`) ```java Set<String> chasseurs = new TreeSet<>() ; chasseurs.add("Bébert"); chasseurs.add("Robert"); chasseurs.add("Gérard"); chasseurs.add("Gérard"); System.out.println(chasseurs); // [Bébert, Gérard, Robert] // Dans l'ordre naturel (ici alphabétique) ``` `TreeSet`est compatible avec le type `SortedSet`. ```java SortedSet<String> treeSet = new TreeSet<>(); ``` ### `Set` non modifiable ```java Set<String> chasseurs; chasseurs = Set.of("Bébert", "Robert", "Gérard"); chasseurs = Collections.EMPTY_SET; HashSet<String> hashSet = new HashSet<>(); hashSet.add("A"); chasseurs = Collections.unmodifiableSet(hashSet); ``` <div style="page-break-after: always;"></div> ## `Queue` File d'attente. Est compatible avec le type `Collection` Quelques types compatibles ```java Queue<String> queue; queue= new PriorityQueue<>(); queue= new LinkedList<>(); queue= new ArrayDeque<>(); ``` ![[collections-queue-methods.png|335x154]] ```java queue.add("A"); queue.offer("B"); String head = queue.remove(); head = queue.poll(); head = queue.peek(); head = queue.element(); ``` <div style="page-break-after: always;"></div> ## `Deque` Une collection linéaire qui prend en charge **l'insertion et la suppression** d'éléments **aux deux extrémités**. Le nom deque est l'abréviation de "double file d'attente" en anglais et se prononce généralement "deck". Est compatible avec le type `Collection` et `Queue` Résumé des méthodes de `Deque` ![[collections-deque-method-summary.png|421x136]] Quelques types compatibles avec `Deque` ```java Deque<String> deque; deque=new LinkedList<>(); deque=new ArrayDeque<>(); deque=new ConcurrentLinkedDeque<>(); deque=new LinkedBlockingDeque<>(); ``` Comparaison entre `Queue` et `Deque` ![[collections-deque-queue-methods.png|304x249]] Exemples de quelques méthodes de deque ```java Deque<String> deque = new LinkedList<>(); deque.push("A"); String popped = deque.pop(); String first = deque.peekFirst(); String last = deque.peekLast(); deque.offerFirst("A"); deque.offerLast("A"); String first1 = deque.pollFirst(); String last1 = deque.pollLast(); deque.removeFirstOccurrence("A"); deque.removeLastOccurrence("B"); ``` <div style="page-break-after: always;"></div> ## Parcourir une collection : boucle foreach ```java Map<Integer,String> nombresRomains = Map.of( 1,"I", 2,"II", 3,"III", 4,"IV", 5,"V"); for (Integer nombreArabe : nombresRomains.keySet()){ System.out.println(nombreArabe+" : "+nombresRomains.get(nombreArabe)); } // 1 : I // 2 : II // 3 : III // 4 : IV // 5 : V for (String nombreRomain : nombresRomains.values()){ System.out.println(nombreRomain); } // I // II // III // IV // V Collection<String> chasseurs = new HashSet<>() ; chasseurs.add("Bébert"); chasseurs.add("Robert"); chasseurs.add("Gérard"); for (String chasseur : chasseurs){ System.out.println(chasseur); } // Bébert // Robert // Gérard Collection<String> chasseurs = new ArrayList<>() ; chasseurs.add("Bébert"); chasseurs.add("Robert"); chasseurs.add("Gérard"); for (String chasseur : chasseurs){ System.out.println(chasseur); } // Bébert // Robert // Gérard ``` <div style="page-break-after: always;"></div> ## Revenons à `Iterable` et `Collection` Comme nous l'avons vu plus haut, les collections `Set`, `List` sont compatibles avec les types `Iterable` et `Collection` ![[dev-java-collection-hierarchy.png|320x292]] Cela signifie qu'il bénéficient des fonctionnalités de ces types. ### Type `Iterable` Indique que la collection peut être **parcourue à l'aide d'une boucle améliorée**. Ex. ```java Iterable<String> monIterable; monIterable = new ArrayList<String>(); monIterable = List.of("A","B","C"); monIterable = new HashSet<String>(); monIterable = Set.of("A","B","C"); for (String valeur : monIterable){ IO.println(valeur); } ``` Voir : https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/lang/Iterable.html <div style="page-break-after: always;"></div> ### Type `Collection` Ce type est généralement utilisée pour transmettre des collections et les manipuler là où une généralité maximale est souhaitée. `Collection` est compatible avec `Iterable`. Cela sgnifie qu'on peut également utiliser la boucle for améliorée avec une variable de type `Collection`. Voici des fonctionnalités présentes dans le type `Collection` - `add(element)` - `addAll(collection)` - `clear()` - `contains(objet)` - `containsAll(collection)` - `isEmpty()` - `remove(objet)` - `removeAll(collection)` - `removeIf(filtre)` - `size()` - `stream()` - `toArray()` Voir : https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/util/Collection.html ```java Collection<String> maCollection; maCollection = new ArrayList<String>(); maCollection = new HashSet<String>(); maCollection.add("A"); maCollection.remove("A"); maCollection = List.of("A","B","C"); maCollection = Set.of("A","B","C"); // Les listes non modifiables (List.of(), Set.of()) // Ne peuvent pas être modifiées maCollection.add("A"); // -> UnsupportedOperationException maCollection.remove("A"); // -> UnsupportedOperationException ``` <div style="page-break-after: always;"></div> ## `Map` Le type `Map` correspond à un **dictionnaire** clé-valeur. > [!danger] > `Map` **N'EST PAS compatible** avec le type `Collection` ni avec `Iterable`. ### `HashMap` `HashMap` en est une implémentation de `Set` dont les clés sont basées sur une `HashMap`. HashMap est modifiable. ```java Map<Integer,String> nombresRomains = new HashMap<>(); nombresRomains.put(1,"I"); nombresRomains.put(2,"II"); nombresRomains.put(3,"III"); nombresRomains.put(4,"IV"); nombresRomains.put(5,"V"); nombresRomains.get(2); // "II" nombresRomains.remove(3); nombresRomains.size(); ``` ### `Map` non modifiable ```java Map<Integer,String> nombresRomains; nombresRomains= Map.of( 1,"I", 2,"II", 3,"III", 4,"IV", 5,"V"); nombresRomains= Collections.EMPTY_MAP; HashMap<Integer, String> hashMap = new HashMap<>(); hashMap.put(1,"I"); nombresRomains= Collections.unmodifiableMap(hashMap); ``` <div style="page-break-after: always;"></div> ## Utilitaires `Collections` Utilitaires pour les collections ```java List<String> list = new ArrayList<>(List.of("Bébert","Dédé","Gérard")); Collections.shuffle(list); Collections.sort(list); Collections.max(list); // ... ``` # À suivre [[3.1 - Fondamentaux de la Programmation Orientée Objet]]