POO en Javammm

Pr: Ismaili Alaoui El Mehdi Filière: SMI-5

Programmation orientée objet en Java

Chapitre 5: Tableaux en Java

1 Introduction
Jusqu’ici, nous avons employé les variables pour stocker les valeurs individuelles de types
primitifs : une variable de type int pour stocker un entier, une variable de type boolean pour un
booléen, etc.
Un tableau est une structure regroupant plusieurs valeurs de même type, chacune étant stockée
dans un espace particulier appelé une case du tableau. On peut traiter un tableau comme un
tout, ou case par case. Traité comme un tout, on pourra le stocker dans une variable, le passer
en paramètre ou le donner en résultat d’un calcul. Chaque case est désignée individuellement
via son indice, qui correspond à sa position dans le tableau, et peut être traitée comme variable
individuelle : on pourra consulter sa valeur, la modifier, etc.

tab[0], tab[1], tab[2], tab[3], . . ., tab[6] } 7 Variables (cases)

Les tableaux sont des structures des données présentes dans tous les langages de programma-
tion.

2 Les tableaux à une dimension

2. 1 Déclaration de tableaux
Quand vous déclarez un tableau, Java dispose de deux syntaxes équivalentes pour la décla-
ration des tableaux:

type [] nomTab ;
type nomTab[];
2

L’utilisation de l’une ou l’autre de ces syntaxes est une affaire de goût personnel.

p Exemple:
int[] tab; //Déclaration d’un tableau d’entiers
char tab1[],tab2[];//Déclaration de 2 tableaux de caractères

Remarquez que la taille du tableau n’est pas spécifiée. La déclaration d’un tableau ne lui
alloue pas de mémoire. Dans la plupart des autre langages, la taille du tableau doit être indiquée
dans la déclaration, mais dans Java, vous ne spécifiez pas sa taille jusqu’au moment ou vous
l’utilisez. La mémoire appropriée est alors allouée.

p Exemple:
int tab [5];//Erreur ne compile pas

2. 2 Création de tableaux
Notez que la taille d’un tableau ne fait pas partie de sa déclaration. La création (donc allouer
réellement de la mémoire) devra donc indiquer la taille du tableau. La syntaxe à employer est la
suivante:

nomTab= new Type[Taille];

On peut simultanément déclarer et créer un tableau comme suit :

type nomTab[]= new Type[Taille];

La taille du tableau est déterminée par l’expression entre crochets qui doit avoir une valeur
entière positive. Une fois qu’un tableau est créé, sa taille ne peut plus modifier.

2. 2. 1 Valeurs par défaut à la création

Java initialise automatiquement les éléments des tableaux, avec la valeur 0 pour les primi-
tives entières (byte, short, int et long), 0.0 pour les primitives flottantes (float et double), false
pour les boolean et null pour les objets et les tableaux.
2 Les tableaux à une dimension 3

p Exemple:
int [] tb = new int[3];
char [] ch = new char[4];
boolean [] bt = new boolean[3];

2. 3 Les tableaux littéraux

Lorsqu’un tableau est de petite taille, il est possible de l’initialiser en donnant la liste des
valeurs de chaque case. On utilise la notation { v0 , v1 „ . . . vn }, où vi , est la valeur à donner
à la case i du tableau. Nous reprendrons souvent cette notation pour regrouper en une seule
instruction. Une expression d’initialisation peut être ajoutée à la déclaration; dans ce cas, le
tableau est créé et la taille est déterminée par le résultat de l’expression d’initialisation.

p Exemple:
char[] voyelles= {’a’,’e’,’i’,’o’,’u’,’y’};

Cette instruction crée un tableau de type char de 6 éléments appelé voyelles. Elle initialise
les éléments du tableau avec les 6 voyelles. Nous n’avons pas eu besoin d’utiliser l’opérateur
new pour créer ce tableau ; et enfin, les caractères ’a’,’e’,’i’,’o’,’u’, et ’y’ sont affectés aux élé-
ments voyelles[0], voyelles[1], voyelles[2], voyelles[3] , voyelles[4] et voyelles[5], la mémoire
nécessaire est automatiquement affectée au tableau pour y mettre les valeurs initialisées.
Les tableaux littéraux peuvent contenir des variables, comme dans l’exemple suivant :

