Classe utilitaire Java Arrays

java.util.Arrays est la collection de méthodes utilitaires de la bibliothèque standard pour les tableaux. C'est une classe final qui ne contient que des méthodes static — vous ne l'instanciez jamais, vous appelez directement ses méthodes : Arrays.sort(...), Arrays.toString(...), etc. Une fois que vous savez ce qu'elle contient, le code que vous écrivez pour manipuler les tableaux devient beaucoup plus concis.

Ce chapitre est une visite guidée. Le tri et la copie ont leurs propres chapitres ; ici nous nous concentrons sur le reste.

Importation

import java.util.Arrays;

Presque tous les exemples ci-dessous supposent cette importation.

toString et deepToString

Transformez un tableau en chaîne lisible. toString gère les tableaux unidimensionnels :

int[] data = {3, 1, 4};
String s = Arrays.toString(data);   // "[3, 1, 4]"

deepToString formate récursivement les tableaux imbriqués :

int[][] grid = {{1, 2}, {3, 4}};
String s = Arrays.deepToString(grid);   // "[[1, 2], [3, 4]]"

Les deux fonctionnent avec des types d'éléments primitifs et objet.

equals et deepEquals

== compare les références de tableaux. Pour comparer le contenu :

int[] a = {1, 2, 3};
int[] b = {1, 2, 3};
boolean same = Arrays.equals(a, b);   // true

Pour les tableaux imbriqués, utilisez deepEquals :

int[][] g1 = {{1, 2}, {3, 4}};
int[][] g2 = {{1, 2}, {3, 4}};
boolean same = Arrays.deepEquals(g1, g2);   // true

Les deux considèrent que null == null vaut true.

hashCode et deepHashCode

Des hachages basés sur le contenu, utiles quand une classe encapsule un tableau et a besoin de equals/hashCode :

int[] data = {1, 2, 3};
int h = Arrays.hashCode(data);

Si vous redéfinissez equals pour utiliser Arrays.equals, vous devez redéfinir hashCode pour utiliser Arrays.hashCode afin de respecter le contrat.

fill

Définissez chaque élément sur une valeur, ou remplissez une plage :

int[] data = new int[5];
Arrays.fill(data, 7);              // {7, 7, 7, 7, 7}
Arrays.fill(data, 1, 4, 0);        // zero indexes 1..3

sort et parallelSort

Tri en place, par ordre croissant :

int[] data = {3, 1, 4, 1, 5};
Arrays.sort(data);                 // {1, 1, 3, 4, 5}

Pour les très grands tableaux, vous pouvez utiliser parallelSort afin de répartir le travail sur plusieurs cœurs. L'histoire complète du tri — types primitifs, objets, ordres personnalisés — se trouve dans le chapitre Tri des tableaux.

binarySearch

Trouvez un élément dans un tableau trié en O(log n) :

int[] sorted = {1, 3, 5, 7, 9};
int idx = Arrays.binarySearch(sorted, 5);   // 2
int miss = Arrays.binarySearch(sorted, 6);  // negative — encodes insertion point

Si l'élément est absent, la valeur retournée est -(insertionPoint) - 1. Ainsi miss == -4 signifie que 6 devrait se trouver à l'index 3. Si l'entrée n'est pas triée, le résultat est indéfini — triez d'abord.

copyOf et copyOfRange

Retournez un nouveau tableau en copiant les valeurs d'un tableau existant :

int[] data = {1, 2, 3, 4, 5};
int[] all   = Arrays.copyOf(data, data.length);    // exact copy
int[] grown = Arrays.copyOf(data, 8);              // padded with zeros
int[] slice = Arrays.copyOfRange(data, 1, 4);      // {2, 3, 4}

Ces méthodes sont couvertes en détail dans Copie des tableaux.

asList

Encapsulez un tableau de références dans une List de taille fixe :

String[] arr = {"a", "b", "c"};
List<String> list = Arrays.asList(arr);

