java vector chaine de cractères éléments de base

1. CHAPITRE 3
ÉLÉMENTS DE BASE DU LANGAGE
JAVA

2. 1. Les structures de contrôle
Utilisation des mêmes structures de contrôle que le langage C.
1.1. La structure if
class IfApp {
public static void main (String args []){
int c = 0;
if ( c == 1)
System.out.println(“ici vaut 1”);
else
System.out.println(“ici vaut 0”);
}
}
L’évaluation de l’expression de la condition « if » est obligatoirement de type booléen ;
1.2. La structure switch
char c = (char) System.in.read() ;
switch (c)
{ case ‘a’: case ‘A’: System.out.println(“A”);
break;
case ‘b’: case ‘B’: System.out.println(“B”);
break;
default : System.out.println (“Erreur”);
break;
}
1.3. Les structures while et do…while
int c ;
do {
System.out.println(“Entrez un nombre positif <= 5”);
c = Clavier.lireInt() ; //classe Clavier permet de saisir à partir du clavier
} while ( c <= 0 || c > 5);
while ( c > 0)
System.out.println( c--) ;

3. 1.4. La structure for
int i;
for (i=0; i<=5; i++)
System.out.println(i);
for (int j =0; j<=5;j++)
System.out.println(j);
j=2; //Erreur, j est local à for
2. Typage en Java
Les types primitifs en Java sont similaires au langage C (int, short, long, float, double,
char, boolean, …)
Les constantes en Java sont déclarées en ajoutant le mot-clé final
Exemple :
final double PI = 3.141592 ;
En java, il y a deux possibilités de conversions des types des variables :
Conversion explicite (nommée casting)
Conversion implicite (3 cas) :
Conversion lors d’une affectation
Conversion lors d’un passage de paramètre
Conversion lors d’une promotion arithmétique (les opérandes ne sont pas du même
type). Le choix de l’opérande à convertir se fait du type le plus restreint vers le
type le plus large.
Les conversions implicites légales en Java sont :
byte short int long float double
char - int long float - double
Les conversions explicites (Casting) sont celles qui peuvent provoquer une perte de valeur.
(exp de float vers int)
Exemples :
int i, j ;
short s =2 ;
float f =1.5 ;
i = (int) f ; //conversion explicite obligatoire car avec perte de données
i =s ; //conversion implicite
f =i/2.0 ; //conversion par promotion arithmétique
j=objet.meth(s) ; //conversion lors d’un passage de paramètres
(méthode : int meth (int arg))

4. 3. Les tableaux
En java, le type tableau est assimilable à une classe et un tableau est un objet de cette
classe.
Une variable tableau ne représente pas l’objet lui-même mais son adresse mémoire
Le type des éléments d’un tableau est unique et il est fixé dès sa définition.
Si le type des éléments du tableau est simple, java stocke directement les valeurs dans
les éléments du tableau
Si le tableau contient des objets construits à partir d’une classe standard ou définie par
le programmeur les éléments du tableau contiennent toujours des références aux objets
à stocker et non pas les objets eux-mêmes
La taille d’un tableau est indiquée à sa création par l’opérateur new.
3.1. Tableau à une dimension
Déclaration : <type> <nomtableau> [ ] ; ou bien <type> [ ] <nomtableau> ;
Définition : <nomtableau> = new <type> [taille] ;
int [] TEntier; TEntier = new int [5];//Création d’un tableau de 5 entiers
float [] TReel = new new float [10]; //Création d’un tableau de 10 réels
Initialisation :
L’initialisation par défaut est 0 pour les nombres, false pour les booléens et null sinon.
On peut initialiser un tableau à la déclaration par une liste de valeurs séparés par virgule et
entre {}
<type> [ ] <nomtableau> = {val1, val2, …, valn} ;
int [ ] notes = {10, 9, 14, 12, 8, 16} ;
Utilisation :
L’accès aux éléments d’un tableau se fait par ses indices dont le premier est l’indice 0.
Deux variables peuvent référencer le même tableau par simple affectation
int [] notes = new int [10] ; //création d’un tableau de 10 entiers
int [] resultats = notes ; // notes et resultats opèrent sur le même tableau
notes = new int [50] ; // redéfinition de notes. notes est désormais un tableau
de 50 entiers initialisés à 0.
La propriété length de l’objet tableau fournit la taille du tableau. On peut l’utiliser dans la
boucle for.
for (i = 0 ; i < notes.length ; i++)