p Exemple:
int a = 1, b = 2, c = 3, d = 4, e = 5;
int[] y = {a, b, c, d, e};

Ils peuvent même contenir des variables de types différents :

4

p Exemple:
byte a = 1;
short b = 2;
char c = 3;
int d = 4;
long e = 5;
long[] y = {a, b, c, d, e};

Cela n’est cependant possible que grâce à la particularité suivante : comme avec les opéra-
teurs, tous les éléments d’un tableau littéral sont sur-castés vers le type supérieur. Ici, bien que
chaque variable soit d’un type différent, tous les éléments du tableau littéral {a, b, c, d, e} sont
des long, ayant subi un sur-casting implicite vers le type de l’élément le plus long.

2. 4 Accéder aux éléments du tableau

Maintenant que nous avons un tableau, on va avoir besoin de récupérer les éléments dedans.
L’accès à une case de tableau permet de traiter cette case comme n’importe quelle variable in-
dividuelle : on peut modifier sa valeur dans le tableau, l’utiliser pour un calcul, un affichage,
etc. L’accès d’une case se fait via son indice ou position dans le tableau. En Java, la première
position a pour indice 0 et non 1, et la dernière, a l’indice n-1 (taille du tableau moins un).

Une fois le tableau initialisé, on accède aux éléments du tableau à l’aide de la syntaxe
suivante :

nomTab [indice]

p Exemple:
int[] tabCinq = {2,4,6,8,10};
int i = 0;
int x = tabCinq[i]; //x= 2, l’élément d’indice 0
int y = tabCinq[4]; //y= 10, l’élément d’indice 4
2 Les tableaux à une dimension 5

On modifie le contenu d’une case avec la construction d’affectation. Ainsi pour mettre à 0
la deuxième case du tableau tabCinq, on écrira tabCinq[1] = 0;
Une fois le tableau initialisé, il est possible à tout moment de connaître sa taille(son nombre de
cases) à l’aide de la variable d’instance length.

p Exemple:
int longueur = tabCinq.length;// longueur vaut maintenant 5.

Si on tente d’accéder en dehors des bornes du tableau(indice<0 ou indice>=nomTab.length),

par exemple en écrivant tabCinq[-1], alors on obtient une erreur :
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: -1

2. 5 Affinité entre tableaux et boucles for

Le numéro de case peut être cherché dans une variable. Il arrive souvent qu’on utilise une
boucle for pour effectuer une opération sur chacune des cases d’un tableau. On utilise alors la
variable de la boucle for pour désigner un numéro de case. A chaque tour de boucle, l’opération
est effectuée sur une des cases du tableau et la boucle est parcourue autant de fois qu’il y a de
cases dans le tableau.

2. 5. 1 Parcours pour affichage d’un tableau

La boucle fait varier l’indice du tableau tab entre i= 0 et i = tab.length-1.
Pour afficher un tableau, il faut faire comme dans le programme qui suit un affichage case par
case au moyen d’une boucle for.

public class AfficheTab {

. public static void main (String args[]) {
. int[] tab = {10,20,30,40};
. for (int i=0; i<= tab.length -1; i++) {
. System.out.println("tab["+i+ "] = "+ tab[i]);
. }
. }
}

Ce programme affiche:
tab[0] = 10
. tab[1] = 20
. tab[2] = 30
. tab[3] = 40
6

Une erreur commune dans une boucle, est de fixer le dernier indice à i <= tab.length plutôt
qu’à i <= tab.length − 1. Si nous changeons la condition de la boucle de cette manière,
l’exécution produit une erreur : l’indice tab.length, égal à 4 ici, n’existe pas dans tab.
. tab[0] = 10
. tab[1] = 20
. tab[2] = 30
. tab[3] = 40
. Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 4

2. 5. 2 Boucles d’initialisation et d’affichage