La liste est adossée au tableau — list.set(0, "z") modifie aussi arr[0]. La taille est fixe, donc add/remove lèvent une exception. Avec les tableaux primitifs, cela ne fait pas ce que vous attendez : Arrays.asList(new int[]{1, 2, 3}) produit une List<int[]> de longueur un. Pour les types primitifs, convertissez-les avec des streams en premier.

stream

Obtenez un stream depuis n'importe quel tableau numérique ou objet :

int[] nums = {3, 1, 4, 1, 5};
int sum = Arrays.stream(nums).sum();
double avg = Arrays.stream(nums).average().orElse(0);

Pour les tableaux d'objets, Arrays.stream(arr) retourne un Stream<T>. Il existe aussi des formes limitées à une plage — Arrays.stream(arr, from, to).

setAll et parallelSetAll

Remplissez un tableau en utilisant une fonction de l'index :

int[] squares = new int[6];
Arrays.setAll(squares, i -> i * i);
// {0, 1, 4, 9, 16, 25}

Utilisez setAll quand vous voulez une séquence dérivée et qu'une boucle for ne ferait qu'ajouter du bruit.

compare et mismatch (Java 9+)

Arrays.compare(a, b) retourne un nombre négatif, zéro ou positif — ordre lexicographique sur les éléments :

int[] a = {1, 2, 3};
int[] b = {1, 2, 4};
int cmp = Arrays.compare(a, b);   // negative — a is smaller

Arrays.mismatch(a, b) retourne l'index du premier élément différent, ou -1 s'ils sont égaux :

int diff = Arrays.mismatch(a, b);   // 2

Quand un tableau est un préfixe propre de l'autre, le plus court est considéré comme « plus petit » par compare, et mismatch retourne la longueur du tableau le plus court :

int[] s = {1, 2};
int[] l = {1, 2, 3};
Arrays.compare(s, l);    // negative — s is a prefix, so it sorts first
Arrays.mismatch(s, l);   // 2 — they agree up to index 2, then s runs out

Ces méthodes sont utiles quand vous avez besoin d'un ordre ou de savoir « où ont-ils divergé » sans écrire la boucle manuellement.

Pièges courants

Quelques erreurs surviennent suffisamment souvent pour mériter d'être listées en un seul endroit :

• == n'est pas une comparaison de contenu. a == b est true uniquement quand les deux noms pointent vers le même objet tableau. Utilisez Arrays.equals (ou Arrays.deepEquals pour les tableaux imbriqués) pour comparer le contenu.
• toString est superficiel. Arrays.toString(grid) sur un int[][] affiche quelque chose comme [[I@1b6d3586, ...] — les tableaux internes utilisent leur Object.toString par défaut. Utilisez Arrays.deepToString dès qu'un tableau contient d'autres tableaux.
• asList avec un tableau primitif vous surprend. Arrays.asList(new int[]{1, 2, 3}) est une List<int[]> d'un seul élément, pas une List<Integer> de longueur trois, car int[] est un objet unique. Utilisez Arrays.stream(arr).boxed().toList() (Java 16+) pour obtenir la liste voulue.
• asList est de taille fixe. C'est une vue sur le tableau d'origine, donc set fonctionne mais add et remove lèvent une UnsupportedOperationException. Encapsulez-le dans new ArrayList<>(Arrays.asList(...)) si vous avez besoin de l'agrandir.
• binarySearch nécessite un tableau trié. Sur une entrée non triée, le résultat est indéfini — aucune exception n'est levée, mais l'index retourné est incorrect. Triez d'abord.

Un exemple pratique

La démo ci-dessous regroupe la plupart des méthodes. Exécutez-la et comparez le résultat aux commentaires ci-dessus — binarySearch retournant 5 pour la valeur 5, le résultat négatif pour un élément absent, et la liste [red, green, blue] obtenue avec asList :

Et ensuite

Nous n'avons utilisé Arrays.sort qu'en passant. Le chapitre suivant, Tri des tableaux, explique en détail comment le tri fonctionne pour les types primitifs par rapport aux objets, par ordre croissant par rapport à décroissant, et comment trier selon vos propres critères avec un Comparator.

Pratique