INITIATION A LA

PROGRAMMATION JAVA

Mme. KASSE L2 UADB

1
 PLAN DU COURS
Historique
Principes de la POO
Exemple de programme
Les instructions de contrôle
La POO
Les tableaux
Les chaines de caractères
Héritage
CHAPITRE IV

Les tableaux en JAVA

3
 Introduction

Dès que l'on travaille avec de nombreuses données homogènes ( de même type), la
première
structure de base permettant le regroupement de ces données est le tableau. Java
comme tous les langages algorithmiques propose cette structure au programmeur.
Comme pour les String, pour des raisons d'efficacité dans l'encombrement
mémoire, les tableaux sont gérés par Java, comme des objets.

Les tableaux Java sont comme en Delphi, des tableaux de tous types y
compris des types objets.
Il n'y a pas de mot clef spécifique pour la classe tableaux, mais
l'opérateur symbolique [ ] indique qu'une variable de type fixé est un
tableau.
La taille d'un tableau doit obligatoirement avoir été définie avant que Java
accepte de l’utilisiez !

4
 Tableaux à une dimension
Déclaration d'une variable de tableau :

type identificateur [ ] ;
ou
type [ ] identificateur ;

Exemples:

int [ ] table1;
char [ ] table2;
float [ ] table3;
...
String [ ] tableStr;

5
 Définition et création d’un tableau

Déclaration d'une variable de tableau avec définition explicite de

taille :
int [ ] table1 = new int [5];
char [ ] table2 = new char [12];
float [ ] table3 = new float [8];
...
String [ ] tableStr = new String [9];
Le mot clef new correspond à la création d'un nouvel objet (un
nouveau tableau) dont la taille
est fixée par la valeur indiquée entre les crochets. Ici 4 tableaux
sont créés et prêts à être utilisés :
table1 contiendra 5 entiers , table2 contiendra 12 caractères,
table3 contiendra 8 réels en simple précision et tableStr
contiendra 9 chaînes de type String.

6
Déclaration et création d’un tableau

Les tableaux peuvent être initialisés par l'intermédiaire d'une

liste de valeurs séparées par une virgule et compris entre des
accolades .
type [ ] identificateur = { valeur1, ..., valeurN };
type identificateur [ ] = { valeur1, ..., valeurN };
int [ ] table1 = {17,-9,4,3,57};
char [ ] table2 = {'a','j','k','m','z'};
float [ ] table3 = {-15.7f,75,-22.03f,3,57};
String [ ] tableStr = {"chat","chien","souris","rat","vache"};
Dans cette éventualité Java crée le tableau, calcule sa taille et
l'initialise avec les valeurs fournies.

7
Déclaration et création d’un tableau

Il existe un attribut général de la classe des

tableaux, qui contient la taille d'un tableau
quelque soit son type, c'est l'attribut length.
Exemple :
int [ ] table1 = {17,-9,4,3,57};
int taille;
taille = table1.length; // taille = 5

8
 Accéder aux éléments d’un tableau
Un tableau en Java comme dans les autres langages algorithmiques,
s'utilise à travers une cellule de ce tableau repérée par un indice
obligatoirement de type entier. Le premier élément d'un tableau est
numéroté 0, le dernier length-1.
On peut ranger des valeurs ou des expressions du type général du
tableau dans une cellule du tableau.
Exemple avec un tableau de type int
int [ ] table1 = new int [5];
table1[0] = -458;
table1[4] = 5891;
table1[5] = 72;
for (int i = 0 ; i<= table1.length-1; i++)
table1[i] = 3*i-1; //

9
 Accéder globalement au tableau
La manipulation globale d’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
0
même type de composantes. 1
int [ ] tab = new int [3] ; tab 2

for(int i = 0; i < 3; i++) tab [i] = i ;

10
int [ ] t = new int [2] ; t 11
for(int i =0 ; i < 2 ;i++) t[i] = i+10 ;
10
Tableau en argument ou en valeur de retour

Comprenez la transmission d’un tableau en argument ou en valeur

