Tableaux de classe d'assistance

1. Arraysclasse

Comme nous l'avons noté précédemment, les tableaux sont très utiles et fréquemment utilisés en programmation.

Les créateurs de Java ont très vite remarqué que les programmeurs Java écrivaient souvent le même code lorsqu'ils travaillaient avec des tableaux. Par exemple, copier une partie d'un tableau dans un autre tableau, coder pour remplir chaque cellule d'un tableau avec la même valeur, afficher le contenu d'un tableau dans un format pratique, etc.

C'est pourquoi ils ont créé la Arraysclasse spéciale (son nom complet est java.util.Arrays), en y mettant les actions les plus populaires liées aux tableaux.

Il propose de nombreuses méthodes pour chaque occasion, mais nous n'en examinerons d'abord que 10 - les plus simples et les plus souvent utilisées.

2.Arrays.toString()

La première méthode que nous allons examiner s'appelle Arrays.toString(). Mais d'abord, un peu de contexte.

Chaque tableau en Java a une toString()méthode qui renvoie une "représentation textuelle du tableau". Vous pouvez obtenir une représentation textuelle d'un tableau à l'aide de l'instruction suivante :

String str = name.toString();

Où nameest le nom de la variable de tableau et strest le nom de la variable qui stockera la représentation sous forme de chaîne du tableau.

Mais si vous essayez d'imprimer le tableau à l'écran en utilisant la méthode, vous verrez très probablement quelque chose comme ceci :System.out.println(name)

I@37afeb11

La première lettre Isignifie qu'il s'agit d'un inttableau et les symboles suivants @sont l'adresse du tableau en mémoire. D'une part, c'est précisément l'information stockée dans la variable tableau, mais d'autre part, nous nous attendions à quelque chose de différent, n'est-ce pas ?

Nous voulions voir les valeurs dans le tableau ! Et c'est exactement pourquoi ils ont trouvé la Arrays.toString()méthode — pour afficher les valeurs d'un tableau. Nous l'appelons ainsi :

String str = Arrays.toString(name);

Exemples:

int[] array = {1, 2, 3};
String str = Arrays.toString(array);

"[1, 2, 3]"

int[] array = {};
String str = Arrays.toString(array);

"[]"

String[] array = {"Hi", "How's", "life?"};
String str = Arrays.toString(array);

"[Hi, How's, life?]"

3.Arrays.deepToString()

Mais si vous essayez de convertir un tableau à deux dimensions en une using the Arrays.toString()méthode de chaîne (pour l'afficher), vous verrez quelque chose de familier :

[I@37afeb11, I@37afeb21, I@37afeb31]

Tout cela est dû au fait que les cellules d'un tableau à deux dimensions stockent des références à des tableaux à une dimension. Et comment les tableaux unidimensionnels sont-ils convertis en chaîne ? Exactement comme vous le voyez ci-dessus.

Ce qui peut être fait? Comment afficher correctement un tableau à deux dimensions ?

À cette fin, la Arraysclasse a une autre méthode spéciale — deepToString(). L'appel ressemble à ceci:

String str = Arrays.deepToString(name);

Cette méthode peut être transmise à des tableaux à deux dimensions, à une dimension, à trois dimensions ou, en général, à n'importe quelle dimension, et elle affichera toujours les éléments du tableau.
Remarque : la Arrays.deepToString()méthode ne fonctionne pas avec des tableaux unidimensionnels de primitives (par exemple, int[]).

Exemples:

Integer[] array = {1, 2, 3};
String str = Arrays.deepToString(array);

"[1, 2, 3]"

int[][] array = { {1, 1}, {2, 2}, {3, 3} };
String str = Arrays.deepToString(array);

"[[1, 1], [2, 2], [3, 3]]"

int[][][] array = { {{1, 2, 3}, {1}}, {{}} };
String str = Arrays.deepToString(array);

"[[[1, 2, 3], [1]], [[]]]"

4.Arrays.equals()

Nous avons compris comment afficher des tableaux à l'écran, mais qu'en est-il de la comparaison de tableaux ?

Pour comparer des chaînes, nous avons des méthodes equalset equalsIgnoreCase, mais quelles méthodes les tableaux ont-ils ?

La bonne nouvelle est que les tableaux ont une equalsméthode. La mauvaise nouvelle est qu'il ne compare pas le contenu des tableaux. La equalsméthode des tableaux fait la même chose que l' ==opérateur — elle compare les références. Exemples:

Exemples:

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
boolean b = x1 == x2;

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
x1.equals(x2);

Ce qui peut être fait? Comment comparer les tableaux en fonction de leur contenu ?

Et encore le Arraysvient à notre rescousse, ou plus précisément, sa Arrays.equals()méthode. C'est ainsi que nous l'appelons :

Arrays.equals(name1, name2)

La méthode retourne truesi les tableaux sont de longueur égale et si leurs éléments sont égaux. Sinon, ça revient false.

Exemples:

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
x1.equals(x2);

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
Arrays.equals(x1, x2);

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3, 4};
Arrays.equals(x1, x2);

5.Arrays.deepEquals()

Et, comme vous l'avez probablement déjà deviné, la Arrays.equalsméthode ne fonctionnera pas correctement pour les tableaux à deux dimensions : elle traite les tableaux à deux dimensions comme un tableau à une dimension dont les éléments sont des adresses de tableaux à une dimension.

Ainsi, pour comparer correctement les tableaux multidimensionnels ( n = 1, 2, 3,...), ils ont proposé la Arrays.deepEquals()méthode. L'appel ressemble à ceci:

Arrays.deepEquals(name1, name2)

La méthode retournetruesi les tableaux sont de longueur égale et leurs éléments sont égaux. Sinon, il revientfalse. Si les éléments à l'intérieur du tableau sont également des tableaux, alors la Arrays.deepEquals()méthode est utilisée pour les comparer, et ainsi de suite.

Exemples:

int[][] x1 = {{1, 2, 3}, {4, 5, 6}};
int[][] x2 = {{1, 2, 3}, {4, 5, 6}};
x1.equals(x2);

int[][] x1 = {{1, 2, 3}, {4, 5, 6}};
int[][] x2 = {{1, 2, 3}, {4, 5, 6}};
Arrays.equals(x1, x2);

int[][] x1 = {{1, 2, 3}, {4, 5, 6}};
int[][] x2 = {{1, 2, 3}, {4, 5, 6}};
Arrays.deepEquals(x1, x2);