On souhaite initialiser un tableau avec des notes d’étudiants saisies au clavier. Le pro-
gramme demande le nombre de notes à saisir, et crée un tableau notes de cette taille. Une
première boucle initialise le tableau ; la boucle suivante affiche son contenu. Les itérations se
font dans l’intervalle de i = 0 jusqu’à i <= notes.length − 1.

import java.util.Scanner;
public class AffichageNotes {
. public static void main (String args[]) {
. Scanner clav=new Scanner(System.in);
. System.out.println("Nombre de notes à lire? ");
. int N = clav.nextInt();
. double [] notes = new double[N];
. // Initialisation
. for (int i=0; i< notes.length; i++) {
. System.out.println("Note no. "+(i+1)+"? ");
. notes[i] = clav.nextDouble();
. }
. // Affichage
. System.out.println("Notes dans le tableau:");
. System.out.println("**********************");
. for (int i=0; i< notes.length; i++){
. System.out.println("Note no. " + (i+1) + " = ");
. System.out.println(notes[i]);
. }
. }
}
2 Les tableaux à une dimension 7

2. 5. 3 Boucle for revisitée (for-each)

A partir de la version 1.5 du langage, une syntaxe complémentaire a été introduite pour
l’instruction for. Elle permet de parcourir tous les éléments d’un tableau en utilisant une syntaxe
allégée:

for (type elem : nomTab) {Instructions} // Le symbole ":" se lit "in" ("dans").

Cette forme de l’instruction for est parfois appelée for-each

p Exemple:
public class TestForeach{
. public static void main(String[] args){
. int tab[]={2,0,3,0,5,0,7};
. for (int elem : tab){
. if (elem!=0)
. System.out.println("# de 0");
. else
. System.out.println("= 0");
. }
. }
}

Cette nouvelle syntaxe ne remplace pas la syntaxe de base (elle la simplifie dans certaines
situations particulières).

2. 6 Copier un tableau
Pour copier un tableau, on utilise l’opération suivante:
System.arraycopy(source, positionSrc, destination, positionDst, nombre);
å source : tableau source.
å positionSrc : position de départ pour le tableau source.
å destination : tableau destination.
å positionDst : position de départ pour le tableau destination.
å nombre : nombre d’éléments à copier.

p Exemple:
System.arraycopy(src, 0, dst, 2, 5); //copie les 5 premiers éléments de src dans
. //dst à partir de l’indice 2.
8

Allocation de memoire et copier par appel de l’opération Arrays.copyOf() ou Arrays.copyOfRange().

p Exemple:
int[] tab2= Arrays.copyOf(t, 5); // copie des 5 premiers éléments.
int[] tab3= Arrays.copyOfRange(t, 2, 5); // copie entre les indices 2 à 5.

La méthode clone() peut aussi être utilisée pour copier le contenu d’un tableau.

p Exemple:
int[] tab3 = tab2.clone();

2. 7 Passage de tableaux en paramètre

Les tableaux peuvent être passés comme paramètres lors des appels de méthodes, ce pas-
sage s’effectue par adresse (par référence).
Dans le passage par adresse ci-après, les noms des tableaux dans le programme appelant et dans
la fonction diffèrent légèrement(tab1 et tab2) pour éviter toute confusion. Ils pourraient être
identiques ou carrément différents, cela ne change rien au principe du passage par adresse.
Dans l’exemple ci-dessous, la méthode maximum() reçoit en paramètre une copie de la réfé-
rence du tableau tab1 (paramètre effectif) dans la variable tab2 (paramètre formel).

p Exemple :
public static void main(String[] args){
. int[] tab1 = {0,1,2,3};
. int max = maximum(tab1);
. System.out.println("Le maximum de nombres est : " + max);//3
. }
public static int maximum(int[] tab2){
. int max = tab2[0];
. for (int i=1; i<tab2.length; i++)
. {
. if (tab2[i]>max)
. max = tab2[i];
. }
. return max;
. }
2 Les tableaux à une dimension 9

Le passage par adresse permet de modifier la variable du programme appelant puisqu’on

