Opérations courantes sur les tableaux Java

Les tableaux eux-mêmes n'ont pas beaucoup de méthodes. L'objet tableau expose un champ (length) et une méthode (clone()). Tout le reste — affichage, remplissage, recherche, comparaison — se trouve dans la classe utilitaire java.util.Arrays, que nous aborderons en détail dans le prochain chapitre. Ce chapitre présente les opérations du quotidien : ce qu'elles font et quelle méthode utiliser.

Cette page couvre la lecture de la taille, l'affichage, le remplissage, la comparaison, la recherche, la copie et la conversion d'un tableau en List. Pour chaque tâche, il y a généralement un appel idiomatique — l'objectif est de reconnaître lequel.

Longueur

int[] data = {3, 1, 4, 1, 5, 9, 2, 6};
System.out.println(data.length);   // 8

Champ, pas méthode — pas de parenthèses. length est fixé dès la création du tableau ; pour « agrandir » un tableau, il faut en allouer un nouveau et copier (voir Copie ci-dessous). Notez que length est un champ des tableaux, tandis que String et les collections comme List utilisent une méthode length() ou size() à la place — source fréquente de confusion.

Affichage d'un tableau

System.out.println(arr) affiche quelque chose comme [I@1540e19d — le nom de la classe et le hash. C'est rarement ce que vous souhaitez. Utilisez Arrays.toString :

import java.util.Arrays;

int[] data = {3, 1, 4, 1, 5};
System.out.println(Arrays.toString(data));   // [3, 1, 4, 1, 5]

Pour les tableaux à 2 dimensions, utilisez Arrays.deepToString :

int[][] grid = {{1, 2}, {3, 4}};
System.out.println(Arrays.deepToString(grid));   // [[1, 2], [3, 4]]

Remplissage

Pour définir la même valeur dans chaque case :

int[] zeros = new int[5];
Arrays.fill(zeros, 7);              // {7, 7, 7, 7, 7}

Une forme avec plage remplit uniquement [fromIndex, toIndex) :

int[] data = new int[10];
Arrays.fill(data, 3, 7, 1);         // ones in positions 3, 4, 5, 6

Égalité

== sur les tableaux compare les références, pas le contenu. Pour une égalité élément par élément, utilisez Arrays.equals :

int[] a = {1, 2, 3};
int[] b = {1, 2, 3};
System.out.println(a == b);                    // false (different objects)
System.out.println(Arrays.equals(a, b));       // true

Pour les tableaux imbriqués, utilisez Arrays.deepEquals. Pour une sémantique sûre vis-à-vis de null, les deux méthodes considèrent null == null comme true.

Recherche

Un parcours linéaire avec une boucle classique convient pour les petits tableaux ou les tableaux non triés :

int[] data = {7, 3, 9, 1, 5};
int target = 9;
int found = -1;
for (int i = 0; i < data.length; i++) {
  if (data[i] == target) { found = i; break; }
}

Pour un tableau trié, Arrays.binarySearch est en O(log n) :

int[] sorted = {1, 3, 5, 7, 9};
int idx = Arrays.binarySearch(sorted, 7);   // 3

Si la valeur n'est pas présente, binarySearch retourne un nombre négatif qui encode l'endroit où elle devrait se trouver : -(insertionPoint) - 1. Ainsi, un retour de -8 signifie « non trouvé, devrait être à l'index 7. » Pour obtenir le point d'insertion : int insert = -(result) - 1;.

Copie

Pour obtenir un nouveau tableau avec le même contenu :

int[] data = {1, 2, 3, 4, 5};
int[] copy = Arrays.copyOf(data, data.length);

Pour redimensionner lors de la copie — remplir avec les valeurs par défaut si plus long, tronquer si plus court :

int[] longer  = Arrays.copyOf(data, 8);    // {1, 2, 3, 4, 5, 0, 0, 0}
int[] shorter = Arrays.copyOf(data, 3);    // {1, 2, 3}

Pour copier une tranche :

int[] middle = Arrays.copyOfRange(data, 1, 4);   // {2, 3, 4}

from est inclusif, to est exclusif — la convention Java habituelle d'intervalle semi-ouvert.

La seule méthode de copie qui appartient au tableau lui-même est clone() :

int[] data = {1, 2, 3};
int[] dup  = data.clone();          // {1, 2, 3}, a separate array

clone() effectue une copie superficielle : pour un tableau d'objets (ou un tableau à 2 dimensions, qui est un tableau de tableaux), les références internes sont partagées, pas dupliquées. Pour plus de détails sur la copie — notamment System.arraycopy et les copies profondes — consultez le chapitre dédié Copie de tableaux.

Conversion en List

Arrays.asList(...) encapsule un tableau (de références) en tant que List de taille fixe :

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

La taille est fixe : add/remove lèvent une UnsupportedOperationException, mais vous pouvez utiliser list.set(...). Notez que asList ne fonctionne pas avec les tableaux de types primitifs comme vous pourriez l'espérer — Arrays.asList(new int[]{1, 2, 3}) produit une List<int[]> de longueur 1, pas une List<Integer>. Pour les types primitifs, utilisez les streams :

import java.util.stream.IntStream;

int[] nums = {1, 2, 3};
List<Integer> boxed = IntStream.of(nums).boxed().toList();

Hachage

Arrays.hashCode(arr) produit un hash basé sur le contenu que vous pouvez utiliser dans les implémentations equals/hashCode d'une classe contenante :

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

Pour les tableaux imbriqués, utilisez Arrays.deepHashCode.

Un exemple concret

Étape suivante

Les méthodes utilitaires que vous venez d'utiliser — toString, fill, equals, copyOf, binarySearch, sort — se trouvent toutes sur la même classe : java.util.Arrays. Le prochain chapitre examine la classe utilitaire Arrays de manière systématique, y compris les points que nous avons survolés ici.

Pratique