TOC

Arrays in Java: Un guide de référence

Tableaux en Java: Guide de référence

1. introduction

Dans ce didacticiel, nous allons approfondir un concept de base du langage Java: les tableaux.

Nous verrons d'abord ce qu'est un tableau, puis comment les utiliser; dans l'ensemble, nous verrons comment:

  • Commencez avec des tableaux

  • Lire et écrire des éléments de tableaux

  • Boucle sur un tableau

  • Transformez les tableaux en d'autres objets commeList ouStreams

  • Trier, rechercher et combiner des tableaux

2. Qu'est-ce qu'un tableau?

Tout d'abord, nous devons définir ce qu'est un tableau? Selonthe Java documentation, un tableau estan object containing a fixed number of values of the same type. Les éléments d'un tableau sont indexés, ce qui signifie que nous pouvons y accéder avec des nombres (appelésindices).

On peut considérer un tableau comme une liste numérotée de cellules, chaque cellule étant une variable contenant une valeur. En Java, la numérotation commence à 0.

Il existe des tableaux de types primitifs et des tableaux de types d'objets. Cela signifie que nous pouvons utiliser des tableaux deint, float, boolean, … mais aussi des tableaux deString, Object et des types personnalisés.

3. Mettre en place un tableau

Maintenant que les tableaux sont bien définis, passons à leurs utilisations.

Nous aborderons de nombreux sujets pour nous apprendre à utiliser les tableaux. Nous apprendrons quelques notions de base comme la déclaration et l'initialisation d'un tableau, mais nous aborderons également des sujets plus avancés comme le tri et la recherche de tableaux.

Commençons par la déclaration et l’initialisation.

3.1. Déclaration

Nous commencerons par la déclaration. Il existe deux manières de déclarer un tableau en Java: 

int[] anArray;

or: 

int anOtherArray[];

The former is more widely used than the latter.

3.2. Initialisation

Il est maintenant temps de voir comment initialiser les tableaux. Là encore, il existe plusieurs façons d’initialiser un tableau. Nous verrons les principaux ici, maisthis article couvre en détail l'initialisation des tableaux.

Commençons par un moyen simple: 

int[] anArray = new int[10];

En utilisant cette méthode, nous avons initialisé un tableau de dix élémentsint. Notez que nous devons spécifier la taille du tableau.

Lors de l'utilisation de cette méthode,we initialize each element to its default value, ici 0. Lors de l'initialisation d'un tableau deObject, les éléments sontnull par défaut.

Nous allons maintenant voir une autre façon nous donnant la possibilité de définir des valeurs sur le tableau directement lors de sa création: 

int[] anArray = new int[] {1, 2, 3, 4, 5};

Ici, nous avons initialisé un tableau de cinq éléments contenant les nombres 1 à 5. Lorsque vous utilisez cette méthode, nous n'avons pas besoin de spécifier la longueur du tableau, c'est le nombre d'éléments ensuite déclarés entre les accolades.

4. Accéder aux éléments

Voyons maintenant comment accéder aux éléments d'un tableau. Nous pouvons y parvenir en exigeant une position de cellule sur un tableau.

Par exemple, ce petit extrait de code imprimera 10 sur la console: 

anArray[0] = 10;
System.out.println(anArray[0]);

Notez comment nous utilisons des index pour accéder aux cellules du tableau. The number between the brackets is the specific position of the array we want to access.

Lors de l'accès à une cellule, si l'index passé est négatif ou va au-delà de la dernière cellule, Java lancera unArrayIndexOutOfBoundException.

Nous devons faire attention alorsnot to use a negative index, or an index greater than or equal to the array size.

5. Itérer sur un tableau

L'accès aux éléments un par un peut être utile, mais nous pouvons vouloir parcourir un tableau. Voyons comment nous pouvons y parvenir.

La première façon est d'utiliser la bouclefor: 

int[] anArray = new int[] {1, 2, 3, 4, 5};
for (int i = 0; i < anArray.length; i++) {
    System.out.println(anArray[i]);
}

Cela devrait imprimer les numéros 1 à 5 sur la console. As we can see we made use of the length property. This is a public property giving us the size of the array.