de retour d’une méthode comme celle réalisée avec les objets.
Lorsqu’on transmet un nom de tableau en argument 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 .

11
 Exemple

public class TabInverse { public class RunTabInverse {

public static void main( String args[
public static int[ ] inverseTab (int t[ ])
])
{ int tabres[ ] = new int [t.length]; { int tabAinverser [ ] = new int [5];
for ( int i = t.length - 1; i > = 0 ; i--) tabAinverser [0] = 1;
tabres [ t.length – i - 1] = t[ i ]; tabAinverser [1] = 80;
tabAinverser [2] = 71;
return tabres; tabAinverser [3] = 6;
} tabAinverser [4] = 500;
public static void afficheTab( int t[ ]) afficheTab(inverseTab
(tabAinverser));
{ for ( int i = 0; i < t.length; i++) }
System.out.print ( t[ i ]+ " "); }
}

12
 Tableaux à deux dimensions

Pour déclarer un tableau à deux dimensions, on peut utiliser l’une de ces trois
déclarations qui sont équivalentes :
int t [ ] [ ] ;
int [ ] t [ ] ;
int [ ] [ ]t ;
Elles déclarent que t est une référence à un tableau, dans lequel chaque élément
est lui-même une référence à un tableau d’entiers . Pour l’instant, aucun tableau
de cette sorte n’existe encore .

13
Création de tableaux à 2 dimensions

Exemple
int [ ][ ] table1 = new int [2][3];
table1[0][0] = -458;
int [ ][ ] table = new int [n+1][p+1];

14
 Autres exemples

Rien n'oblige les tableaux référencés d'avoir la même dimension,

ce type de tableau se dénomme tableaux en escalier ou tableaux
déchiquetés en Java :
int [ ][ ] table = new int [3][ ];
table[0] = new int[2];
table[1] = new int[4];
table[2] = new int[3];

15
 Taille d’un tableau multi indices
Le même attribut général length de la classe des tableaux, contient la
taille du tableau :
Exemple : matrice à deux lignes et à 3 colonnes
int [ ][ ] table1 = new int [2][3];
int taille;
taille = table1.length;
taille = table1[0].length;
taille = table1[1].length;
Java initialise les tableaux par défaut à 0 pour les int, byte, ... et à
null pour les objets

16
 Les chaines de caractères(String)

La classe String permet de manipuler « les chaînes de

caractères ».

String chaine;
chaine =« "ca c ’est un objet chaine de caractère »

La classe String possède plusieurs constructeurs dont:

String( ); // pour construire une chaine vide
String (String original ); // crée un objet contenant la
chaine original

17
Les chaines de caractères(String)

Un objet de type String n’est pas modifiable.

Sera détruit
String chaine1= " salut "; salut
s’il n’est plus
référencé.

chaine1

chaine1 += " le monde ";

salut le monde

18
 Les méthodes de la classe String (1/4)

/*retourne la longueur de l'objet String.*/

int length ( )
/*retourne un nouvel objet String résultant du remplacement de toutes les
occurrences d'un caractère donnée par un autre caractère. */
String replace(char oldChar, char newChar)
/*remplace dans une chaîne de caractères, chaque sous-chaîne qui correspondent
à l'expression régulière fournie, par une chaîne de caractères de remplacement*/
String replaceAll (String origine, String remplacement)
/*teste si l'objet String démarre au préfixe spécifié. */
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)
19
 Les méthodes de la classe String (2/4)

/*retourne le caractère positionné à l'index spécifié. */

char charAt (int index)
/*compare l'objet String à un autre objet o. Retourne 0 en cas d’égalité
-1 en cas d’infériorité et 1 en cas de supériorité */
int compareTo (Object o)
/*comparaison lexicographique de deux chaines. Retourne 0 en cas
d’égalité -1 en cas d’infériorité et 1 en cas de supériorité */
int compareTo(String anotherString)
/*compare deux chaînes lexicographiquement en ignorant la casse de
caractères*/
int compareToIgnoreCase (String str)
/*concatène l'objet String à une autre chaîne de caractères. */
String concat (String str)
/*retourne true si et seulement si l'objet String représente la même
séquence de caractères comme l'objet StringBuffer spécifié. */
boolean contentEquals (StringBuffer buff)

