Tableaux

en Java
 Généralités sur les Tableaux

 Les tableaux sont des objets en java et non seulement une suite
d'emplacements mémoire comme il est le cas en C/C++

 Ils constituent des collections ordonnées d'éléments

 Les éléments d'un tableau peuvent être :

 des variables de type primitif (int, boolean, double, char...)

 des références sur des objets ( y compris des références sur

d'autres tableaux)

Tableaux 2
 Déclaration d’un tableau à une dimension
 Déclaration
 typeDesElements[] nomDuTableau;
ou bien
 typeDesElements nomDuTableau[];
avec
 typeDesElements un des types de base du langage JAVA
(char, int, float, double...) ou un nom de classe
 nomDuTableau l’identificateur pour désigner le tableau
Remarque : Il est recommandé d’utiliser la première forme de déclaration car permet de
déclarer plusieurs tableaux ayant le même type des éléments en une seule ligne .

Exemples
double [] tab1; //identique à double tab[]
Int[] entiersPremiers, nombresCubes; //déclare deux tableaux dont les éléments sont de type int
Etudiant[] classe; //déclare un tableau dont les élements sont des objets instances de la classe Etudiant

Compte[] clients; //déclare un tableau dont les élements sont des objets instances de la classe Compte
3
 Création d’un tableau à une dimension
 la taille d'un tableau n'est pas spécifiée à la déclaration.
 les tableaux sont des objets,
 La déclaration : typeDesElements[] nomDuTableau;

définit une référence vers un objet de type "tableau d'éléments de type

typeDesElements".
 Le nombre d'éléments du tableau sera déterminé quand l'objet tableau sera
effectivement créé en utilisant new.
 cette taille fixée à la création est fixe, elle ne pourra plus être modifiée par la
suite.

Exemple

int[] entiersPremiers; //déclaration d’une référence vors l’objet tableau

entiersPremiers = new int[50]; //Création de l’objet tableau de 50 entiers

//Déclaration et création d’un tableau de 1000 élements de type Compte

Compte[] listeDesComptes = new Compte[1000]; Tableaux 4
 Création d’un tableau à une dimension

 La création d ’un tableau par new

 alloue la mémoire nécessaire en fonction
du type des éléments du tableau

de la taille spécifiée

 initialise le contenu du tableau

 les éléments de types primitifs sont initialisés à 0

 les éléments de type classe sont initialisé à null

(car chaque élément est une référence à un objet instance de la classe.
Et chaque élément doit être créé par new et rangé dans le tableau)

Tableaux 5
 Tableaux à une dimension
Exemples de Création

int[ ] tab1; isa

tab1 = new int[5]; tab1
int[ ] tab2 = tab1; 0 0
1 0
tab2 2 0
3 0
4 0

Etudiant[ ] classe1; isa

classe1 = new Etudiant[4]; classe1
null
Etudiant[ ] classe2 = classe1; 0
classe2 1
2

Tableaux 6
 Tableaux à une dimension
Accès aux éléments

 accès aux éléments d’un tableau unidimensionnel

 accès à un élément d'un tableau s'effectue à l'aide d'une expression
de la forme : nomDuTableau[expression1]
où
 expression1 s’évalue en une valeur entière dans les bornes du tableau
(>= 0 : plus petit indice et <= length-1 : plus grand indice)
on peut rencontrer une telle expression aussi bien en partie gauche
qu’en partie droite dune affectation

 length donne la dimension (entier) du tableau

nomDuTableau.length = indice max c-a-d indice du dernier élément du
tableau

 Java vérifie automatiquement l'indice lors de l'accès (comparaison avec les

bornes)
Si l’indice est en dehors de l’intervalle [0, length-1] => génération de
l’exception: ArrayIndexOutOfBoundsException Tableaux 7
 Tableaux à une dimension
Précison sur length
 Précision sur lenght
 Lenght est une variable d’instance publique
=>(non respect du principe d’encapsulation)

Lenght est déclarée public final

=>(Initialisation à la création du tableau, et ne peut pas être modifiée)

nomDuTableau.length = dimension (nombre d’éléments) du tableau

nomDuTableau.length – 1 = indice max du tableau

public class TestArgs {

public static void main(String[] args) {

Ce programme
System.out.println("nombre d ’arguments : " + args.length); permet d’afficher les
arguments fournis
for (int i =0; i < args.length; i++) dans la ligne de
commande lors de
System.out.println(" argument " + i + " = " + args[i]); l’exécution du
} programme
}
Tableaux 8
 Tableaux à une dimension
Exemples de Création

int[ ] tab1; isa

tab1 = new int[5]; tab1
tab1[0] = 1; 0 1
for (int i=1; i<5; i++) 1 2
tab1[i] = tab1[i-1]*2; 2 4
3 8
4 16
isa

nom Moha
Public class Etudiant{
String nom, prenom; isa prenom Ali
classe1
double note;
} note 17
0 null
Public Etudiant(String n, String p,double score){
nom = n; prenom = p; note = score; 1
}} 2
3
Etudiant[ ] classe1 = new Etudiant[4];

