Tableaux en Java: un 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:

  • Premiers pas avec les tableaux
  • Lire et écrire des éléments de tableaux
  • Boucle sur un tableau
  • Transformez les tableaux en d'autres objets tels que List ou Streams
  • 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? Selon la documentation Java, un tableau est un objet contenant un nombre fixe de valeurs du même type . Les éléments d'un tableau sont indexés, ce qui signifie que nous pouvons y accéder avec des nombres (appelés indices ).

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 de type int, float, boolean,… Mais aussi des tableaux de type String, Object et custom.

3. Configuration d'une baie

Maintenant que les tableaux sont bien définis, plongons dans leurs utilisations.

Nous aborderons de nombreux sujets en nous apprenant à utiliser les tableaux. Nous apprendrons quelques notions de base comme comment déclarer et initialiser un tableau, mais nous couvrirons é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 allons commencer par la déclaration. Il existe deux façons de déclarer un tableau en Java:

int[] anArray;

ou:

int anOtherArray[];

Le premier est plus largement utilisé que le second .

3.2. Initialisation

Maintenant, il est temps de voir comment initialiser les tableaux. Là encore, il existe plusieurs façons d'initialiser un tableau. Nous verrons les principaux ici, mais cet 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éments int . Notez que nous devons spécifier la taille du tableau.

Lors de l'utilisation de cette méthode, nous initialisons chaque élément à sa valeur par défaut , ici 0 . Lors de l'initialisation d'un tableau d' Object , les éléments sont nuls 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 de 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 alors déclaré entre les accolades.

4. Accès aux éléments

Voyons maintenant comment accéder aux éléments d'un tableau. Nous pouvons y parvenir en exigeant une position de cellule de 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 indices pour accéder aux cellules du tableau. Le nombre entre crochets est la position spécifique du tableau auquel nous voulons accéder.

Lors de l'accès à une cellule, si l'index passé est négatif ou dépasse la dernière cellule, Java lèvera une ArrayIndexOutOfBoundException .

Nous devons faire attention alors à ne pas utiliser un index négatif, ou un index supérieur ou égal à la taille du tableau .

5. Itération sur un tableau

Accéder aux éléments un par un peut être utile, mais nous pourrions vouloir parcourir un tableau. Voyons comment nous pouvons y parvenir.

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

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. Comme nous pouvons le voir, nous avons utilisé la propriété length . Il s'agit d'une propriété publique nous donnant la taille du tableau.

Bien sûr, il est possible d'utiliser d'autres mécanismes de boucle tels que while ou do while . Mais, comme pour les collections Java, il est possible de boucler sur des tableaux en utilisant la boucle foreach :

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

This example is equivalent to the previous one, but we got rid of the indices boilerplate code. The foreach loop is an option when:

  • we don't need to modify the array (putting another value in an element won't modify the element in the array)
  • we don't need the indices to do something else

6. Varargs

We've already covered the basics when it comes to the creation and manipulation of arrays. Now, we'll dive into more advanced topics, beginning with varargs. As a reminder, varargs are used to pass an arbitrary number of arguments to a method:

void varargsMethod(String... varargs) {}

This method could take from 0 to an arbitrary number of String arguments. An article covering varargs can be found here.

What we have to know here is that inside the method body, a varargs parameter turns into an array. But, we can also pass an array directly as the argument. Let's see how by reusing the example method declared above:

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

Will behave the same as:

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

7. Transforming an Array into a List

Arrays are great, but sometimes it can be handier to deal with List instead. We'll see here how to transform an array into a List.

We'll first do it the naïve way, by creating an empty list and iterating over the array to add its elements to the list:

int[] anArray = new int[] {1, 2, 3, 4, 5}; List aList = new ArrayList(); for (int element : anArray) { aList.add(element); }

But there is another way, a little bit more succinct:

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. Unfortunately, this method comes with some drawbacks:

  • It's not possible to use an array of primitive types
  • We can't add or remove elements from the created list, as it'll throw an UnsupportedOperationException

8. From an Array to a Stream

We can now transform arrays into lists, but since Java 8 we have access to the Stream API and we might want to turn our arrays into Stream. Java provides us with the Arrays.stream method for that:

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

When passing an Object array to the method it will return a Stream of the matching type (e.g. Stream for an array of Integer). When passing a primitive one it will return the corresponding primitive Stream.

It's also possible to create the stream only on a subset of the array:

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

This will create a Stream with only “Tomato” and “Chips” Strings (the first index being inclusive while the second one is exclusive).

9. Sorting Arrays

Let's now see how to sort an array, that is rearranging its elements in a certain order. The Arrays class provides us with the sort method. A bit like the stream method, sort has a lot of overloadings.

There are overloadings to sort:

  • Primitive type arrays: which are sorted in ascending order
  • Object arrays (those Object must implement the Comparable interface): which are sorted according to the natural order (relying on the compareTo method from Comparable)
  • Generic arrays: which are sorted according to a given Comparator

In addition, it's possible to sort only a specific portion of an array (passing start and end indices to the method).

The algorithms behind the sort method are quick sort and merge sort for primitive and other arrays, respectively.

Let's see how this all work through some examples:

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. Searching in an Array

Searching an array is pretty simple, we can loop over the array and search our element among the array elements:

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; } }

Here we searched for number 4 and found it at index 3.

If we have a sorted array though, we can use another solution: the binary search. The principle of binary search is explained in this article.

Fortunately, Java provides us with the Arrays.binarySearch method. We have to give it an array and an element to search.

In case of a generic array, we also have to give it the Comparator that was used to sort the array in the first place. There is again the possibility to call the method on a subset of the array.

Let's see an example of the binary search method usage:

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

As we stored number 4 in the fourth cell, this will return index 3 as the result. Note that we used an already sorted array.

11. Concatenating Arrays

Finally, let's see how to concatenate two arrays. The idea is to create an array which length is the sum of the two arrays to concatenate. After that we have to add 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]); }

As we can see, when the index is still lesser than the first array length we add elements from that array. Then we add elements from the second one. We can make use of the Arrays.setAll method to avoid writing a loop:

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]));

This method will set all array element according to the given function. This function associates an index with a result.

Voici une troisième option pour fusionner en tableaux: System.arraycopy . Cette méthode prend un tableau source , une position source, un tableau de destination , une position de destination et un entier 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 on peut le voir, on copie 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 gérer les tableaux via la classe utilitaire Arrays . Il existe également des classes utilitaires pour manipuler des tableaux dans des bibliothèques telles que Apache Commons ou Guava.

Le code complet de cet article est disponible sur notre GitHub.