Classe de tableaux

Rebonjour! :) Dans la leçon d'aujourd'hui, nous parlerons de la classe Arrays en Java. Dans la dernière leçon, nous avons appris à connaître une telle structure de données appelée tableau. Nous avons appris à les créer et à les remplir de données. Et nous avons regardé comment ils sont stockés en mémoire. Aujourd'hui, nous allons examiner certaines tâches et exemples de travail avec des tableaux que vous verrez souvent dans le cadre d'un travail réel. Par exemple, imaginez cette situation : nous avons un tableau de 10 nombres aléatoires.

int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

Notre tâche est de trier ce tableau par ordre croissant : du plus petit au plus grand. Au final, cela devrait ressembler à ceci : [-234, -2, 16, 26, 35, 43, 92, 99, 167] Comment fait-on cela ? Cette tâche n'est pas triviale. Nous n'avons jamais fait cela auparavant :/ Des idées ? Essaie de deviner. Voici une solution :

• Parcourez tous les éléments du tableau. Comparez chaque élément avec le suivant ([0] avec [1], [1] avec [2], [2] avec [3], etc.). Si l'élément actuel est supérieur au suivant, nous les échangeons, puis passons à l'élément suivant. Sinon, laissez-les tels quels et passez à autre chose
• Ainsi, après le premier passage dans les éléments, la plus grande valeur (167) est garantie d'être dans la dernière cellule.
• Maintenant, nous allons revoir tous les éléments, mais cette fois nous allons commencer par l'indice [0] jusqu'à l'avant-dernier élément (le plus grand nombre est déjà à sa place) et faire les mêmes comparaisons et permutations. Après cette passe, dans l'avant-dernière cellule, nous aurons la deuxième plus grande valeur (99).
• Répétez ce processus autant de fois que nous avons d'éléments de tableau.

Nous avons l'idée. Il ne nous reste plus qu'à écrire le code. Il ressemble à ceci :

public class Main {

   public static void main(String[] args) {
      
       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       for (int i = numbers.length - 1; i > 0; i--) {
           for (int j = 0; j < i; j++) {
           /* Compare the elements in pairs.
             If they are not in the right order,
             then swap them */
               if (numbers[j] > numbers[j + 1]) {
                   int tmp = numbers[j];
                   numbers[j] = numbers[j + 1];
                   numbers[j + 1] = tmp;
               }
           }
       }

   }
}

Euh... Ça a l'air un peu compliqué -_- Même si le principe général est compréhensible, il faut quand même écrire pas mal de code pour résoudre une tâche aussi simple. OK, peut-être qu'on s'est juste surestimé ? La tâche à laquelle nous nous sommes attaqués est probablement encore trop compliquée pour nous. Essayons quelque chose de plus simple. Par exemple, prenez le même tableau de nombres.

int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

Notre tâche consiste à copier son contenu dans un autre tableau.

int [] numbersCopy = new int[10];

Pensez à la façon dont vous le feriez en utilisant ce que vous savez déjà sur les tableaux ? Par exemple, vous pouvez parcourir le tableau des nombres dans une boucle et écrire séquentiellement ses éléments dans numbersCopy :

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = new int[10];
      
       for (int i = 0; i < numbers.length; i++) {
          
           numbersCopy[i] = numbers[i];
       }

   }
}

Eh bien, euh, ici, nous l'avons essentiellement fait! Il semble que nous ayons résolu le problème. Cependant, si vous devez le faire souvent, votre code aura un tas de boucles identiques. En fait, ces tâches (et d'autres) ont longtemps été résolues par les créateurs de Java. Nous n'avons pas besoin de "réinventer la roue" et de coder notre propre solution. Il existe une classe statique spéciale ( Arrays ) pour vous aider à effectuer des tâches courantes lorsque vous travaillez avec des tableaux. Des méthodes pour effectuer les tâches les plus courantes auxquelles sont confrontés les programmeurs Java ont été ajoutées à cette classe. Par exemple, la tâche de tri d'un tableau, que nous avons essayé de gérer, est résolue en une seule ligne :

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
      
       Arrays.sort(numbers);

       System.out.println(Arrays.toString(numbers));

   }
}

