Un tableau est un ensemble indexé de données d'un même type. L'utilisation d'un tableau se décompose en trois parties :

• Création du tableau ;
• Remplissage du tableau ;
• Lecture du tableau.

Création d'un tableau

Un tableau se déclare et s'instancie comme une classe :

int monTableau[ ] = new int[10];

ou

int [ ] monTableau = new int[10];

L'opérateur [ ] permet d'indiquer qu'on est en train de déclarer un tableau.

Dans l'instruction précédente, nous déclarons un tableau d'entiers (int, integer) de taille 10, c'est-à-dire que nous pourrons stocker 10 entiers dans ce tableau.

Si [ ] suit le type, toutes les variables déclarées seront des tableaux, alors que si [ ] suit le nom de la variable, seule celle-ci est un tableau :

int [] premierTableau, deuxiemeTableau;
float troisiemeTableau[], variable;

Dans ces quatre déclarations, seule variable n'est pas un tableau.

Remplissage d'un tableau

Une fois le tableau déclaré et instancié, nous pouvons le remplir :

int [] monTableau = new int[10];

monTableau[5] = 23;

L'indexation démarre à partir de 0, ce qui veut dire que, pour un tableau de N éléments, la numérotation va de 0 à N-1.

Dans l'exemple ci-dessus, la 6^ème case contient donc la valeur 23.

Nous pouvons également créer un tableau en énumérant son contenu :

int [] monTableau = {5,8,6,0,7};

Ce tableau contient 5 éléments.

Lorsque la variable est déjà déclarée, nous pouvons lui assigner d'autres valeurs en utilisant l'opérateur new :

monTableau = new int[]{11,13,17,19,23,29};

Lecture d'un tableau

Pour lire ou écrire les valeurs d'un tableau, il faut ajouter l'indice entre crochets ([ et ]) à la suite du nom du tableau :

int [] monTableau = {2,3,5,7,11,23,17};
int nb;

monTableau[5] = 23;  // ->  2 3 5 7 11 23 17
nb = monTableau[4];  // 11

L'indice 0 désigne le premier élément du tableau.