Classe[0] = new Etudiant(« Moha », « Ali », 17); Tableaux 9

 Initialisation d’un tableau à une dimension

 Initialisation d’un tableau = une autre manière de créer des tableaux :

 en donnant explicitement la liste de ses éléments à la déclaration

(liste de valeurs entre accolades)

 Exemples :

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

Etudiant[ ] classe1 = { new Etudiant(« Moha », « Ali », 15),

new Etudiant(« Toto », «Najib », 12),
new Etudiant(« Manolo », «Brahimi », 11),
new Etudiant(« Kardi », « Rachid », 17) };

 L ’allocation mémoire (équivalent de l ’utilisation de new) est prise en

charge par le compilateur
Tableaux 10
 Tableaux à plusieurs dimension
Déclaration

 tableau dont les éléments sont eux mêmes des tableaux

 un tableau à deux dimensions se déclarera ainsi de la manière suivante :

typeDesElements[ ][ ] nomduTableau;

Exemples

double[ ][ ] matrice;

Etudiant[ ][ ][ ] cubeEtud;

Tableaux 11
 Tableaux à plusieurs dimension
Création
 dimensions du tableau
 ne sont pas spécifiées à la déclaration (comme pour les tableaux à une
seule dimension).
 ne sont indiquées que lors de la création
 obligatoire que pour la première dimension.
 autres dimensions peuvent n'être spécifiées que lors de la
création effective des tableaux correspondants.
Exemples :
double [ ][ ] matrice = new double[4][4]; Création d’une matrice 4x4
de réels
double [ ][ ] matrice = new double[4][ ];
for (int i=0; i < 4; i++)
matrice[i] = new double[4]; Les 3 écritures sont
équivalentes
double [ ][ ] matrice;
matrice = new double[4][ ];
for (int i=0; i < 4; i++)
matrice[i] = new double[4]; Tableaux 12
 Tableaux à plusieurs dimension
Création

 chaque tableau imbriqué peut avoir une taille différente.

Exemple :
isa

int [ ][ ] tabsInt; 0 0
tabsInt = new int[3][ ]; 1 0 isa
tabsInt[0] = new int[5]; 2 0
tabsInt[1] = new int[4]; 3 0 0 0
4 0 1 0
tabsInt[2] = new int[6];
2 0
3 0

tabsInt isa
isa
0
1 0 0
2 1 0
2 0
3 0
4 0
Tableaux 5 0 13
 Accès aux éléments d’un tableau à plusieurs dimensions

 accès aux éléments d’un tableau à deux dimensions

L’accès à un élément d'un tableau s'effectue à l'aide d'une expression de la forme :

nomDuTableau[expression1][expression2]
où
– expression1 s’évalue en une valeur entière entre les bornes
0 et nomDuTableau.length - 1
– expression2 délivre une valeur entière entre les bornes
0 et nomDuTableau[expression1].length - 1

char[ ][ ] tabChar = new char[3][ ];

tabChar[0] = new char[4];
tabChar[1] = new char[6];
tabChar[2] = new char[5]
tabChar[0][0] = ‘J’; tabChar[0][1] =‘A’; tabChar[0][2] = ‘V’; tabChar[0][3] =‘A’;

tabChar[1][0] = ‘B’; tabChar[1][1] =‘R’; tabChar[1][2] = ‘A’; tabChar[1][3] =‘V’; tabChar[1][4] = ‘E’;
tabChar[1][5] =‘R’;

tabChar[2][0] = ‘C’; tabChar[2][1] =‘O’; tabChar[2][2] = ‘B’; tabChar[2][3] =‘O’; tabChar[2][4] = ‘L’;
 Initialisation d’un tableau à plusieurs dimensions

 Il est possible de créer un tableau à plusieurs dimensions en initialisant