5. 3.2. Tableau à plusieurs dimensions
Ce sont des structures complexes possédant plusieurs indices. Les dimensions sont en fait
des références vers de simples tableaux.
La définition des tailles d’un tableau multidimensionnel utilise, à l’instar des tableaux
simples, l’opérateur new.
Déclaration :
<type> <nomtableau> [ ] [ ] ; ou bien <type> [ ] [ ] <nomtableau> ;
Définition :
<nomtableau> = new <type> [taille1] [taille2] ;
<type> <nomtableau> [ ] [ ] = new <type> [taille1] [taille2] ;
Initialisation :
<type> <nomtableau> [ ] [ ] = {{ensemble valeurs 1}, {ensemble valeurs 2}} ;
int [] [] a ;
a = new int [2][3] ; //tableau a qui pointe sur un tableau de taille 2 qui pointe
sur un tableau de taille 3. Ce dernier contient les entiers.
La notation a[0] désigne la référence au premier tableau de 3 entiers.
La notation a[0][1] désigne le deuxième élément du premier tableau.
La notation a[1] désigne la référence au second tableau de 3 entiers.
La notation a[1][i-1] désigne le ième
élément de ce tableau.
L’expression a.length vaut 2.
L’expression a[0].length vaut 3.
L’expression a[1].length vaut 3.
a

6. float [] [] [] b = new float [2] [2] [2] ;
3.3. Tableaux d’objets
Un tableau déclaré à partir d’une classe, contient des références à des objets de la classe
en question.
Chaque élément du tableau représente une référence à un objet.
L’accès à un attribut ou une méthode d’un objet contenu dans un tableau se fait avec
l’opérateur « . »
Exemple :
Point [] T ;
T = new Point [3] ;
T[0] = new Point (1,2) ;
T[1] = new Point (4,5) ;
T[2] = new Point (8,9) ;
for (int i= 0 ; i<T.length ; i++)
T[i].affiche();
4. La classe Vector
La classe Vector de Java décrit un conteneur d’objets.
Une instance de la classe Vector implémente un tableau d’objets auxquels on accède par
un indice entier. La taille de ce tableau est variable.
Les objets ( c-à-d les références d’objets) à mettre dans l’instance de Vector peuvent être
de types différents.
Un conteneur ne peut pas contenir des éléments de types primitifs. Sauf si on passe par les
wrapper (des classes contenant des types de données primitives : Integer, Character, …)
b

7. Pour utiliser Vector, il faut importer la package :
Plusieurs méthodes sont offertes dans la classe Vector. Parmi lesquels :
void addElement (Object obj) : ajoute obj à la fin du vecteur
void insertElementAt (Object obj, int i) : insère obj à la position i
void removeElementAt (int i) : supprime l’objet à la position i
void removeAllElements () : supprime tous les éléments
Object elementAt (int i) : retourne une référence sur l’élément à la position i sans
l’éliminer
boolean contains (Object obj) : teste si obj existe
int indexOf (Object obj) : retourne la position de obj (retourne -1 si obj n’existe pas)
int size() : retourne la taille du vecteur
Exemple :
import java.util.*;
...
Vector vec = new Vector();
for (int i=0 ; i<10 ; i++) {
Integer element = new Integer (i);
vec.addElement (element); //ajout à la fin du vecteur
} // 0 1 2 3 4 5 6 7 8 9
String i = "java" ;
vec.insretElementAt(i,5); //insertion à la position indiquée 0 1 2 3 4 java 5 6 7 8 9
Integer k = (Integer) vec.elementAt(5) ;
5. Les chaines de caractères
5.1. Le type char
Une chaine de caractère peut être contenue dans un tableau de char.
Cependant cette solution n’offre pas la possibilité d’utiliser des services de manipulation
standard de chaines. (elle est donc rarement utilisée)
Exemple :
char [] tableau;
tableau = new char[4] ;
tableau[0]= ‘j’; tableau[1]= ‘a’; tableau[2]= ‘v’; tableau[3]= ‘a’;
System.out.println (tableau); // affiche java

