Éléments de syntaxe Java

La référence : The Java Tutorials de Sun Microsystems Inc., les créateurs de

Java.

Table des matières

Instructions en Java
Les identificateurs (noms) de variables
Déclaration de variables – sans initialisation
Déclaration de variables – avec initialisation
Affectation simple
Opérateurs arithmétiques
Entrées
Sorties
Énoncés de sélection
Opérateurs relationnels
Les commentaires
Les constantes
Les opérateurs logiques
Comparaison de chaînes de caractères
Énoncé d’itération « while »
Opérateurs préfixés ++ et --
Affectation composée
Recettes de programmation
Concaténation de Strings en Java avec l’opérateur +
Énoncé d’itération do…while
Instruction switch
Variables booléennes
Énoncé for
Tableaux (« arrays »)
Caractères : type char
Un peu plus sur les chaînes de caractères
Opérations sur les chaînes de caractères
Lecture et écriture des fichiers
Nombres aléatoires

Instructions en Java
instruction 1;
instruction 2;
instruction 3;
...

▪ Une instruction par ligne, typiquement

▪ Chaque instruction se termine par un point-virgule
▪ Le blanc est ignoré, entre les instructions, entre les mots d’une instruction

Exemples
 System.out.println("Salutations !");

Les identificateurs (noms) de variables

▪ Tous les caractères alphanumériques et _ sont permis dans les noms de
variables
▪ Les identificateurs doivent commencer par une lettre, $ ou _
▪ Les identificateurs sont sensibles aux majuscules/minuscules (case
sensitive), par exemple, unNom est différent de UNNOM
Exemples de noms corrects Exemples de noms incorrects
maVariable 2plus2
sommeTotale 007
i facture+taxe
somme2 TAXE-TPS
TAXE_TPS

▪ Java se réserve une liste de mots-clés, que l’on ne peut pas utiliser pour
des identificateurs dans notre code.
En voici une liste

abstract continue for new switch

assert default goto package synchronized
boolean do if private this
break double implements protected throw
byte else import public throws
case enum instanceof return transient
catch extends int short try
char final interface static void
class finally long strictfp volatile
const float native super while

Déclaration de variables – sans initialisation

type_var nomVariable;

▪ La déclaration permet de créer une variable pour l’utiliser dans notre

programme
▪ type_var peut être l’un des types de variables que nous voyons dans le
cours : int, double, String, char, boolean
▪ La variable nouvellement créée n’est pas initialisée à ce stade

Exemples
int nombre1;
double totalFacture;
String monNom;
boolean estFumeur;

Déclaration de variables – avec initialisation

type_var nomVariable = valeur_initiale;

▪ La variable nomVariable est initialisée avec la valeur valeur_initiale

▪ Recommandé : on est ainsi certain de la valeur que l’on donne à une
nouvelle variable
Exemples
int nombre1 = 0;
double totalFacture = 0.0;
String monNom = "B. Wayne"; // notez les guillements anglais
String variableSansRien = null; // null veut dire “rien”
boolean estFumeur = false; // moins de cancer, plus d'argent

Affectation simple
nomVariable = valeur;
nomVariable = expression;

▪ La valeur ou l’expression doit être du même type que nomVariable

▪ expression peut être un calcul

Exemples
nombre1 = 3;
rabais = 0.32;
leGagnant = "Robert C.";

nombre1 = 3 + 3 * 43;
totalFacture = totalFacture * 0.97;
estMajeur = (age >= 18);

Opérateurs arithmétiques
▪ Les expressions mathématiques sont construites avec des opérateurs et des
opérandes. Dans l’expression x + y, x et y sont des opérandes, + est
l’opérateur.
▪ Quelques-uns des opérateurs de base

+ addition
- soustraction
* multiplication

/ division
Dès lors qu’un opérande est un nombre réel, fait un calcul « exact » : 17.0 / 3.0
vaut 5.66666666
Lorsque les opérandes sont toutes deux des entiers, tronque le résultat : 17 / 3
donne 5

% modulo
Donne le reste de la division
17 % 4 donne 1
4 % 17 donne 4

- (rend le nombre qui suit négatif)

si variable vaut 10, alors –variable vaut -10

Priorité : les opérateurs sont listés ci-dessus du moins prioritaire au plus