20
 Les méthodes de la classe String (3/4)

/*retourne un nouvel objet String qui représente la séquence de caractères

dans le tableau spécifié. */
static String copyValueOf (char[ ] data)
/*teste si la fin de l'objet String correspond au suffixe spécifié. */
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. */
boolean equalsIgnoreCase (String anotherString)
/*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)

21
 Les méthodes de la classe String (4/4)

/*retourne l'index à l'intérieur de l'objet String de la première occurrence de

la sous-chaîne spécifiée. */
int indexOf (String str)
/*retourne l'index à l'intérieur l'objet String de la première occurrence de la
sous-chaîne spécifiée à partir d'une certaine position. */
int indexOf(String str, int fromIndex)
/*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)

22
 Utilisation de quelques méthodes

String ch = "Le langage Java est vraiment très puissant";

ch.length ( );// longueur de la chaine est 42 (espaces compris)

ch.substring ( 11);

"Java est vraiment très puissant ";

ch.substring ( 0,16);//attention: le caractère à l’indice 16 n’est pas
extrait
"Le langage Java ";

ch.toUpperCase ( );// il existe aussi toLowerCase

"LE LANGAGE JAVA EST VRAIMENT TRÈS PUISSANT"

ch = " bonjour \n" ;
ch.trim( ) //supprime les espaces de début et de fin dans la chaine
"bonjour"
23
 Utilisation de quelques méthodes
String s= " java " ;
String ch = " java " ;
s.equals (ch); // ici renvoie true car equals est redéfinie dans String

s.charAt (0); // renvoie le caractère à la position 0 donc j

char c [ ] = s.toCharArray( );// renvoie un tableau de caractères

c vaut { ‘j’,’a’,’v’,’a’}

ch.indexOf ( a); // l’indice de la 1ère occurrence trouvée

renvoie la valeur 1
ch.indexOf ( a,2); // l’indice de la 1ère occurrence trouvée à partir de 2
renvoie la valeur 3

24
 L’opérateur +

L’opérateur + permet de concaténer deux chaînes de caractères. Il est

défini lorsque ses deux opérandes sont des chaînes. Il renvoie un
résultat qui est la Concaténation des deux chaînes.
String chaine1 = "Programmer en Java" ;
String chaine2 = "c’est vraiment bien";
String chaineConcat = chaine1 + chaine2;

Programmer en Java
chaine1

chaine2 c’est vraiment bien

chaineConcat Programmer en Java c’est vraiment bien

25
 Conversion de types primitifs en chaines

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

26
Conversion de chaines en typesprimitifs

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 entière 3521
On dispose aussi des méthodes:
Byte.parseByte
Short.parseShort
Integer.parseInt
Long.parseLong
Double.parseDouble
Float.parseFloat

27
 Chaines et tableaux

En 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 caracteres*/
String ch = new String (mot); // ch = " bonjour "
/*constructeur avec le premier caractère et le nombre de
caracteres*/
String ch2 = new String (mot, 3,4);// ch = " jour "

String ch = " bonjour " ;

char [ ] mot = ch.toCharArray ( );

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

28
 La classe StringTokenizer

Cette classe n’ a aucun lien direct avec la classe String, elle se trouve
d’ailleurs dans le paquetage 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 un nombre de « délimiteurs ».
Cette méthode divise une chaîne en différents éléments
appelés tokens.
String s = " Java, est: un .langage ;interessant";
StringTokenizer st = new StringTokenizer (s, " ,;:. " );
while (st.hasMoreTokens ( ))//tant qu’il y a des tokens
{ st.nextToken( ) ; // renvoie le premier element et se positionne sur le
suivant
// cette méthode renvoie un objet String.
}

On trouve 5 tockens : Java est un langage interessant

29