L'attribut length d'un tableau donne sa longueur (le nombre d'éléments). Donc pour un tableau nommé monTableau l'indice du dernier élément est monTableau.length-1.

Ceci est particulièrement utile lorsque nous voulons parcourir les éléments d'un tableau.

for (int i = 0; i < monTableau.length; i++) {
    int element = monTableau[i];
    // traitement
}

Les tableaux en Java 5

Java 5 fournit un moyen plus court de parcourir un tableau.

L'exemple suivant réalise le traitement sur monTableau :

for (int element : monTableau){
   // traitement
}

Attention néanmoins, la variable element contient une copie de monTableau[i]. Avec des tableaux contenant des variables primitives, toute modification de element n'aura aucun effet sur le contenu du tableau.

// Vaine tentative de remplir tous les éléments du tableau avec la valeur 10
for(int element : monTableau){
    element=10;
}

// La bonne méthode :
for(int i=0; i < monTableau.length; i++){
    monTableau[i]=10;
}

Tableaux à plusieurs dimensions

En Java, les tableaux à plusieurs dimensions sont en fait des tableaux de tableaux.

Exemple, pour allouer une matrice de 5 lignes de 6 colonnes :

int[][] matrice=new int[5][];
for (int i=0 ; i<matrice.length; i++)
    matrice[i]=new int[6];

Java permet de résumer l'opération précédente en :

int[][] matrice=new int[5][6];

La première version montre qu'il est possible de créer un tableau de tableaux n'ayant pas forcément tous la même dimension.

On peut également remplir le tableau à la déclaration et laisser le compilateur déterminer les dimensions des tableaux, en imbriquant les accolades :

 int[][] matrice =
    {
        { 0, 1, 4, 3 } , // tableau [0] de int
        { 5, 7, 9, 11, 13, 15, 17 } // tableau [1] de int
    };

Pour déterminer la longueur des tableaux, on utilise également l'attribut length :

matrice.length     //  2
matrice[0].length  //  4
matrice[1].length  //  7

De la même manière que précédement, on peut facilement parcourir tous les éléments d'un tableau :

for (int i=0 ; i<matrice.length ; i++)
{
	for (int j=0 ; j<matrice[i].length ; j++)
	{
		//Action sur matrice[i][j]
	}
}

Depuis Java 5, il est possible de parcourir les valeurs comme ceci :

for (int[] row : matrice)
{
	for (int j=0 ; j<row.length ; j++)
	{
		//Action sur row[j]
	}
}

Le parcours des éléments du tableau row peut également utiliser la boucle for itérative sur le type primitif int. Ce type de boucle ne permet pas de modifier les éléments du tableau.

for (int[] row : matrice)
{
	// Modifications sur row[index] répercutées sur matrice[...][index]
	// Modifications sur row ignorées
	for (int cell : row)
	{
		// Action sur cell
		// Modifications sur cell ignorées
	}
}

Pour une matrice d'objet, cela est donc également possible :

String[][] matrice_de_themes =
{
	{ "Java", "Swing", "JavaFX" },
	{ "Python", "Numpy" },
	{ "Vélo", "Chambre à air", "Rustine", "Guidon" },
	{ "Cuisine", "Recette", "Ingrédient", "Préparation", "Ustensile" },
};
for (String[] ligne_theme : matrice_de_themes)
{
	for (String mot : ligne_theme)
	{
		//Action sur mot
		System.out.println(mot);
	}
}

La classe Arrays

La classe Arrays du package java.util possède plusieurs méthodes de gestion des tableaux de types de base, et d'objets :

• la méthode asList convertit un tableau en liste,
• la méthode binarySearch effectue la recherche binaire d'une valeur dans un tableau,
• la méthode equals compare deux tableaux renvoie un booléen true s'ils ont même longueur et contenu,
• la méthode fill remplit un tableau avec la valeur donnée,
• la méthode sort trie un tableau dans l'ordre croissant de ses éléments.

Exemple de source :

import java.util.*;
 
public class ArrayExample {
 
  static Scanner input = new Scanner(System.in);
 
  public static void main(String[] args) {
    int numNoms = getInt("Nombre d'entrées du tableau ?");
    String[] noms = new String[numNoms];
    for (int i = 0; i < noms.length; i++) {
      noms[i] = getString("Entrée n°" + (i+1));
    }
    for (int i = 0; i < noms.length; ++i) {
      System.out.println(noms[i]);
    }
  }
 
  public static int getInt(String prompt) {
    System.out.print(prompt + " ");
    int entier = input.nextInt();
    input.nextLine(); // Get rid of this line
    // so that getString won't read it
    return entier;
  }
 
  public static String getString(String prompt) {
    System.out.print(prompt + " ");
    return input.nextLine();
  }
}

Par défaut, Arrays.sort() place les caractères non ASCII après le "z" (ex : à, é...). Pour tenir compte de l'Unicode, il faut donc remplir son deuxième paramètre, avec un java.text.Collator ou un java.util.Comparator.

Copie d'un tableau

La copie d'un tableau implique la copie de ses éléments dans un autre tableau. Dans le cas d'un tableau d'objets, seules les références à ces objets sont copiées, aucun nouvel objet n'est créé.

La méthode arraycopy de la classe System permet de copier tout ou partie d'un tableau vers un autre tableau déjà alloué.

Comme toutes les classes, les tableaux dérivent de la classe java.lang.Object. Les méthodes de la classe Object sont donc utilisables :

int[] premiers = { 2, 3, 5, 7, 11 };
System.out.println( premiers.toString() ); // Par défaut <type>@<hashcode>, exemple : [I@a108298c
System.out.println( Arrays.toString(premiers) );  // Pour afficher son contenu à l'écran

La copie intégrale d'un tableau dans un nouveau tableau peut donc se faire en utilisant la méthode clone(). La valeur retournée par cette méthode étant de type Object, il faut la convertir dans le type concerné.

Exemple :

int[] nombres = { 2, 3, 5, 7, 11 };
int[] copie = (int[]) nombres.clone();
nombres[1]=4; // nombres contient 2 4 5 7 11
// tandis que copie contient toujours 2 3 5 7 11

Somme des éléments d'un tableau

public class SommeTableaux
{
	public static void main(String[] args)
	{
		int[] nb = {1,2,3,4,5,6,7,8,9};
		int somme = java.util.stream.IntStream.of(nb).sum();
		System.out.println(somme); //45
	}
}

Comparaison de deux tableaux

Il serait possible de lancer des boucles de comparaison, mais le plus court moyen donne un avant-goût du chapitre Collections :

import java.util.*;
public class CompareTableaux
{
	public static void main(String[] args)
	{
		String[]
			arr1 = { "2", "3", "5", "7", "11" },
			arr2 = { "2", "4", "6", "8", "11", "12" };

		List<String> l1 = Arrays.asList(arr1);
		List<String> l2 = Arrays.asList(arr2);

		HashSet<String> communs = new HashSet<String>(l1);
		communs.retainAll(l2);

		HashSet<String> non_communs = new HashSet<String>(l1);
		non_communs.addAll(l2);
		non_communs.removeAll(communs);

		System.out.println(communs);      // [11, 2]
		System.out.println(non_communs);  // [12, 3, 4, 5, 6, 7, 8]
	}
}