Initialisation par une liste de valeurs

Lorsqu’un tableau est de petite taille, il est possible de l’initialiser en donnant la liste des valeurs de chaque composante. On utilise la notation {v0 , v1 , . . . vn}, ou` vi est la valeur a` donner a` la compo-sante i du tableau. Nous reprendrons souvent cette notation pour regrouper en une seule instruction la d´eclaration, la cr´eation et l’initialisation d’un tab leau.
Exemple 3 : D´eclaration, cr´eation et initialisation d’un tableau e n une seule instruction.
int [] tab = {1,9,2,4};
Il est alors inutile de realiser´ une creation´ explicite via new : elle se fait automatiquement a` la taille n´ecessaire pour stocker le nombre des valeurs donn´ees. En m´emoire on aura :
tab −→ 1 9 2 4
Valeurs par defaut a la creation
Lors de la cr´eation, les composantes d’un tableau sont initialis´ees avec des valeurs par d´efaut :
– les composantes boolean sont initialis´ees a` false.
– les composantes num´eriques sont initialis´ees a` 0.
– les composantes char sont initialis´ees au caract`ere nul ‘\0’.
– les composantes ref´erence´2 sont initialis´ees a` la valeur null (r´ef´erence nulle).
Exemple 4 : Valeurs par d´efaut dans les composantes apr`es cr´eation .
int [] tb = new int[3];
char [] ch = new char[4];
boolean [] bt = new boolean[3];
L’op´eration new initialise les composantes de ces tableaux par :
tb −→ 0 0 0
ch −→ ‘\0’ ‘\0’ ‘\0’ ‘\0’
bt −→ false false false

Longueur d’un tableau

La taille ou longueur d’un tableau est le nombre n des composantes qu’il contient. Supposons que tab d´esigne un tableau de taille n. On peut obtenir sa longueur par la notation tab.lenght. Les indices du tableau tab sont alors compris entre 0 et tab.length-1. Cette notation sera souvent employ´ee pour fixer la valeur maximale qui peut prendre l’in dice d’un tableau (voir exemple 6).

Acces aux composantes

L’acces a une composante de tableau permet de traiter cett e composante comme n’importe quelle variable individuelle : on peut modifier sa valeur dans le tab leau, l’utiliser pour un calcul, un affichage, etc. L’acc`es d’une composante se fait via son indice ou position dans le tableau. En Java, la premi`ere position a pour indice 0, et la derni`ere, a l’indice n-1 (taille du tableau moins un).
premier indice →0 i n-1← dernier indice (tab.length-1)
tab = 2.5
| {z }
tab.length=n
tab[i] vaut 2.5
L’acc`es aux composantes de tab n’a de sens que pour les indices dans l’intervalle [0,. . ., tab.length-1].
Si i est un indice compris dans cet intervalle :
– tab[i] : est un acces` a` la composante de position i dans tab. On peut consulter ou modifier
cette valeur dans le tableau. Exemple : tab[i] = tab[i] + 1 ;
– acces` en dehors des bornes du tableau tab : si j n’est pas compris entre 0 et tab.length-1, l’acc`es tab[j] provoque une erreur a` l’ex´ecution : l’indice j et la compos ante associ´ee n’existent pas dans le tableau. Java leve` l’exception ArrayIndexOutOfBoundsException.
Exemple 5 : Modification d’une composante, acc`es en dehors des bornes d’un tableau.
1 p u b l i c c l a s s T e s t {
2 p u b l i c s t a t i c v o i d m a i n ( S t r i n g a r g s [ ] ) {
3 d o u b l e [ ] t a b = { 1 . 0 , 2 . 5 , 7 . 2 , 0 . 6 } ; / / C r e a t i o n
4 / / A f f i c h a g e a v a n t m o d i f i c a t i o n
5 T e r m i n a l . e c r i r e S t r i n g ( ” t a b [ 0 ] a v a n t = ”);
6 T e r m i n a l . e c r i r e D o u b l e l n ( t a b [ 0 ] ) ;
7 t a b [ 0 ] = t a b [ 0 ] + 4 ;
8 / / A f f i c h a g e a p r \ ` e s m o d i f i c a t i o n
9 T e r m i n a l . e c r i r e S t r i n g ( ” t a b [ 0 ] a p r e s = ”);
10 T e r m i n a l . e c r i r e D o u b l e l n ( t a b [ 0 ] ) ;
11 / /t a b [ 5 ] = 1 7 ; / / E r r e u r : i n d i c e e n d e h o r s d e s b o r n e s
12 }
13 }
Ce programme affiche la valeur de la premi`ere composante de tab, avant et apr`es modification.
Java/Essais> java Test tab[0] avant = 1.0 tab[0] apres = 5.0
Si nous enlevons le commentaire de la ligne 11, l’ex´ecution se termine par une erreur : l’indice 5 est en dehors des bornes du tableau.
Java/Essais> java Test tab[0] avant = 1.0 tab[0] apres = 5.0
Exception in thread « main » java.lang.ArrayIndexOutOfBoundsException: 5 at Test.main(Test.java:9)
Exemple 6 : Parcours pour affichage d’un tableau tab. La boucle fait varier l’indice de tab entre i= 0 et i <= tab.lenght-1.
Listing 6.2 – (lien vers le code brut)
1 p u b l i c c l a s s A f f i c h e T a b {
2 p u b l i c s t a t i c v o i d m a i n ( S t r i n g a r g s [ ] ) {
3 i n t [ ] t a b = { 1 0 , 2 0 , 3 0 , 4 0 } ;
4 f o r ( i n t i = 0 ; i <= t a b . l e n g t h −1; i + + ) {
5 T e r m i n a l . e c r i r e S t r i n g l n ( ” t a b [ ” + i + ” ] = ” + t a b [ i ] ) ;
6 }
7 }
8 }
Ce programma affiche :
Java/Essais> java AfficheTab tab[0] = 10
tab[1] = 20 tab[2] = 30 tab[3] = 40
Une erreur commune dans une boucle, est de fixer le dernier ind ice a` i <= tab.length plutotˆ qu’`a i <= tab.length -1. Si nous changeons la condition de la boucle de cette mani`ere, l’ex´ecution produit une erreur : l’indice tab.length, egal´ a` 4 ici, n’existe pas dans tab.
Java/Essais> java AfficheTabErr tab[0] = 10
tab[1] = 20 tab[2] = 30 tab[3] = 40
Exception in thread « main » java.lang.ArrayIndexOutOfBoundsException: 4 at AfficheTabErr.main(AfficheTabErr.java:5)
Exemple 7 : Boucles d’initialisation et d’affichage. On souhaite init ialiser un tableau avec des notes
d’´el`eves saisies au clavier. Le programme demande le nomb re de notes a` saisir, et cr´e´ un tableau lesNotes de cette taille. Une premi`ere boucle initialise le tableau ; la boucle suivante affiche son contenu. Les it´erations se font dans l’intervalle de i=0 jusqu’`a i <= lesNotes.length-1.
1 p u b l i c c l a s s N o t e s {
2 p u b l i c s t a t i c v o i d m a i n ( S t r i n g a r g s [ ] ) {
3 i n t n o m b r e N o t e s ;
4 T e r m i n a l . e c r i r e S t r i n g ( ” Nombre d e n o t e s a s a i s i r ? ” ) ;
5 n o m b r e N o t e s = T e r m i n a l . l i r e I n t ( ) ;
6 d o u b l e [ ] l e s N o t e s = new d o u b l e [ n o m b r e N o t e s ] ;
7 / / I n i t i a l i s a t i o n
8 f o r ( i n t i = 0 ; i <= l e s N o t e s . l e n g t h −1; i + + ) {
9 T e r m i n a l . e c r i r e S t r i n g ( ” N o t e n o . ” + ( i + 1 ) + ” ? ” ) ;
10 l e s N o t e s [ i ] = T e r m i n a l . l i r e D o u b l e ( ) ;
11 }
12 / / A f f i c h a g e
13 T e r m i n a l . s a u t D e L i g n e ( ) ;
14 T e r m i n a l . e c r i r e S t r i n g l n ( ” N o t e s d a n s l e t a b l e a u : ” ) ;
15 T e r m i n a l . e c r i r e S t r i n g l n ( ” ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗” ) ;
16 f o r ( i n t i = 0 ; i <= l e s N o t e s . l e n g t h −1; i + + ) {
17 T e r m i n a l . e c r i r e S t r i n g ( ” N o t e n o . ” + ( i + 1 ) + ” = ” ) ;
18 T e r m i n a l . e c r i r e D o u b l e l n ( l e s N o t e s [ i ] ) ;
19 }
20 }
21 }
Java/Essais> java Notes Nombre de notes a saisir? 4 Note no. 1? 7.6
Note no. 2? 11 Note no. 3? 14 Note no. 4? 5
Notes dans le tableau:
**********************
Note no. 1 = 7.6 Note no. 2 = 11.0 Note no. 3 = 14.0 Note no. 4 = 5.0

Affectation entre tableaux

Il est possible d’affecter une variable de type tableau a` une autre autre variable, a` condition qu’elles soient d´eclar´ees avec le mˆeme type de composantes. Apr`e s affectation, les deux variables ref´erent´ a` un memeˆ et seul tableau en memoire´ : elles deviennent synonymes. Toute modification sur un compo-sant de l’une modifie le mˆeme composant de l’autre.
Exemple 8 :
1 i n t [ ] t ;
2 i n t [ ] m = { 2 , 3 , 4 , 5 , 6 } ;
3 t = m ; / / t e t m d e s i g n e n t u n meme t a b l e a u
4 T e r m i n a l . e c r i r e S t r i n g l n ( ” t [ 0 ] = ” + t [ 0 ] ) ;
5 T e r m i n a l . e c r i r e S t r i n g l n ( ”m [ 0 ] = ” + m [ 0 ] ) ;
6 / / M o d i f i c a t i o n d e t [ 0 ]
7 t [ 0 ] = 9 ;
8 / / N o u v e a u x t [ 0 ] , m [ 0 ]
9 T e r m i n a l . e c r i r e S t r i n g l n ( ” N o u v e a u t [ 0 ] = ” + t [ 0 ] ) ;
10 T e r m i n a l . e c r i r e S t r i n g l n ( ” N o u v e a u m[ 0 ] = ” + m [ 0 ] ) ;
L’affectation de m dans t a pour effet de bord de rendre ces deux variables synonymes : elles ref´erent´ toutes les deux au mˆeme espace m´emoire, qui contient le tab leau {2, 3, 4, 5, 6} d´esign´ par m. L’affectation t[0] = 9 est ainsi “visible” lors d’un acc`es a` m. Ce programme affiche :
t[0] = 2
m[0] = 2
Nouveau t[0] = 9
Nouveau m[0] = 9
Enfin, les tableaux d´esign´es par les variables d’une affec tation peuvent avoir des longueurs diff´erentes.
Exemple 9 : Affectation entre tableaux de tailles diff´erentes.
1 i n t [ ] t = {1 0 , 2 0 };
2 i n t [ ] m = { 2 , 3 , 4 , 5 , 6 } ;
3 T e r m i n a l . e c r i r e S t r i n g l n ( ” L o n g u e u r d e t = ” + t . l e n g t h ) ;
4 t = m ; / / t c o n t i e n t m a i n t e n a n t u n t a b l e a u d e 5 e l e m e n t s
5 / / N o u v e l l e l o n g u e u r d e t
6 T e r m i n a l . e c r i r e S t r i n g l n ( ” N o u v e l l e l o n g u e u r d e t = ” + t . l e n g t h ) ;
Ce programme affiche :
Longueur de t = 2
Nouvelle longueur de t = 5
Egalite´ entre tableaux
Lorsqu’on compare deux tableaux par des tests d’egalit´e´ (==) ou d’inegalit´e´ (!=), le test porte
sur l’identite´ des tableaux et non sur leur contenu. Cela signifie qu’on cherche a` savoir, non pas si les tableaux contiennent les mˆemes el´ements, mais s’ils ont et´ cr´ees par un seul et mˆeme new. Voyons un exemple.
1 p u b l i c c l a s s T a b 5 {
2 p u b l i c s t a t i c v o i d m a i n ( S t r i n g [ ] a r g v ) {
3 i n t [ ] t a b 1 ;
4 i n t [ ] t a b 2 ;
5 i n t [ ] t a b 3 ;
6 t a b 1 = new i n t [ 3 ] ;
7 t a b 1 [ 0 ] = 1 0 ;
8 t a b 1 [ 1 ] = 2 0 ;
9 t a b 1 [ 2 ] = 3 0 ;
10 t a b 2 = new i n t [ 3 ] ;
11 t a b 2 [ 0 ] = 1 0 ;
12 t a b 2 [ 1 ] = 2 0 ;
13 t a b 2 [ 2 ] = 3 0 ;
14 t a b 3 = t a b 2 ;
15 i f ( t a b 1 == t a b 2 ) {
16 T e r m i n a l . e c r i r e S t r i n g l n ( ” t a b 1 e t t a b 2 s o n t e g a u x ” ) ;
17 } e l s e {
18 T e r m i n a l . e c r i r e S t r i n g l n ( ” t a b 1 e t t a b 2 s o n t d i f f e r e n t s ” ) ;
19 }
20 i f ( t a b 2 == t a b 3 ) {
21 T e r m i n a l . e c r i r e S t r i n g l n ( ” t a b 2 e t t a b 3 s o n t e g a u x ” ) ;
22 } e l s e {
23 T e r m i n a l . e c r i r e S t r i n g l n ( ” t a b 2 e t t a b 3 s o n t d i f f e r e n t s ” ) ;
24 }
25 }
26 }
L’ex´ecution du programme donne :
> java Tab5
tab1 et tab2 sont diff´erents
tab2 et tab3 sont egaux´
Explication : tab1 et tab2 sont deux tableaux dont les contenus sont egaux,´ mais ces deux tableaux ont et´ cr´e´es par deux new diff´erents. Il s’agit donc de deux espaces m´emoires disti ncts. Changer l’un ne change pas l’autre. En revanche, tab2 et tab3 sont cr´e´es par un seul et unique new. Changer le contenu de l’un change aussi le contenu de l’autre. Il s’agit d’un seul et unique espace m´emoire.

Exemples avec tableaux unidimensionnels

Exemple 10 : Recherche du minimum et maximum dans un tableau d’entiers. Deux variables min
boucle de recherche des minimum et max sont initialisees avec le premier element du tableau. La  et maximum, compare chaque element avec ces deux valeurs. La comparaison se fait a` partir du deuxieme element : c’est pourquoi l’indice i debute a i=1.