Les tableaux

Introduction
9 Les tableaux sont des structures de données regroupant plusieurs valeurs de
même type. Ou encore on parle de tableaux pour désigner un ensemble
d’éléments de même type désignés par un nom unique, chaque élément étant
repéré par un indice précisant sa position au sein de l’ensemble .
9 Les tableaux constituent des collections d'informations homogènes, c'est-à-
di de
dire, d valeurs
l primitives
i i i ou d'objets
d' bj ded même
ê type.
9 Les éléments d'un tableau peuvent être :
9 des
d primitives
i iti (scalaires)
( l i ) (float
fl t, int
i t, char
h , etct .),
)
9 des références d'objets (String, Object),
9 des références de tableaux.
tableaux
9 La taille d'un tableau est fixée d'une façon permanente suite à la déclaration du
tableau et à l'allocation de ressources systèmes
y ppour ce dernier.
 Introduction
9 Les tableaux sont des objets:
Indépendamment du type de tableau qu'on utilise, un identifiant de tableau
est en fait une référence sur un vrai objet. j C'est l'objet j qqui stocke les
références sur les autres objets, et il peut être créé soit implicitement grâce
à la syntaxe d'initialisation de tableau, soit explicitement avec une
expression new.
9 La variable length indique le nombre d'éléments qui peuvent être stockés
d le
dans l tableau.
bl L’opérateur
’ é "[ ]" est le l seull autre accès
è disponible
d bl pour
les objets tableaux.
 Déclaration
é de tableaux
En Java,
Java un tableau est déclaré de la manière suivante:

t
type id
identificateur
ifi [] ;
ou encore
type [] identificateur ;
Exemple:
int tab [] ; //t contient la référence d’un tableau d’entier
double [] som ;
P
Personne p [] ; //p
// contient
i la référence
é é d’un tableau de
//Personnes
 Déclaration
é de tableaux
La différence entre les deux formes de déclaration devient perceptible
p p
lorsque l’on déclare plusieurs identificateurs dans une même instruction.
Ainsi :

int [] t1 , t2 ; // t1 et t2 sont des références à

//des tableaux d’entiers

int t1 [], n, t2 [] ; // t1 et t2 sont de tableaux

//d’entiers , n est entier

Attention ! La taille d'un tableau n'est spécifiée qu'à partir du moment de

son utilisation dans le pprogramme.
g Ainsi,, la mémoire ne sera allouée qque
lorsque ça sera nécessaire. C’est pourquoi, lors de la déclaration du tableau
on ne peut pas faire:
int t [12];// erreur ! pas de dimension.
dimension
 Création
é
La déclaration peut se combiner à la définition du tableau produisant
une instruction plus compacte.
int [] tab = new int [ 14]; //taille (14 ici )
//obligatoire
Dans la création d’un tableau,, il faut obligatoirement
g mentionner la
taille du tableau.
Par défaut, les valeurs de chaque élément dd'un
un tableau sont égales à :
90 pour des entiers (int, short, ...),
9 0.0 p
pour des nombres à virgule
g flottante (double, float),
9 u0000 pour des caractères (char),

9 false p
pour des booléens (boolean),
9 null pour des objets (Object, String).
 Remarques
On ne ppeut ppas créer un tableau avec une taille négative.
g Une instruction
telle que:
Point p [ ] = new Point [- 5] ;
déclenche
dé l h une exception i java.lang.NegativeArraySizeException,
laquelle, si elle n’est pas interceptée et traitée provoque l’arrêt brutal du
programme
(on verra comment traiter les exceptions).