La méthode Arrays.sort() trie le tableau. Et son algorithme est beaucoup plus efficace que le code que nous avons écrit. Sortie console : [-234, -2, 16, 26, 35, 43, 80, 92, 99, 167] Remarque : Pour convertir le tableau en chaîne, nous avons utilisé une autre méthode de la classe Arrays : Arrays.toString() . Les tableaux en Java ne remplacent pas la méthode toString() par eux-mêmes. Donc, si vous écrivez simplement

System.out.println(numbers.toString());

toString() de la classe Object sera appelée. Pour un tableau, la sortie sera quelque chose comme ceci : [I@4554617c Nous n'entrerons pas dans les détails maintenant sur la raison exacte pour laquelle il s'agit de la sortie. L'essentiel est que ce n'est clairement pas ce dont nous avons besoin. Mais Arrays.toString() fait précisément ce que nous voulons. D'ailleurs, la copie est aussi facilement accomplie avec la classe Arrays :

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = Arrays.copyOf(numbers, numbers.length);
       System.out.println(Arrays.toString(numbersCopy));

   }
}

Nous passons à la méthode Arrays.copyOf() notre tableau d'origine (dont nous voulons copier les valeurs) et la longueur du nouveau tableau dans lequel nous copions les données. Dans ce cas, nous avons indiqué nombres.longueur comme longueur, puisque nous voulons copier le tableau entier. Si nous voulions copier uniquement les premiers éléments, nous pouvons spécifier la longueur d'un nouveau tableau plus petit :

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = Arrays.copyOf(numbers, 4);
       System.out.println(Arrays.toString(numbersCopy));

   }
}

Ici, nous avons spécifié 4 comme longueur du nouveau tableau. En conséquence, seuls les 4 premiers éléments de nombres seront copiés dans le nouveau tableau. Sortie de la console : [167, -2, 16, 99] Au fait, Arrays vous permet également de copier une partie d'un tableau à partir du milieu plutôt qu'au début du tableau :

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = Arrays.copyOfRange(numbers, 2,6);
       System.out.println(Arrays.toString(numbersCopy));

   }
}

Sortie : [16, 99, 26, 92] Les nombres ont été copiés dans le nouveau tableau à partir du deuxième tableau du deuxième (inclus) au sixième élément (non inclus). Nous pouvons également avoir besoin de comparer deux tableaux. Comme avec la méthode toString() , les tableaux eux-mêmes ne remplacent pas la méthode equals() . Donc, si nous essayons de les comparer comme ça

public class Main {

   public static void main(String[] args) {

       int[] numbers = {1, 2, 3};
       int[] numbers2 = {1, 2, 3};

       System.out.println(numbers.equals(numbers2));
   }
}

alors nous obtenons faux. En effet, Object.equals() , qui compare les références, sera appelé. Et, évidemment, ils sont différents ! Mais ce dont nous avons besoin, c'est de comparer le contenu du tableau, pas les références. La classe Arrays remplace la méthode equals() pour lui faire faire exactement ce que nous voulons :

public class Main {

   public static void main(String[] args) {

       int[] numbers = {1, 2, 3};
       int[] numbers2 = {1, 2, 3};

       System.out.println(Arrays.equals(numbers, numbers2));
   }
}

Sortie : true À propos, la classe Arrays fonctionne non seulement avec des tableaux ordinaires, mais également avec des tableaux à deux dimensions :

public class Main {

   public static void main(String[] args) {

       int[][] numbers = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

       int[][] numbersCopy = Arrays.copyOf(numbers, numbers.length);

       System.out.println("Are these two-dimensional arrays equal?");
       System.out.println(Arrays.deepEquals(numbers, numbersCopy));
      
       System.out.println(Arrays.deepToString(numbersCopy));
   }
}

Sortie : ces tableaux à deux dimensions sont-ils égaux ? true [[1, 2, 3], [4, 5, 6], [7, 8, 9]] Comme vous pouvez le voir, la méthode Arrays.copyOf() a pu copier un tableau à deux dimensions. Et la classe a des méthodes spéciales pour comparer et afficher des tableaux à deux dimensions : deepEquals et deepToString() . À l'avenir, vous verrez à plusieurs reprises (et vous vous en réjouirez) que les créateurs de Java ont anticipé de nombreuses situations fréquemment rencontrées par les programmeurs et ont implémenté des solutions toutes faites pour eux dans le langage. Utiliser ces solutions est beaucoup plus simple et pratique que de réinventer la roue, n'est-ce pas ? :) Assurez-vous de lire la documentation de la classe Arrays sur le site Web d'Oracle . Bonne chance dans tes études!