8. 5.2. La classe String
La classe String est fournie par java est décrit des objets contenant une chaine de
caractère constante.
Le contenu de l’objet String ne peut pas être modifié mais sa référence peut désigner un
autre objet String.
Ce ne sont pas des tableaux de caractères comme en C.
String dispose de deux constructeurs : l’un sans arguments créant une chaine vide, l’autre
avec argument de type String qui en crée une copie.
Exemple :
String ch1 = new String (); //ch1 contient une référence à une chaine vide
String ch2 = new String ("hello");
Considérons la situation suivante :
String ch1, ch2, ch3;
ch1 ="bonjour" ;
ch2 ="bonsoir" ;
ch = ch1 ;
ch1 = ch2 ;
ch2 = ch;
Les deux objets String n’ont pas été modifiés, mais les références ch1 et ch2 l’ont été.
5.3. Concaténation entre chaines
La classe String utilise l’opérateur + et += pour concaténer des chaines.
Lorsqu’une opérande est de type String, l’autre peut être d’un autre type (primitif ou autre
objet), dans ce cas, la valeur de l’objet sera convertie en String en utilisant la méthode
toString() de la classe de l’objet.
Remarque :
toString() est une méthode de la classe mère Object qui peut être utilisée par toutes ses
filles. (voir chapitre sur l’héritage)
Exemple :
int n = 26 ;
System.out.println ("n=" + n ) ; // => affiche n=26
String ch = "bonjour";
ch += "monsieur";

9. La chaine "bonjour" devient candidate au ramasse miettes (Garbage Collector) dès la
fin de la seconde instruction
L’opérateur += n’est utilisable que lorsque les deux opérandes sont de type String
5.4. Comparaison de chaines
Il faut faire la différence entre la valeur de l’objet String et sa référence.
En créant des chaines identiques en utilisant l’affectation, la machine Java crée un seul
objet String avec plusieurs références.
L’utilisation explicite de new force Java à créer un nouvel objet String.
On peut utiliser == et != pour comparer des String mais avec prudence.
Exemple :
String s1 = "Bonjour!" ;
String s2 = "Bonjour!" ;
String s3 = new String ("Bonjour!") ;
if (s1 == s2) retourne true
if (s1 == s3) retourne false
if (s2 != s3) retourne true
String s4 = "Bon"; s4 += "jour!";
if (s1 == s4) retourne false
5.5. Quelques méthodes de String
boolean equals (String) : compare le contenu de deux chaines. Il s’agit en fait d’une
redéfinition de la méthode equals, héritée de la super classe Object.
boolean equalsIgnoreCase (String) : effectue la même comparaison mais sans distinguer
les majuscules des minuscules.
Chaine1.compareTo (chaine2) : compare les chaines selon l’ordre d’apparition des
caractères. Retourne un entier :
Négatif si chaine1 arrive avant chaine2
Nul si chaine1 et chaine2 sont égales (chaine1==chaine2)
Positif si chaine1 arrive après chaine2.
int length() : permet d’obtenir la longueur d’une chaine (nombre de caractères)
char charAt (int i) : retourne le caractère qui se trouve à la position i dans la chaine
courante (les indicent commencent à 0).
int indexOf (char c) : retourne la position du caractère c.
String toLowerCase () : convertie une chaine en minuscule

10. 5.6. Conversion entre chaines et types primitifs
La méthode valueOf de la classe String convertie une valeur de type primitif en une
valeur de type chaine.
Exemple :
int n = 45 ;
String s = String.valueOf(n) ; // fournie la chaine “45”
Remarques :
String.valueOf(obj) ; est équivalente à obj.toString() ;
String.valueOf(n) ; est équivalente à Integer(n).toString() ;
Les méthodes parseXXX des classes enveloppes associées aux types primitifs, permettent
de convertir une chaine au type primitif désiré. (Integer.parseInt, Float.parseFloat,
Long.parseLong, …)
Exemple :
String s = "427" ;
int n = Integer.parseInt(s);
5.7. Les arguments de la ligne de commande
public static void main (String args [])
La méthode main reçoit un paramètre de type tableau de String.
Ce tableau est destiné à contenir les éventuels arguments fournis au programme lors de
son exécution (en ligne de commande dans le cas d’une console)
La longueur du tableau reçu indique le nombre d’arguments.
Exemple :
public static void main (String [] args){
int nb = args.lentgh;
if (nb == 0)
System.out.println(“pas d’argument”);
else {
for (int i=0 ; i<nb ; i++)
System.out.println(“Argument N°” + i+1 + “ = ” + args[i]);
}
}