prioritaire.

Entrées
Ici, il y a des lignes « magiques » qu’il faut ajouter au programme. Vous les
éluciderez par la suite.
Pour préparer la lecture, il faut modifier son programme pour qu’il ressemble
au squelette de programme suivant, où les instructions importantes sont
marquées comme ceci.
/*
* Commentaire d'en-tête
*/

package nomdupackage;

import java.io.*;

/**
*
* @author FG
*/
public class NomClasse
{

/**
* @param args the command line arguments
*/
public static void main(String[] args) throws IOException
{
BufferedReader r = new BufferedReader(new InputStreamReader
(System.in));
reste du programme
}

Il est ensuite possible d’ajouter les instructions de lecture au clavier après ces
modifications.

Lecture d’une chaîne de caractères saisie au clavier

nomVariable = r.readLine();

Lecture d’un entier saisi au clavier

nomVariable = Integer.parseInt(r.readLine());

Lecture d’un réel saisi au clavier

nomVariable = Double.parseDouble(r.readLine());

▪ Si on veut lire un nombre au clavier, mais que Java ne peut reconnaître le

nombre, il se produit une erreur que Java vous signalera.

Sorties
Les sorties sont plus simples.

System.out.println affiche expression, puis retour

(expression); chariot

System.out.print affiche expression, sans retour

(expression); chariot après

▪ L’expression peut être unique, ou contenir des morceaux collés

ensemble (on dit qu’ils sont concaténés) avec l’opérateur +
Exemples
System.out.println("Bonjour le monde !");
System.out.print(nomVariable);

System.out.println("Le total est : " + totalFacture + "

$");

Énoncés de sélection
Il y en a trois formes.

Forme simple Forme avec else-if

if (condition) if (condition1)
{ {
instructions; instructions1;
} }
else if (condition2)
{
Forme if-else instructions2;
if (condition) }
{ else if (condition3)
instructions1; {
} instructions3;
else }
{ …
instructions2; else
} {
instructionsn;
}
▪ Les blocs d’instructions sont délimités par des accolades ({ }), situées une
au-dessus de l’autre
▪ La condition (appelée aussi test) est entre parenthèses
▪ Le bloc else est toujours optionnel
▪ La première condition qui est trouvée vraie entraîne l’exécution de son
bloc d’instructions
▪ Le bloc d’instructions entre accolades est en retrait (il y a du blanc avant)
par rapport à l’énoncé qui précède

Exemples
if (montantFacture >= 100.0)
{
System.out.println("Votre facture excède 100,00 $");
rabais = 0.25 * 100.0;
}
else if (montantFacture < 10.0)
{
System.out.println("Pas de rabais aujourd’hui!");
}
else
{
System.out.println("Votre facture est entre 10,00 et
100,00 $");
rabais = 0.15 * 100.0;
}

Opérateurs relationnels
Les conditions vues jusqu’à présent s’expriment souvent à l’aide d’opérateurs
relationnels, qui servent à comparer des valeurs entre elles.
 < plus petit que

<= plus petit ou égal à

> plus grand que

>= plus grand ou égal à

== égal à

!= n’est pas égal à

Exemples
if (montantFacture > 100.0)
{
…
}

if (agePatient == 18)
{
…
}

Les commentaires
Les commentaires servent à documenter le code, c’est-à-dire à ajouter des
notes pour l’expliquer.

Ils sont ignorés par le compilateur.

1re forme, sur une ligne

// ce qui suit est ignoré, jusqu’à la fin de la ligne

2e forme, sur plus d’une ligne

/*
Ce commentaire comporte plus d’une ligne. Il commence par
une barre oblique – étoile et se termine par une étoile
- barre oblique, tout entre les deux est ignoré.
*/

▪ Au lieu de détruire du code sur lequel on travaille, on peut le mettre en

commentaire, puis le détruire définitivement seulement lorsqu’on est
certain qu’il est inutile
▪ Les commentaires sont idéaux pour les en-têtes (débuts) de programmes

Exemples
/*
* Ce commentaire respecte nos normes de programmation. Les
étoiles
* à gauche sont alignées verticalement.
*/
 int age = 0; // l’âge du capitaine
double facture = 133.0; // la facture du capitaine
String leNom = "Haddock"; // le nom du capitaine

/*
* Ce test nous permet de savoir si la température mesurée
* dépasse le seuil permis par notre système de sécurité.
*/
if (temperature > 120.0)
{
System.out.println("Attention : température dangereuse");
}
else
{
System.out.println("Tout baigne");
}

Les constantes
Les constantes sont des variables spéciales dont on empêche le changement de
valeur durant l’exécution d’un programme. Leur valeur est donc en lecture
seulement.

final type_var NOM_VARIABLE = valeur;

▪ c’est exactement comme une déclaration et une initialisation, mais avec le

mot-clé final devant
▪ il faut initialiser la constante dès sa déclaration (on ne peut le faire plus
tard, car c’est justement une constante en lecture seule)
▪ on utilise une constante quand on a affaire à une valeur qu’on sait ne
changera jamais durant l’exécution du programme, par exemple
o Les constantes mathématiques ou physiques ( , température
d’ébullition de l’eau, etc.)
o Les constantes financières : taxes, montants fixes, etc.
o Plus généralement : les données d’un problème qui sont fixes :
maximums, minimums, etc. mentionnés explicitement dans
l’énoncé du problème

▪ Par convention, les déclarations de constantes sont les premières

instructions d’un programme
▪ Par convention, les identificateurs des constantes sont en majuscules, et
les mots qui les composent sont séparés par le caractère de soulignement
(_)

Exemples
final double PI = 3.1416;
final double TEMP_CONGELATION = 0.0;
final String VERSION_PROGRAMME = "1.0";
final double TAXE_PROVINCIALE = 1.07;
final char YES = 'Y';

Les opérateurs logiques

Les opérateurs logiques peuvent combiner ou inverser les conditions simples.
 !condition1 négation de la condition1

condition1 && condition2 condition1 ET condition2

condition1 || condition2 condition1 OU condition2

Exemples
if (!condition)
{
System.out.println("La condition est fausse");
}

if (dateCourante == dateAnniversaire && moisCourant ==

moisAnniversaire )
{
System.out.println("Bonne fête !");
}

if (age <= 0 || age >= 130)

{
System.out.println("Age impossible !");
}

Comme pour les opérateurs arithmétiques, il y a une priorité des opérateurs

logiques. Ils sont évalués dans cet ordre :

1. La négation : !
2. Le ET : &&
3. Le OU : ||

On peut forcer la priorité en utilisant les parenthèses, comme pour les

opérateurs arithmétiques.

Exemples
if (a == 3 || b > 3 && !(c < 4))
{
...
}

if ((a == 3 || b > 3) && !(c < 4))

{
...
}

Comparaison de chaînes de caractères

Les tests sur les Strings sont différents de ceux sur les entiers.
Pour tester l’égalité de deux Strings string1 et string2
string1.equals cette expression est vraie si string1
(string2) égale string2

Pour tester l’inégalité de deux strings string1 et string2, on fait alors

!(string1.equals cette expression est vraie si string1
(string2)) n’égale pas string2
▪ Cette comparaison est sensible à la casse, donc « Mul » n’est pas égal à
« mul »

Exemples
if (prenom.equals("Roger"))
{
System.out.println("Bonjour Roger");
}
else
{
System.out.println("Vous ne vous appelez pas Roger");
}

if (prenom.equals("Roger") && !nom.equals("Tremblay"))

{
System.out.println("Votre prénom est Roger");
System.out.println("Vous n’êtes pas un Tremblay");
}

Énoncé d’itération « while »

L’énoncé while permet de répéter

un bloc d’instructions tant qu’une
condition demeure vraie.
while (condition)
{
instructions;
}

▪ La condition (appelée aussi test) est entre parenthèses. Ce peut être une
condition simple ou composée.
▪ Il n’y a pas de point-virgule à la fin de la première ligne.
▪ La condition doit être vraie pour que le bloc d’instructions soit exécuté.
▪ Le bloc d’instructions sera exécuté aussi longtemps que la condition
demeure vraie. Attention : Vous assurer que la condition devient fausse
sinon vous aurez une boucle infinie.
▪ Si la condition est fausse dès le début, le bloc d’instruction ne sera pas
exécuté et le programme continuera à l’instruction qui suit l’accolade
fermante.
▪ Le bloc d’instructions est délimité par des accolades ({ }), situées une au-
dessus de l’autre
▪ Le bloc d’instructions entre accolades est en retrait (il y a du blanc avant)
par rapport à l’énoncé qui précède.

Exemples
 int i = 3;
while (i > 0)
{
i = i - 1;
System.out.println("i vaut " + i);
}

Opérateurs préfixés ++ et --
Il arrive fréquemment qu’on ait à incrémenter (ajouter 1) ou décrémenter
(soustraire 1) à une variable, comme on l’a vu à l’exemple précédent.

++variable addition de 1 à la valeur de variable

--variable soustraction de 1 à la valeur de variable

Exemple
On peut transformer ceci
int nbValeurs = 0;
nbValeurs = nbValeurs + 1;
nbValeurs = nbValeurs - 1;
en ceci
int nbValeurs = 0;
++nbValeurs;
--nbValeurs;

Affectation composée
Il existe un raccourci en Java pour combiner une affectation et la modification
d’une variable donnée.
Au lieu d’écrire… On peut écrire…
variable = variable + variable += expression;
expression;
variable = variable – variable -= expression;
expression;
variable = variable * variable *= expression;
expression;
variable = variable / variable /= expression;
expression;
variable = variable % variable %= expression;
expression;

Exemples
On peut transformer ceci
nombre = nombre * 2;
en ceci
nombre *= 2;

ou encore

On peut transformer ceci

nombre1 = nombre1 – nombre2;
en ceci
nombre1 -= nombre2;
 Recettes de programmation
Échange du contenu de deux variables
temp = variable1;
variable1 = variable2;
variable2 = temp;

Poser une question tant que l’utilisateur entre une valeur prédéfinie pour
arrêter
Exemple avec une valeur de 0 pour arrêter le programme
System.out.println("Entrez une valeur (0 pour arrêter)");
valeur = Integer.parseInt(r.readLine());

while (valeur != 0)
{
// faire quelque chose avec valeur
System.out.println("Entrez une valeur (0 pour
arrêter)");
valeur = Integer.parseInt(r.readLine());
}

Concaténation de Strings en Java avec l’opérateur +

Il est possible d’assembler des expressions pour former des Strings en
utilisant l’opérateur de concaténation + en Java.
Lorsqu’au moins une des opérandes du + est une expression de type String,
au lieu d’une addition, Java « colle ensemble » les expressions pour former
une String.
Exemples
Si monNom vaut "Alfred" et monAge vaut 17, alors l’expression
monNom + " a " + monAge + " ans"
vaut
"Alfred a 17 ans"

On pourrait écrire aussi

String message = monNom + " a " + monAge + " ans";
et la variable message contiendrait alors
"Alfred a 17 ans"

La variable message peut ensuite être modifiée en lui concaténant des

morceaux, comme par exemple :
message = message + " et demi";
message vaut maintenant
"Alfred a 17 ans et demi"

On peut même utiliser l’opérateur d’affectation composée (voir plus haut)

 message += " en octobre";
message vaut maintenant
"Alfred a 17 ans et demi en octobre"

Il est donc possible de construire de longues chaînes de caractères avec des

boucles
int i = 0;
String longueChaine = "";

while (i < 25)

{
longueChaine += "A";
++i;
}
et longueChaine contient alors 25 fois le caractère "A"
"AAAAAAAAAAAAAAAAAAAAAAAAA"

Énoncé d’itération do…while

L’énoncé do..while ressemble à la
boucle while, sauf que le test de
condition est fait après que les
instructions sont exécutées.
do
{
instructions;
}
while (condition);

▪ La condition est suivie d’un point-virgule, contrairement à la boucle

while
▪ On est certain que le corps de la boucle sera exécuté au moins une fois
Exemples
int i = 3;
do
{
--i;
System.out.println("i vaut " + i);
}
while (i > -1);

do
{
System.out.println("Entrez un nombre plus grand que 0");
i = Integer.parseInt(r.readLine());
}
while (i <= 0);

Instruction switch
L’instruction switch permet de choisir un cas particulier selon la valeur d’une
expression de type entier.
switch (expression) ▪ L’expression doit être de type
{ entier.
case valeur1:
instructions; ▪ Lorsqu’un cas (case) égal à
break; expression est trouvé, il entraîne
case valeur2: l’exécution du bloc d’instructions
instructions; du case, jusqu’au break
break;
// autres valeurs
▪ Le cas par défaut « default » est
default: exécuté si aucun cas ne correspond
instructions; à la valeur de expression.
break;
}

Exemple
int noJour = 2;
String nomJour = "";

switch (noJour)
{
case 1:
nomJour = "lundi";
break;
case 2:
nomJour = "mardi";
break;
case 3:
nomJour = "mercredi";
break;
case 4:
nomJour = "jeudi";
break;
case 5:
nomJour = "vendredi";
break;
case 6:
nomJour = "samedi";
break;
case 7:
nomJour = "dimanche";
break;
default:
nomJour = "inconnu";
break;
}

System.out.println("Le nom correspondant au jour " + noJour + " est " +

nomJour);

Variables booléennes
Le type de variable boolean permet de stocker une valeur « vrai » (true) ou
« faux » (false) dans une variable.
// déclaration et initialisation de la variable maVariable à false
boolean maVariable = false;
Exemple
boolean estFumeur = false;
boolean estMajeur = false;
int age = 19;

estFumeur = true;
estMajeur = (age >= 18);

if (estMajeur) // on ne fait jamais if (estMajeur == true)

{
System.out.print("Vous êtes majeur.");
 if (!estFumeur)
{
System.out.print("Vous ne fumez pas - bravo.");
}
}
else
{
System.out.println("Vous êtes un mineur.");
}

Énoncé for
L’énoncé for fournit une façon
claire et compacte de balayer un
intervalle de valeurs.
On peut faire encore plus avec cette
instruction, mais elle est
habituellement utilisée pour le
balayage d’un intervalle.
Elle s’exécute un nombre déterminé
de fois, que l’on peut facilement
trouver en regardant la première
ligne la boucle for.

for (initialisation;
condition; changement)
{
instructions;
}

▪ Les points virgules doivent toujours apparaître entre initialisation,

condition et changement
▪ Dans l’initialisation, on met habituellement une déclaration de variable
compteur qui balayera l’intervalle de valeurs. Cette variable n’existe qu’à
l’intérieur du for. À l’extérieur des accolades du for, c’est comme si elle
n’avait jamais été déclarée.

Exemples
// afficher les nombres de 0 à 99
for (int i = 0; i < 100; ++i)
{
System.out.println(i);
}

// faire la somme des entiers pairs entre 0 et 100

int somme = 0;
for (int i = 0; i <= 100; i += 2) // par bonds de 2
{
somme += i;
}

// la variable i n’existe plus ici, à l’extérieur du for

 Tableaux (« arrays »)
Un tableau est un ensemble de données du même type, accessibles à partir
d’un seul nom de variable.
Déclaration avec initialisation On déclare un tableau en spécifiant le type des
données qu’il contiendra, son nom, et sa taille (un entier qui donne le nombre
d’éléments que le tableau contient).
type[] varTableau = new type[taille]; déclaration du tableau
Ceci crée un ensemble de valeurs en mémoire.
Exemple
int[] tabAges = new int déclaration d’un tableau contenant 10
[10]; âges
Ceci crée un tableau tabAges de 10 entiers en mémoire.
Déclaration sans initialisation Pour déclarer un tableau sans l’initialiser, on
écrit :
type[] varTableau = null; déclaration du tableau sans initialisation
Le tableau ne contient alors rien (null), et on ne peut le manipuler avant de
l’avoir initialisé.
Exemple
int[] tabAges = null; déclaration d’un tableau sans initialisation
// autres traitements...
tabAges = new int[32]; initialisation du tableau
Initialisation En Java, les éléments du tableau sont initialisés à 0 (entiers) et à
false (booléens) automatiquement lors de la déclaration du tableau.

Pour les tableaux de Strings, les éléments du tableau contiennent une valeur
spéciale appelée null, qu’il vaut mieux ne pas manipuler. Il faut alors
initialiser « à la mitaine » tous les éléments du tableau de Strings.
On peut également déclarer et initialiser un tableau avec une liste d’éléments
séparés par des virgules.
Exemple
double[] tabSalaires = { 76.12, 34.3, tableau à 4
31.3, 88.3 }; éléments
Accès aux éléments du tableau Pour accéder au contenu du tableau, on utilise
le nom de la variable du tableau et un indice pour spécifier l’élément auquel
on veut accéder.
varTableau accès à un élément du tableau, dont l’indice est
[indice] indice

Le premier élément d’un tableau a l’indice 0.

Exemples
 tabAges[0] = 18; // affectation de 18 au 1er élément du tableau
(indice 0)
tabAges[1] = 19; // affectation de 19 au 2e élément du
tableau
// ... on continue l’initialisation

if (tabAges[8] > 20) // accès à la valeur du 9e élément

{
System.out.println("Le 9e élément plus grand que 20");
}

Taille du tableau En tout temps, il est possible de récupérer le nombre

d’éléments dans un tableau. Le nombre d’éléments s’appelle taille du tableau
ou encore longueur du tableau. On récupère cette information en faisant
nomTableau.length.

Exemple
boolean[] tabBooleens = new boolean[23];
// Ceci devrait afficher une taille de 23...
System.out.println("Taille de mon tableau = " +
tabBooleens.length);

Boucle for et tableaux La boucle for se prête bien à l’exploration d’un

tableau, dans bien des tâches. Un compteur (p.ex. i) prend alors toutes les
valeurs d’indice possibles.
Exemple : somme des éléments d’un tableau
double[] tabSalaires = { 0.12, 34.3, 31.3, tableau à 4
88.3 }; éléments
double somme = 0.0;
int i = 0; // compteur

for (i = 0; i < tabSalaires.length; ++i)

somme += tabSalaires[i];

System.out.println("somme : " + somme);

Normes de programmation
Il n’y a pas d’espace autour des crochets des tableaux (p.ex. : tabSalaires
[i]).

La taille d’un tableau est souvent une constante, lorsqu’on connaît d’avance la
longueur du tableau.
Exemple : décompte de chaque type de voyelles dans un mot
final int NB_VOYELLES = 6;
final int INDICE_A = 0;
final int INDICE_E = 1;
final int INDICE_I = 2;
final int INDICE_O = 3;
final int INDICE_U = 4;
final int INDICE_Y = 5;

int[] compteurVoyelles = new int[NB_VOYELLES];

// ...

System.out.println("nb de a : " + compteurVoyelles

[INDICE_A]);
// ...
 Caractères : type char
Le type char représente un caractère. Ce sont notamment ceux que vous voyez
dans ce document, que vous écrivez ou lisez dans un fichier, et qui constituent
les chaînes de caractères.
char monCaractere; déclaration d’un caractère
Les valeurs littérales (constantes) des char sont toujours entre simples
apostrophes (').
char monCaractere = 'a'; déclaration d’un caractère et initialisation
On peut faire les opérations habituelles sur les char.
Exemples
if (monCaractere == 'a')
{
System.out.println("Le car. est : " + monCaractere);
}

char[] tableauCars = new char[32]; // un tableau

Classes On distingue plusieurs classes de caractères, et ce, pas seulement en

Java
▪ lettres ('a', 'B', 'Ω', '‫)'ۺ‬
▪ chiffres ('0')
▪ signes de ponctuation (';')
▪ caractères spéciaux ('^', '&', '#')
▪ caractères de contrôle : retour chariot, marque de tabulation, etc.
Séquences d’échappement Certains caractères ne peuvent être saisis par le
programmeur que précédés par le caractère d’échappement \.
Séquence d’échappement Signification
'\t' tabulation
'\n' saut de ligne (newline)
'\"' guillemets
'\'' apostrophe simple
'\\' barre oblique inverse
(backslash)
Jeu de caractères Le jeu de caractères est l’ensemble des caractères reconnus.
Pour Java, ce jeu de caractères est Unicode
(http://jrgraphix.net/research/unicode_blocks.php), qui permet de représenter
presque toutes les lettres connues. Un autre jeu de caractères (plus vieux et
restreint) est ASCII, représenté par la table (http://fr.wikipedia.org/wiki/Ascii).
Unicode est plus complet, et inclut notamment tous les codes ASCII.
Les char et les int sont donc proches parents : lorsque l’on utilise une
variable char comme si c’était un nombre, Java la convertit en entier en
utilisant son code dans la table.
Exemple
char var = 'y'; // var vaut maintenant 'y', 121 selon
Unicode et ASCII
int carEntier = var - 20; // carEntier vaut 101 (121 – 20)

À cause de ceci, il est même possible de faire un switch sur une variable de
type char.
Exemple
char maLettre = 'a'; Un switch est possible, puisque
switch (maLettre) celui-ci ne fonctionne que sur
{ les variables de type entier. Or,
case 'a': un char est un proche parent d’un
++nbVoyelles; entier, ce qui fait que ça
break; fonctionne !
case 'b':
...

Un peu plus sur les chaînes de caractères

Séquence d’échappement Pour inclure certains caractères dans une chaîne de
caractères, il suffit d’utiliser les séquences d’échappement vues pour les
caractères.
Exemples
Exemple de chaîne Sortie à l’écran si la chaîne est
affichée
"C'est \"Hung up\"." C'est "Hung up".
"Prénom:\tEric" Prénom: Eric
"Nom:\tTremblay" Nom: Tremblay
"A\nL\nL\nO" A
L
L
O
"C:\\temp\\a.txt" C:\temp\a.txt

Conversions String int

String s = "9000";
int i = Integer.parseInt(s); // i vaut 9000

Conversions int String

int i = 9000;
String s = Integer.toString(i); // s vaut "9000"

Opérations sur les chaînes de caractères

Les variables de type String permettent certaines opérations utiles.
La notation générale pour l’utilisation de ces opérations est toujours la
suivante :
resultat = nomVariableString.NomOperation
En Java, nous appellerons l’opération une méthode.
Longueur d’une chaîne : méthode length() compte le nombre de
caractères
Exemples
String chaine = "Cobalt 60";
int longueur = chaine.length(); // longueur vaut 9

Mise en majuscules ou en minuscules : méthodes toUpperCase() et

toLowerCase()

Exemples
String chaine = "Cobalt 60";
 String minuscule = chaine.toLowerCase(); // cobalt 60
String majuscule = chaine.toUpperCase(); // COBALT 60

String chaine2 = "Carbone 14";

System.out.println(chaine2.toUpperCase()); // affiche
CARBONE 14

/*
* notez que chaine et chaine2 n'ont pas changé de valeur
* elles valent toujours "Cobalt 60" et "Carbone 14"
respectivement
*/

Rognage des espaces : méthode trim()

Le rognage des espaces consiste à enlever les blancs de part et d’autre d’une
chaîne de caractères. Cette méthode est essentielle par exemple pour
« nettoyer » les entrées faites par un utilisateur, qui se soucie peu des espaces
qu’il entre avant et après ses entrées.
Exemple
String chaine = " ¡Hola! ";

// la ligne suivante affiche une longueur de 15

caractères,
System.out.println("Le mot a une longueur de " +
chaine.length());

chaine = chaine.trim(); // chaine vaut maintenant "¡Hola!"

// la ligne suivante affiche une longueur de 6 caractères

System.out.println("Le mot a maintenant une longueur de "
+
chaine.length());

Test d’égalité : méthode equals

Cette méthode que nous connaissons permet la comparaison entre deux
variables de type String. Elle retourne un booléen : true si les chaînes sont
identiques, false autrement.
Exemple
String chaine1 = "hello";
String chaine2 = "bonjour";

boolean sontEgales = chaine1.equals(chaine2);

if (sontEgales)
{
System.out.println("Les deux chaînes sont identiques
!");
}

// ou, plus simplement, comme nous faisons depuis le début

if (chaine1.equals(chaine2))
{
System.out.println("Les deux chaînes sont identiques
!");
}

Conversion en tableau de caractères : méthode toCharArray()

Cette méthode permet de retourner un tableau de caractères contenant, dans
l’ordre, tous les caractères qui constituent la chaîne de caractères.
Exemple
String chaine = "Cobalt 60";
char[] carsDansChaine = chaine.toCharArray();

System.out.println("Le 1er caractère est " +

carsDansChaine[0]);

Extraction d’une sous-chaîne : méthode substring

▪ Extrait un fragment (sous-chaîne) commençant à une position donnée de
la chaîne originale
▪ La méthode substring attend 2 paramètres pour préciser la sous-chaîne à
extraire :
o La position de départ où commencer à extraire
o La position de fin où arrêter l’extraction (cette position est exclue)
▪ L’index du premier caractère d’une chaîne est toujours 0.
Exemples
String chaine = "Cobalt 60";
String premierMot = chaine.substring(0,6); // extraction
de [0,6[
// premierMot vaut maintenant 'Cobalt'

Recherche d’une sous-chaîne : méthode indexOf

▪ Recherche un passage dans une chaîne
▪ Retourne l’index (position) du passage dans la chaîne
▪ L’index du premier caractère d’une chaîne est toujours 0
▪ Si le passage n’est pas trouvé, la fonction retourne -1

Exemples
String w = "Hal 9000";
int positionDuAl = w.indexOf("al"); // retourne 1

if (w.indexOf("rouge") == -1)
System.out.println("Pas de rouge dans cette chaîne");

Note : Il existe quantité d’opérations qui peuvent être effectuées sur une
variable de type String. Vous pouvez les consulter sur le site de Sun
expliquant tout le langage Java, à l’URL
http://java.sun.com/javase/6/docs/api/java/lang/String.html
De plus, vous avez
constaté que NetBeans
vous offre des
suggestions
documentées lorsque
vous tapez le point à la
suite d’une variable de
type chaîne. Explorez !
 Lecture et écriture des fichiers
Les fichiers
Les fichiers permettent d’enregistrer l’information de façon persistante (c’est-
à-dire qu’ils conservent l’information même après que le programme s’est
terminé).
▪ Il y a deux types de fichiers
o les fichiers texte (comme ceux du Bloc-notes de Windows)
o les fichiers binaires (les images bitmap, les fichiers Word, etc. qui
ne contiennent pas seulement du texte)
▪ Dans notre cours, nous voyons l’accès séquentiel (« sequential access »)
sur des fichiers texte.
o on lit le fichier ligne par ligne, du début à la fin
o on écrit dans le fichier ligne par ligne
Instructions de lecture
package nomdupackage;

import java.io.*;

/**
* @author LeProf
*/
public class NomClasse
{

public static void main(String[] args) throws IOException

{
String nomFichier = "c:\\temp\\lenomdufichier.txt";
String ligne = "";
BufferedReader lecteurFichier = null; // initialisation à “rien”

lecteurFichier = new BufferedReader(new FileReader(nomFichier));

while ((ligne = lecteurFichier.readLine()) != null)

{
// faire qqchose avec la ligne lue

lecteurFichier.close(); // toujours fermer le fichier

}

}
Note : lorsque le nom du fichier ne contient pas le nom du répertoire, p.ex.
String nomFichier = "lenomdufichier.txt";
alors, le fichier est trouvé dans le répertoire du projet NetBeans.
Instructions d’écriture
 package nomdupackage;

import java.io.*;

/**
* @author LeProf
*/
public class NomClasse
{

public static void main(String[] args) throws IOException

{
String nomFichier = "c:\\temp\\lenomdufichier.txt";
String ligne = "bonjour";
PrintWriter createurFichier = null; // initialisation à "rien"

createurFichier = new PrintWriter(

new BufferedOutputStream(new FileOutputStream(nomFichier)));

createurFichier.println("allô !");
createurFichier.println("comment allez" + "-vous ?");
createurFichier.println(ligne);

createurFichier.close();
}

Nombres aléatoires
Les nombres aléatoires sont des nombres « tirés au hasard ».
Ils sont très utiles dans les jeux. Par exemple, dans le jeu de cartes Solitaire, ce
sont des nombres aléatoires qui déterminent l’ordre des cartes qui vont être
jouées. Java peut générer des nombres aléatoires.
package nomdupackage;

import java.util.Random;

public class NomClasse

{

public static void main(String[] args)

{
Random generateur = new Random();

/*
* La ligne suivante tire au hasard un nombre entier entre 0
(inclus)
* et 32 (exclu). 32 pourrait être une constante, dans vos
programmes.
*/
int nbAleatoire = generateur.nextInt(32);

System.out.println("Un nombre au hasard entre 0 et 32 : " +

nbAleatoire);
}