Bien entendu, il est possible d’utiliser d’autres mécanismes de boucle tels quewhile oudo while. Mais, comme pour les collections Java, il est possible de boucler sur des tableaux en utilisant la boucleforeach: 

int[] anArray = new int[] {1, 2, 3, 4, 5};
for (int element : anArray) {
    System.out.println(element);
}

Cet exemple est équivalent au précédent, mais nous nous sommes débarrassés du code standard des indices. The foreach loop is an option when:

  • nous n'avons pas besoin de modifier le tableau (mettre une autre valeur dans un élément ne modifiera pas l'élément dans le tableau)

  • nous n'avons pas besoin des index pour faire autre chose

6. Varargs

Nous avons déjà couvert les bases de la création et de la manipulation de tableaux. Nous allons maintenant aborder des sujets plus avancés, en commençant parvarargs. Pour rappel, lesvarargs sont utilisés pour passer un nombre arbitraire d'arguments à une méthode: 

void varargsMethod(String... varargs) {}

Cette méthode peut prendre de 0 à un nombre arbitraire d'argumentsString. Un article couvrantvarargs peut être trouvéhere.

Ce que nous devons savoir ici, c'est qu'à l'intérieur du corps de la méthode, un paramètrevarargs se transforme en tableau. Mais,we can also pass an array directly as the argument. Voyons comment en réutilisant l'exemple de méthode déclaré ci-dessus: 

String[] anArray = new String[] {"Milk", "Tomato", "Chips"};
varargsMethod(anArray);

Se comportera comme: 

varargsMethod("Milk", "Tomato", "Chips");

7. Transformer un tableau en liste

Les tableaux sont excellents, mais parfois il peut être plus pratique de traiter lesList à la place. Nous allons voir ici comment transformer un tableau en unList.

Nous allons d'abord le faire de manière naïve, en créant une liste vide et en itérant sur le tableau pour ajouter ses éléments à la liste: 

int[] anArray = new int[] {1, 2, 3, 4, 5};

List aList = new ArrayList<>();
for (int element : anArray) {
    aList.add(element);
}

Mais il y a une autre façon, un peu plus succincte: 

Integer[] anArray = new Integer[] {1, 2, 3, 4, 5};
List aList = Arrays.asList(anArray);

The static method Arrays.asList takes a varargs argument and creates a list with the passed values. Malheureusement, cette méthode présente quelques inconvénients:

  • Il n’est pas possible d’utiliser un tableau de types primitifs

  • Nous ne pouvons pas ajouter ou supprimer des éléments de la liste créée, car cela lancera unUnsupportedOperationException

8. D'un tableau à un ruisseau

Nous pouvons maintenant transformer les tableaux en listes, mais depuis Java 8, nous avons accès auxStream API et nous pourrions vouloir transformer nos tableaux enStream. Java nous fournit la méthodeArrays.stream pour cela: 

String[] anArray = new String[] {"Milk", "Tomato", "Chips"};
Stream aStream = Arrays.stream(anArray);

Lors du passage d'un tableauObject à la méthode, il retournera unStream du type correspondant (par exemple Stream<Integer> pour un tableau deInteger). En passant une primitive, il retournera la primitive correspondanteStream.

Il est également possible de créer le flux uniquement sur un sous-ensemble de la baie: 

Stream anotherStream = Arrays.stream(anArray, 1, 3);

Cela créera unStream<String> w avec uniquement «Tomato» et «Chips»Strings (le premier index étant inclusif tandis que le second est exclusif).

9. Tri des tableaux

Voyons maintenant comment trier un tableau, c'est-à-dire réorganiser ses éléments dans un certain ordre. The Arrays class provides us with the sort method. Un peu comme la méthodestream,sort a beaucoup de surcharges.