11. 6. Exercices
Exercice 1 :
Ecrire un programme qui permet de faire la somme des 100 premiers entiers naturels.
Exercice 2 :
Ecrire un programme qui permet de saisir une série de notes dans un tableau T. Le nombre de
notes ne doit pas dépasser 30. Ce programme doit ensuite éclater le tableau en deux autres :
T1contiendra les valeurs >= 10 et T2 contiendra le reste. L’affichage des valeurs des tableaux
résultats se fait par une méthode Afficher (Tableau, dimension).
Exercice 3 :
La table de Pythagore donne le résultat des multiplications suivantes :
1. Ecrire une classe Pythagore caractérisée :
• Une variable membre privée : matrice de dimension 9 lignes et 9 colonnes
• Un constructeur qui initialise la matrice
• Une méthode public int multiplier (int, int) qui multiplie deux nombres et
retourne le résultat de multiplication à partir de la table de Pythagore.
• Une méthode int somme_Lig (int) qui fournit la somme des éléments d’une ligne.
• Une méthode int somme_Col (int) qui fournit la somme des éléments d’une
colonne.
2. Ecrire un programme principal qui utilise les méthodes : multiplier, somme_Lig et
somme_Col.
3. Ecrire deux méthodes (non membres de Pythagore) : int Diag1 (Pythagore P) qui
calcule la somme de la première diagonale et int Diag2 (Pythagore P) qui calcule la
somme de la deuxième diagonale.
Exercice 4 :
1. Ecrire une classe Vecteur caractérisée par deux attributs privés : une dimension d et un
tableau d’entiers.
• La dimension est fournie au constructeur comme paramètre
• Une méthode getDimension () retourne la dimension du tableau
• Une méthode getElement (int) qui permet de retourner l’élément d’une position
2. Ecrire une méthode afficher() membre de Vecteur qui affiche ses éléments
Ecrire une méthode afficher(Vecteur) non membre de Vecteur
3. On désire implémenter une méthode boolean coincide (Vecteur) de Vecteur qui
permet de tester si deux vecteurs sont identiques ou non.

12. 4. On désire implémenter une méthode boolean coincide (Vecteur, Vecteur) de
Vecteur qui permet de tester si les éléments de deux vecteurs sont identiques ou non.
5. Utiliser des objets v1, v2 et v3 de type Vecteur pour réaliser des appels à
coincide (Vecteur, Vecteur). Donner l’appel à la méthode adéquate pour que :
v1 teste l’égalité de v2 et v3
v1 teste l’égalité de v1 et v2
6. Que serait la méthode coincide pour tester l’égalité des éléments de l’objet en cours
avec ceux d’un autre.
Exercice 5 :
1. Ecrire une classe Chaine avec deux String (s1 et s2) comme attributs, ainsi que les
méthodes suivantes :
Le constructeur par défaut initialise s1 à « le chat joue » et s2 à « avec la souris »
int longueur (String) : retourne la longueur d’un String
void caractere (int, String) : affiche le nième caractère d’un String
void sousChaine (int x, int y, String) : affiche une sous chaine du caractère x
au caractère y
boolean comparaison (String, String) : pour tester si deux chaines sont
identiques
void concatener (String, String) : pour concaténer s1 à s2
boolean egalite (String, String): pour tester si une chaine est égale à une autre
2. Tester toutes ces méthodes en leurs faisant appel dans un programme principal.
Exercice 6 :
1. Ecrire une classe User qui représente un utilisateur caractérisé par un login et un mot de
passe qui sont deux attributs privés. La classe contient un constructeur et les méthodes
suivantes : getLogin, getMdp, setLogin et setMdp.
2. Ecrire une classe Users caractérisée par un vecteur d’objet de type Vector et un entier
représentant le nombre d’utilisateurs. Son constructeur prend en entrée le nombre
d’utilisateurs et remplit le vecteur par des objets de type User.
3. Ajouter la méthode public void supprimeDoublons (User u) à Users qui permet de
ne laisser qu’une seule occurrence de l’utilisateur u dans le vecteur.
4. Ajouter la méthode public void afficher() à Users qui affiche la liste des utilisateurs.
5. Ecrire une classe Test qui permet de :
- créer un tableau d’utilisateurs (objet de type Users) et les afficher
- créer un objet User puis appelle la méthode de suppression de doublons et réaffiche les
utilisateurs (sans doublons).
Exercice 7 :
1. Ecrire une classe Caractere qui contient une variable char et un constructeur.
2. Lui ajouter la méthode public int convertirEntier()qui permet de convertir le
caractère en entier. Pour les caractères numériques, il faut les convertir en leurs valeurs
respectives. Les autres sont convertis en leurs valeurs de code ascii.
3. Tester la classe dans un programme.