De même,
D ê on ne peutt accéder
éd à un indice
i di ded tableau
t bl trop
t grandd (ie
(i accès
è en
dehors des bornes ou limites du tableau). Avec:
int tab[ ] = new int [ 10]; ll’instruction
instruction
tab[10] = 12;
déclenche une exception java.lang.ArrayIndexOutOfBoundsException
(en fait
f lesl indices
d d éléments
des élé d’ tableau
d’un bl varient de
d 0 à taille
ll -1).
 Création
é avec un initialiseur
Les tableaux peuvent être initialisés par ll'intermédiaire
intermédiaire dd'une
une liste de
valeurs séparées par une virgule et compris entre des accolades .
type [ ] identificateur = { valeur1, ..., valeurN };
type identificateur [ ] = { valeur1, ..., valeurN };

E
Exemples:
l
int [ ] notes = {10, 9, 12, 14, 16, 15, 17, 20, 19, 18};
ou
int notes [ ] = {10, 9, 12, 14, 16, 15, 17, 20, 19, 18};

Un initialiseur n’est utilisable que dans une déclaration.

int [ ] notes;
notes = {10, 9, 12, 14, 16, 15, 17, 20, 19, 18}; //interdit
 Utilisation d’un tableau
En Java,
Java on peut utiliser un tableau de deux façons différentes :
9 en accédant individuellement à chacun de ses éléments
9 en accédant gglobalement à l’ensemble du tableau .

L'accès individuel aux éléments d'un tableau est réalisé en utilisant ses
indices, soit les numéros de chacun de ses éléments, en sachant que le
premier commence à l'indice 0.
Exemples:
String s[ ] = new String [10];
s[2] = new String ("Bonjour");//place la chaîne "Bonjour"
//dans le 3ème élément du tableau
double d [ ] = new double [6];
d[ 5]++; // incrémente de 1 le dernier élément du tableau
 Utilisation d’un tableau
La manipulation globale dd’un un tableau se fait par affectation de
tableaux. Il est possible d’affecter une variable de type tableau à une
autre variable, à condition qu’elles soient déclarées avec le même type
de composantes.
int [] tab = new int [3] ;
for(int i = 0; i < 3; i++)
tab [i] = i ;
int [] t = new int [2] ;
for(int i =0 ; i < 2 ;i++)
t[i] = i+10 ;

tab = t ; //Désormais, tab et t désignent le même objet

// tab[0] = t[0] = 10 et tab[1] = t[1] = 11
 Remarque
Même si deux tableaux contiennent les mêmes éléments ((donc même contenu)) et sont créés avec
deux instructions identiques, il y deux espaces mémoires différents créés, donc ils ne désignent pas
le même tableau.
Exemple:
public class Tab {
public static void main(String tr[]){
int t [] = {1
{1, 2
2, 3} ;
int t1 [] = {1, 2, 3} ;

System out println(t equals(t1)) ;//false

System.out.println(t.equals(t1))
System.out.println(t == t1) ; //false

t1 = t ; //t et t1 désignent désormais le même objet

System.out.println(t.equals(t1)) ; //true
System.out.println(t == t1) ; //true
f
for (i
(int
t i = 0
0; i < t1
t1.length;
l th i++)
System.out.println(t1[i]) ;
//affiche 1, 2
}
Tableau en argument ou en valeur de retour
Lorsqu’on
q transmet un nom de tableau en argument
g d’une méthode,, on transmet
en fait (une copie de )la référence au tableau .La méthode agit alors directement
sur le tableau concerné et non sur une copie.
Exemple
p :
public class TabInverse {
/*méthode retournant sous forme de tableau l’inverse d’un tableau
transmis en argument */
public static int[] inverseTab (int t[ ]) {
int tabres[ ] = new int [t.length];
for (int i = t.length - 1; i >= 0 ; i--)
t b
tabres[
[ t
t.length
l th -i
i - 1] = t[ i ]];
return tabres;
}
//méthode affichant les éléments du tableau renversé*/
public static void afficheTab( int t[ ]){
for ( int i = 0; i < t.length; i++)
System.out.print ( t[ i ]+ " ");
);
}
Tableau en argument ou en valeur de retour
public class RunTabInverse {
public static void main( String args[ ]){
int tabAinverser [] = {19, 89, 12, 1};
afficheTab(inverseTab(tabAinverser));
}
}

//1 12 89 19
 Tableau de dimension > 1
9 Les tableaux vus jusqu
jusqu’ici
ici sont des tableaux à une dimension :
conceptuellement tous les éléments se trouvent dans une seule ligne
(ou co
colonne).
o e).
9 Les tableaux à plusieurs dimensions sont utiles dans la modélisation
des données, mais ce sont les tableaux à deux dimensions qui sont de
loin les plus utilisés en informatique.
9 Un tableau à deux dimensions, ou matrice, représente un rectangle
composé de lignes et de colonnes. Chaque élément stocké dans le
tableau est adressé ppar sa pposition,, donnée ppar sa ligne
g et sa colonne.
9 En Java, si tab est un tableau à deux dimensions, l’élément de ligne i
et colonne j est désigne
g ppar tab[[ i ][ j ]].
 Tableau à deux dimensions
Déclaration:
Pour déclarer un tableau à deux dimensions, on peut utiliser l’une de
ces trois déclarations qui sont équivalentes :
int t [][] ; // tableau d’entiers à deux dimensions
int [] t [] ; //idem
int [] []t ; //idem

Elles déclarent que t est une référence à un tableau, dans lequel

chaque élément est lui
lui-même
même une référence à un tableau d’entiers
d entiers .
Pour l’instant, aucun tableau de cette sorte n’existe encore .
 Tableau à deux dimensions
Création:
int [] []t = {new int [3], new int[2] } ;
L’initialiseur de t comporte
p deux éléments dont l’évaluation crée un tableau de 3
entiers et un tableau de 2 entiers . Les éléments des tableaux sont, comme
d’habitude, initialisés à 0.
Dans ces conditions, on voit que :
9 la notation t [0] désigne la référence au premier tableau de 3 entiers
9 la notation t[1] désigne la référence au second tableau de 2 entiers
9 l’expression t.length vaut 2
9 l’expression t[0].length vaut 3
9 l’expression t[1].length vaut 2
Les chaines de caractères: la classe
String
 La classe String
La classe String gppermet de manipuler
p les chaînes de caractères. Une chaîne de
caractères est contenue dans un objet de la classe String.
Déclaration et initialisation :
String chaine ; //déclaration d
d’une
une référence chaine
//à un objet de type String

chaine = "ceci
ceci est un objet chaine de caractère
caractère" ;
//un objet chaine référencé par la variable chaine

L classe
La l String possède
èd plusieurs
l i constructeurs dont:
d
String(); // pour construire une chaine vide
String(String str); // crée un objet contenant la
//chaine str

On peut ainsi initialiser un objet chaîne comme suit:

String chaine1 = new String ("Bonjour LtDSI-Soir") ;
 La classe String
Les objets de la classe String ont la particularité dd'être
être constants.
constants
Chaque traitement qui vise à transformer un objet de la classe est
implémenté
p é e té pa
par uunee méthode
ét o e qu
qui laisse
a sse l'objet
o jet d'origine
o g e inchangé
c a gé et
renvoie un nouvel objet String contenant les modifications.
 Quelques méthodes de la classe String
/*retourne la longueur de l'objet String*/
int length ()
/*retourne un nouvel objet String résultant du remplacement de toutes les
occurrences d
d'un
un caractère donnée par un autre caractère
caractère*/
/
String replace(char oldChar, char newChar)
/*remplace dans une chaîne de caractères, chaque sous-chaîne qui
correspondent
p à l'expression
p régulière
g fournie,
, p
par une chaîne de
caractères de remplacement*/
String replaceAll (String origine, String remplacement)
/*teste si l'objet
j String
g commence p
par le p
préfixe spécifié.
p */
boolean startsWith (String prefix)
/*retourne une nouvelle chaîne de caractères qui est une sous-chaîne de
l'objet String par l'intermédiaire d'un intervalle commençant à l'index
spécifié jusqu'à la fin. */
String substring (int beginIndex)
/*retourne une nouvelle chaîne de caractères qui est une sous-chaîne de
l'objet String par l'intermédiaire d'un intervalle spécifié */
String substring(int beginIndex, int endIndex)
 Quelques méthodes de la classe String
//retourne la caractère p
positionné à l'index spécifié.
p
char charAt (int index)
/*comparaison lexicographique de deux chaines. Retourne 0 en
cas d’égalité -1
1 o
ou -32
32 en cas d’infé
d’infériorité
io ité et 1 o
ou 32 en
cas de supériorité */
int compareTo(String str)
/*compare deux chaînes lexicographiquement en ignorant la casse
de caractères*/
int compareToIgnoreCase
p g (String
( g str)
)
/*concatène l'objet String à une autre chaîne de caractères. */
String concat (String str)
 Quelques méthodes de la classe String
/*retourne un nouvel objet String qui représente la séquence de
caractères dans le tableau spécifié */
static String copyValueOf (char[] tabCar)
//teste si la fin de l'objet
// j String
g correspond
p au suffixe spécifié.
p
boolean endsWith (String suffix)
//compare le contenu de deux chaînes de caractères entre elles.
boolean equals (Object anObject)
/*compare l'objet String à un autre objet de même type en ignorant la
casse de caractères. */
b l
boolean equalsIgnoreCase
l I C (St i
(String anotherString)
th St i )
/*retourne l'index à l'intérieur de l'objet String de la première
occurrence du caractère spécifié */
int indexOf (int ch)
/*retourne l'index à l'intérieur de l'objet String de la première
occurrence du caractère spécifié à partir d'une certaine position */
int indexOf(int ch, int fromIndex)
 Quelques méthodes de la classe String
/*retourne l'index à l'intérieur de l'objet
j String
g de la
première occurrence de la sous-chaîne spécifiée. */
int indexOf (String str)
/*retourne
/* eto ne l'index
l'inde à l'inté
l'intérieur
ie l'objet String
St ing de la p
première
emiè e
occurrence de la sous-chaîne spécifiée à partir d'une
certaine position. */
i
int i d
indexOf(String
f( i str, int
i f
fromIndex)
d )
/*retourne l'index à l'intérieur de l'objet String de la
dernière occurrence du caractère spécifié */
int lastIndexOf (int ch)
/*retourne une chaîne de caractères issue de l'objet String. */
String toString()
/*retourne un représentation sous forme d'un objet String de la
valeur de type int passée en argument */
static String valueOf (int i)
 Utilisation de quelques méthodes
é
String ch ="I have never seen such a powerfull language";
ch.length(); //longueur de la chaine 42(espaces compris

ch substring(23);
ch.substring(23);

ch.substring(6,17);//"never seen".
//attention: le caractere à l’indice 17
//n’est pas extrait

ch.toUpperCase();// I HAVE NEVER SEEN SUCH A POWERFULL LANGUAGE

// il existe aussi toLowerCase
ch = " bonjour \n
\n" ;

ch.trim() //supprime les espaces de début et de fin dans la

//chaine
 Utilisation de quelques méthodes
é
String
g s= "java"
j ;
String ch = "java" ;

s.equals (ch); // ici renvoie true car equals est redéfinie

//dans String

s.charAt(0); // renvoie le caractere à la position 0 donc j

char
h c [] = s.toCharArray(
h ( )
);//
// renvoie
i un tableau
bl d
de
//caracteres c ={‘j’, ‘a’, ‘v’, ‘a’}
ch.indexOf(a); // l’indice de la 1ère occurrence de a
//trouvée, ie 1
ch.indexOf(a,2); // l’indice de la 1ère occurrence trouvée
//à partir de 2
 La méthodes
é toUpperCase
La méthode toUpperCase
pp de la classe Stringg ppermet de convertir tous les
caractères d’une chaîne en majuscules.
Pour convertir certains caractères d’une chaîne en majuscules, on peut utiliser la
méthode
public static char toUpperCase (char c)
de la classe Character.
Par exemple: l
String s = "bonjour ";
for ( (int j = 0; j < s.length g (); j
() j++)
)
if (s.charAt(j) == ‘o'){
char c = Character.toUpperCase (s.charAt (j) ) ;
s = s.replace (s.charAt(j), c ) ;
}
System.out.print("affichage:" +s);//"affichage bOnjOur "
Il existe aussi la méthode public static char toLowerCase (char c)
 L’opérateur
é +
L opérateur + permet de concaténer deux chaînes de caractères.
L’opérateur caractères Il est
défini lorsque ses deux opérandes sont des chaînes. Il renvoie un résultat
qqui est la concaténation des deux chaînes.
String chaine1 = "Java est vraiment simple, " ;
String chaine2 = "plus besoin de strcat";
String chaineConcat = chaine1 + chaine2;
/* chaineConcat = "Java est vraiment simple, plus besoin de
strcat " */
 L’opérateur
é +
L’opérateur
p + est utilisé lorsque
q ses deux opérandes
p sont de type
yp String.g. Mais,, il
est possible de mélanger des expressions de type chaine et de type primitif.
Dans ce cas, il y a conversion (formatage) de la valeur de type primitif en chaîne.
int p = 100;
System.out.println (" la valeur de p est: " +p);
// la valeur en binaire de p est représentée en chaine

En définitive, lorsque l’opérateur + possède un opérande de type String, l’autre

est automatiquement converti en String.

Lorsque ll’opérateur
L é t + possède èd deux
d opérandes,
é d ll’un de d type
t St i , ll’autre
String t peutt
être de n’import quel type primitif, mais aussi de type objet. Dans ce dernier cas,
il y a conversion de la valeur de l’objet en chaine et ceci est réalisé grâce à la
méthode
é h d toString de d la
l classe
l d l’objet
de l’ bj qu’il
’il faut
f souvent redéfinir.
défi i
 L’opérateur
é +=
L opérateur +
L’opérateur += défini dans le cadre des opérations arithmétiques binaires
est également défini pour les chaînes. Cet opérateur n’est pas défini si son
deuxième opérande est chaine alors que le premier ne l’est pas.

String ch = "note";
for ( int i = 0; i < 5; i++)
ch += i;
System.out.println(ch);

Cette façon de procéder pour créer la chaine "note 01234" est médiocre
elle pourra être supplantée par l’utilisation de la classe StringBuffer qui
permet de modifier directement la valeur d’une chaîne de caractères.
 Equals vs ==
String
g ch = "note";
String s = "note";
System.out.print (ch == s) ; // affiche la valeur true
//== teste les références des chaînes

Une chaine n’étant pas modifiable, une seule chaine est créée et référencée par ch
et s.
s On parle ici dd’une
une fusion des chaînes identiques.
identiques

String ch = "bonjour";
String s = "bon";
s + = "jour" ;
System.out.print (ch == s) ; // affiche la valeur false

Vu l’utilisation non optimisée de ==, pour comparer deux chaînes il faut utiliser la
méthode equals qui compare le contenu de deux chaînes.
Cette méthode est celle de la classe Object mais redéfinie dans la classe String.
 Equals vs ==
String
g ch = "note";
;
String s = "note";
System.out.print(ch.equals (s)) ; // affiche la valeur true
// equivalent à ch.equals("note" );
String ch = "bonjour";
String s = "bon";
bon ;
s += "jour" ;
System.out.print(ch.equals( s)) ; // affiche la valeur true
String ch = "NoTe";
String s = "note";
System out print(ch equalsIgnoreCase (s)) ; // affiche la
System.out.print(ch.equalsIgnoreCase
//valeur true
Conversions de chaînes et types primitifs
La classe String possède une méthode statique valueOf surdéfinie avec un argument de
chaque type primitif qui permet de convertir n’importe quel type primitif en chaîne de
caractères.
int n = 541;
double d = 120.56;
String intCh = String.valueOf(n); //intCh contient la
//chaine " 541"
String doubleCh = String.valueOf(d); //doubleCh contient
//la chaine " 120.56 "
L’écriture intCh = String.valueOf(n); est équivalent à celle-ci:

intCh = ""+n; //on utilise une chaine vide pour recourir à

// l’ operateur + qui convertit n en String
Conversions de chaînes et types primitifs
Il est possible de convertir une chaine dans un type primitif en recourant aux
classes enveloppes définies pour chaque type primitif.
String ch = "3521" ;
int n = Integer.parseInt(ch); // n contient la valeur
//entiere 3521
On dispose
d aussi des
d méthodes:
éh d

9 Short.parseShort
9 Long.parseLong
9 Double.parseDouble
9 Byte.parseByte
9 Float.parseFloat
 Chaînes
î et tableaux
En Java
Java, on peut convertir un tableau en chaîne et vice versa:

char [ ] mot = { ‘b’, ‘o’, ‘n’, ‘j’, ‘o’, ‘u’, ‘r’};

//on construit une chaine à partir d’un tableau de caractères

String ch = new String(mot); // ch = "bonjour"

//constructeur avec le premier caractère et le nombre de

caractères
String
g ch2 = new String(mot,
g( , 3,4);//
, );// ch = " j
jour "
String ch = "bonjour" ;
char [] mot = ch.toCharArray( );
//mot = { ‘b’, ‘o’, ‘n’, ‘j’, ‘o’, ‘u’, ‘r’};
 La classe StringBuffer
Les objets
j de la classe Stringg ne sont ppas modifiables.. La modification d’une
chaîne n’est possible qu’en créant une nouvelle chaîne, ce qui n’est pas optimale
lorsqu’on manipule des chaînes assez intenses.
C’ t pourquoi,
C’est i Java
J propose la l classe
l St i B ff
StringBuffer quii permett de
d manipuler
i l
des chaînes tout en ayant la possibilité d’en modifier la valeur sans créer de
nouvelles chaînes.

//pour optimiser la création précédente de la chaine "note 01234 "

String ch = "note";
"note"
StringBuffer sb = new StringBuffer(ch) ; //on transmet ici un objet
//String
for ( int i =0; i < 5;i++)
sb.append (i); //on rajoute à la fin du StringBuffer vide
ch = sb.toString ( ); // on convertit le StringBuffer en String
System out println (ch);
System.out.println
 La classe StringTokenizer
Cette classe nn’ a aucun lien direct avec la classe String, elle se trouve
d’ailleurs dans le package java.util . Elle apporte un rôle dans la
manipulation des chaînes en facilitant la division de chaînes en sous-chaînes
selon
l un nombreb de d « délimiteurs
déli it ».
Cette méthode divise une chaîne en différents éléments appelés tokens.

String s = "Java, est: un .langage ; très puissant:";

St
StringTokenizer
g o e e st = new
e St
StringTokenizer
g o e e (s, ",;:."
,;:. );
String res = "" ;
while(st.hasMoreTokens ()) { //tant qu’il y a des tokens
res +=
+ st.nextToken()
t tT k () ;
// renvoie le premier élément et se positionne sur le
//suivant. cette méthode renvoie un objet String.
}
System.out.println(res) ;