Il y a des surcharges à trier:

  • Tableaux de type primitif: triés par ordre croissant

  • TableauxObject (cesObject doivent implémenter l'interfaceComparable): qui sont triés selon l'ordre naturel (en s'appuyant sur la méthodecompareTo deComparable)

  • Tableaux génériques: qui sont triés selon unComparator donné

De plus, il est possible de ne trier qu’une partie spécifique d’un tableau (en passant les index de début et de fin à la méthode).

Les algorithmes derrière la méthodesort sont respectivementquick sort etmerge sort pour les tableaux primitifs et autres.

Voyons comment tout cela fonctionne à travers quelques exemples: 

int[] anArray = new int[] {5, 2, 1, 4, 8};
Arrays.sort(anArray); // anArray is now {1, 2, 4, 5, 8}

Integer[] anotherArray = new Integer[] {5, 2, 1, 4, 8};
Arrays.sort(anotherArray); // anotherArray is now {1, 2, 4, 5, 8}

String[] yetAnotherArray = new String[] {"A", "E", "Z", "B", "C"};
Arrays.sort(yetAnotherArray, 1, 3,
  Comparator.comparing(String::toString).reversed()); // yetAnotherArray is now {"A", "Z", "E", "B", "C"}

10. Recherche dans un tableau

La recherche dans un tableau est assez simple, nous pouvons parcourir le tableau et rechercher notre élément parmi les éléments du tableau: 

int[] anArray = new int[] {5, 2, 1, 4, 8};
for (int i = 0; i < anArray.length; i++) {
    if (anArray[i] == 4) {
        System.out.println("Found at index " + i);
        break;
    }
}

Ici, nous avons cherché le numéro 4 et l’avons trouvé à l’index 3.

If we have a sorted array though, we can use another solution: the binary search. Le principe de la recherche binaire est expliqué dansthis article.

Fortunately, Java provides us with the Arrays.binarySearch method. Nous devons lui donner un tableau et un élément à rechercher.

Dans le cas d'un tableau générique, nous devons également lui donner leComparator qui a été utilisé pour trier le tableau en premier lieu. Il est à nouveau possible d'appeler la méthode sur un sous-ensemble du tableau.

Voyons un exemple d'utilisation de la méthode de recherche binaire: 

int[] anArray = new int[] {1, 2, 3, 4, 5};
int index = Arrays.binarySearch(anArray, 4);
System.out.println("Found at index " + index);

Comme nous avons stocké le numéro 4 dans la quatrième cellule, cela retournera l'index 3 comme résultat. Notez que nous avons utilisé un tableau déjà trié.

11. Concaténer des tableaux

Enfin, voyons comment concaténer deux tableaux. The idea is to create an array which length is the sum of the two arrays to concatenate. Après cela, nous devonsadd the elements of the first one and then the elements of the second one: 

int[] anArray = new int[] {5, 2, 1, 4, 8};
int[] anotherArray = new int[] {10, 4, 9, 11, 2};

int[] resultArray = new int[anArray.length + anotherArray.length];
for (int i = 0; i < resultArray.length; i++) {
    resultArray[i] = (i < anArray.length ? anArray[i] : anotherArray[i - anArray.length]);
}

Comme nous pouvons le constater, lorsque l'index est toujours inférieur à la longueur du premier tableau, nous ajoutons des éléments de ce tableau. Ensuite, nous ajoutons des éléments du second. Nous pouvons utiliser la méthodeArrays.setAll pour éviter d'écrire une boucle: 

int[] anArray = new int[] {5, 2, 1, 4, 8};
int[] anotherArray = new int[] {10, 4, 9, 11, 2};

int[] resultArray = new int[anArray.length + anotherArray.length];
Arrays.setAll(resultArray, i -> (i < anArray.length ? anArray[i] : anotherArray[i - anArray.length]));

Cette méthode définira tous les éléments du tableau en fonction de la fonction donnée. Cette fonction associe un index à un résultat.

Voici une troisième option pour fusionner en tableaux:System.arraycopy. Cette méthode prend une sourcearray, une position source, une destinationarray, une position destination et unint  définissant le nombre d'éléments à copier: 

System.arraycopy(anArray, 0, resultArray, 0, anArray.length);
System.arraycopy(anotherArray, 0, resultArray, anArray.length, anotherArray.length);

Comme nous pouvons le constater, nous copions le premier tableau, puis le second (après le dernier élément du premier).

12. Conclusion

Dans cet article détaillé, nous avons couvert les utilisations basiques et avancées des tableaux en Java.

Nous avons vu que Java propose de nombreuses méthodes pour traiter les tableaux via lesArrays utility class. Il existe également des classes utilitaires pour manipuler des tableaux dans des bibliothèques telles queApache Commons ouGuava.

Le code complet de cet article est disponible surour GitHub.

Related