ses éléments lors de sa déclaration (Comme pour tableaux à une dimesion)

 exemples :
int[ ][ ] t1 = { int[ ][ ] t1 = new int[2][5];
t1[0][0]=1; t1[0][1]=2; t1[0][2]=3; t1[0][3]=4; t1[0][4]=5;
{ 1, 2, 3, 4, 5},
{ 6, 7, 8, 9, 10} ≡
t1[1][0]=6; t1[1][1]=7; t1[1][2]=8; t1[1][3]=9; t1[1][4]=10;
};

Point[ ][ ] pts = {
Point[ ][ ] pts = new Point[3][2];
{ new Point(10,15),new Point(20,25)},
{ new Point(30,35), new Point(40,45)} , ≡ Pts[0][0] = new Point(10,15); Pts[0][1] = new Point(20,25);
Pts[1][0] = new Point(30,35); pts[1][1] = new Point(40,45) ;
{ new Point(50,55),new Point(60,65)} , Pts[2][0] = new Point(50,55); ,pts[2][1] = new Point(60,65) ;
};

Tableaux 15
 Classe Arrays : Tri d’un tableau

 package java.util définit une classe, Arrays, qui propose des méthodes
statiques (de classe) pour le tri et la recherche dans des tableaux.

Exemple : tri d’un tableau

// tableau de 1000 réels tirés au hasard

// dans l ’intervalle [0..100[

double[ ] tab = new double[100];

for (int i = 0; i < tab.length; i++)

tab[i] = Math.random()*100;

// tri du tableau
Arrays.sort(tab);

// affichage du tableau trié

for (int i = 0; i < tab.length; i++)
Tableaux 16
System.out.print(tab[i] + " " );
Classe Arrays : Recherche d’une donnée dans un tableau
Exemple : recherche dans un tableau
// tableau de 100 entiers tirés au hasard
// dans l ’intervalle [0..100[
int[ ] tab = new int[100];

for (int i = 0; i < tab.length; i++)

tab[i] = (int) (Math.random()*100);

// tri du tableau
Arrays.sort(tab);

// recherche de la valeur 45
int pos = Arrays.binarySearch(tab,45);

// utilisation des résultats de la recherche

if (pos >= 0)
System.out.println("position de 45 : " + pos);
else {
System.out.println(« 45 n ’est pas dans le tableau");
System.out.println("position d ’insertion : " + (-(pos+1))); 17
}
 Classe Arrays : Quelques méthodes extraites
de la documenetation de l’API

static boolean deepEquals(Object[] a1, Object[] a2)

          Returns true if the two specified arrays are deeply equal to one another.

static void fill(double[] a, double val)

          Assigns the specified double value to each element of the specified
array of doubles.

static String toString(double[] a)

          Returns a string representation of the contents of the specified array.

static void sort(double[] a)

          Sorts the specified array of doubles into ascending numerical order.

static void sort(double[] a, int fromIndex, int toIndex)

          Sorts the specified range of the specified array of doubles into ascending
numerical order.

Tableaux 18
 System.arraycopy()

The subroutine, System.arraycopy(), is a static member subroutine in the

standard System class. Its declaration has the form

public static void arraycopy(Object sourceArray, int sourceStartIndex,

Object destArray, int destStartIndex, int count)

For example, to make a copy of the array, A, using this subroutine, you would say:

double B = new double[A.length];

System.arraycopy( A, 0, B, 0, A.length );

Tableaux 19
 Arrays and for-each Loops

BaseType[ ] anArray = new BaseType[N];

for ( BaseType item : anArray ) {

.
. // process the item
.
}

for ( int index = 0; index < anArray.length; index++ ) {

BaseType item;
item = anArray[index]; // Get one of the values from the array
.
. // process the item
.
}

Tableaux 20
It’s important to note that a for-each loop processes the values in the array, not the
elements (where an element means the actual memory location that is part of the
array).
For example, consider the following incorrect attempt to fill an array of integers with
17’s:

int[] intList = new int[10];

for ( int item : intList ) { // INCORRECT! DOES NOT MODIFY THE
ARRAY!
item = 17;
}

The assignment statement item = 17 assigns the value 17 to the loop control
variable, item.

However, this has nothing to do with the array. When the body of the loop is
executed, the value from one of the elements of the array is copied into item.

The statement item = 17 replaces that copied value but has no effect on the
array element from which it was copied; the value in the array is not
changed. Tableaux
21