connaît son adresse. Si, à l’intérieur d’une méthode, vous modifiez un tableau passé en argu-
ment, cette modification affecte également le tableau à l’extérieur de la méthode, puisqu’il s’agit
du même objet. Le programme suivant en fait la démonstration :

p Exemple:
public static void main(String[] args){
. int[] tab1 = {0,1,2,3};
. int max = maximum(tab1);
. System.out.println("Le maximum de nombres est : "+ max);//42
. }
public static int maximum(int[] tab2){
.. tab2[2]=42;
.. int max = tab[0];
. for (int i=1; i<tab2.length; i++)
. {
. if (tab2[i]>max)
. max = tab2[i];
. }
. return max;
. }

Il est important de comprendre que, pendant l’exécution de la méthode maximum, la va-

riable locale tab2 est un alias pour le tableau tab1. Ainsi, à l’entrée de la méthode maximum,
on a

et, après l’exécution de l’instruction tab2[2]=42;, on a

p Exercice:
Soit la méthode suivante:
void changement(int[] t1,int[] t2){
. t1 =t2;
10

. t1[0] = t2[t2.length-1];
. }
Et les déclarations et instructions suivantes:
int[] numero = {1,3,4,5};
int[] num={4,3,6};
changement(numero, num);
Que contiennent les tableaux numero et num après cet appel?

3 Les tableaux à plusieurs dimensions

On peut généraliser la notion de tableau à une dimension pour créer des tableaux multidi-
mensionnels. Un tableau à deux dimensions est un tableau à 1 dimension dont chaque élément
est lui-même un tableau à une dimension, autrement dit un tableau à deux dimensions est un
tableau de tableaux. Du point de vue de la notation, chaque paire de crochets ([]) représente une
dimension (aussi bien pour la déclaration, la création que l’accès aux éléments). Pour déclarer
un tableau à deux dimensions, vous devez utiliser la syntaxe suivante :

p Syntaxe:
type [] [] nomTab; ou type nomTab[] [];

L’initialisation du tableau peut être effectuée à l’aide de tableaux littéraux :

p Exemple:
int [][] x = {{0, 0,0, 0},
. {0, 1, 2, 3},
. {0, 2, 4, 6},
. {0, 3, 6, 9}};

ou à l’aide de l’opérateur new :

p Exemple:
double[][] Tab ; // Déclaration d’un tableau à 2 dimensions de réels
Tab = new double[2][3]; // Création d’un tableau contenant 2 tableaux de
. // 3 réels chacun. Tab a donc 2 lignes et 3 colonnes.

Pour accéder à tous les éléments du tableau, vous devez utiliser des boucles imbriquées :
3 Les tableaux à plusieurs dimensions 11

p Exemple:
int [][] mat = new int [2][3] ;
for (int i=0;i<mat.length;i++)
. for (int j=0;j<mat[i].length;j++)
. mat[i][j] = i*j;

p Remarque:
å En fait, la syntaxe : int [][] tab = new int[2][3];
crée un tableau de deux tableaux. Ces deux tableaux ont tous trois éléments.
å mat.length: représente le nombre des tableaux=2.
å mat[i].length: représente la taille de chaque tableau=3.

Ces exemples mettent en évidence la véritable nature des tableaux multidimensionnels. Il

s’agit en fait de tableaux de tableaux. Par conséquent, il est possible de créer des tableaux de
forme quelconque, par exemple des tableaux triangulaires :

p Exemple:
int [][] tab = {{1},
. {2, 3},
. {4, 5, 6}};

ou en losange :

p Exemple:
int [][] x = {{1},
. {2, 3},
. {4, 5, 6},
. {7, 8},
. {9}};

Si vous voulez utiliser l’opérateur new pour créer des tableaux non rectangulaires, il faut
initialiser séparément chaque sous-tableau. Pour créer le tableau en triangle de l’exemple pré-
cédent, vous pouvez procéder de la façon suivante :

p .
int [][] tab = new int[3][];
for (int i = 0; i < 3; i++)
. tab[i] = new int[i + 1];