Les chaines de caractères

Java dispose d’une classe nommée String, permettant de manipuler des chaines de caractère, c’est-à-dire
des suites de caractères. Les constantes chaines telles que “ bonjour “ ne sont en fait que des objets de
type String construits automatiquement par le compilateur.

Nous verrons que Java fait preuve d’une certaine originalité en prévoyant que les objets de type String ne
soient modifiables.

Lorsque le programmeur aura besoin de manipuler intensivement des chaines , il pourra , s’il souhaite
privilégier l’efficacité de son programme , recourir à une autre classe StringBuffer.

Contrairement à String, celle-ci autorise la modification directe de son contenu. En revanche, les
méthodes utilisées sont différentes de celles de la classe String.

1. Fonctionnalités de base de la classe String

1.1 Comme toute déclaration d’une variable objet, l’instruction:

String ch ;

déclare que ch est destinée à contenir une référence à un objet de type String.

Par ailleurs , la notation : “ bonjour “ désigne en fait un objet de type String ( ou plus précisément sa
référence) , créé automatiquement par le compilateur. Ainsi , avec :

Ch = “ bonjour “ ;

On aboutit à la situation suivante :

bonjour

ch

La classe String dispose de deux constructeurs , l’un sans argument créant une chaine vide , l’autre avec
un argument de type String qui en crée une copie :

String ch1 = new String () ; // ch1 contient la référence à une chaine vide

String ch2 = new String (“hello”) ; // ch2 contient la référence à une chaine contenant la suite “ hello”

String ch3 = new String (ch2) ; // ch3 contient la référence à une chaine , copie de cha2 , donc contenant
“hello”.

1
1.2 Un objet de type String n’est pas modifiable

Un objet de type String n’est pas modifiable. IL n’existera donc aucune méthode permettant d’en
modifier la valeur. Mais il ne faut pas perdre de vue qu’on manipule en fait des références à des objets
et que celles-ci peuvent voir leur valeur évoluer au fil du programme.

Considérons ces instructions :

String ch1 , ch2 , ch3 ;

ch1 = “ bonjour “ ; ch2 = “ bonsoir ‘ ;

après leur exécution , la situation est la suivante :

ch1 bonjour

bonsoir
ch2

Exécutons maintenant ces instructions :

ch = ch1 ;

ch1 = ch2 ;

ch2 = ch ;

Les deux objets de type chaine n’ont pas été modifiés , mais les références ch1 et ch2 l’ont été.

1.3 Lecture d’une chaine de caractère fournie au clavier

String ch = ;

…..

ch = Clavier.lireString () ; // crée un objet de type String contenant la référence à une chaine lue au clavier.

lireString () est une méthode statique de la classe utilitaires Clavier.

1.4 Longueur d’une chaine

La méthode length permet d’obtenir la longueur d’une chaine , c’est-à-dire le nombre de caractères
qu’elle contient.

String ch = “ bonjour “ ;

int n = ch.length() ; // n contient 7 caractères

2
ch = “ “ ; n = ch.length () ; // n contient 0

1.5 Accès aux caractères d’une chaine

La méthode charAt de la classe String permet d’accéder à un caractère de rang donné d’une chaine ( le
premier caractère porte le rang 0). Ainsi , avec :

String ch = “bonjour” ;

ch.charAt(0) correspond au caractère b.

ch.charAt(2) correspond au caractère n.

Voici un exemple d’un programme qui lit une chaine au clavier et l’affiche verticalement, c’est-à-dire à
raison d’un caractère par ligne :

public classMotCol

public static void main (String args [] )

String mot ;

System.out.print ( “ donnez un mot : “ ) ;

mot = Clavier.lireString () ;

System.out.println ( “voici votre mot en colonne : “ ) ;

for ( int i = 0 ; i < mot.length() ; i ++ )

System.out.println (mot.charAt(i) ) ;

Donnez un mot : Langage

3
1.6 Concaténation de chaines

L’opérateur + est défini lorsque ses deux opérandes sont des chaines. Il fournit en résultat une nouvelle
chaine formée de la concaténation des deux autres , c’est-à-dire contenant successivement les caractères
de son premier opérande , suivis de ceux de son second.

Considérons ces instructions :

String ch1 = “ Le langage “ ;

String ch2 = “ Java” ;

String ch = ch1 + ch2 ;

1.7 L’opérateur +=

String ch = “ bonjour” ;

ch += “ monsieur “ ; // ch désigne la chaine “ bonjour monsieur”

Exemple

String ch = “ chiffres = “ ;

for (int i = 0 ; i <= 9 ; i ++ )

ch += i ;

System.out.println ( ch ) ; // affiche : chiffres = 0123456789

2. Recherche dans une chaine

La méthode indexOf surdéfinie dans la classe String permet de rechercher , à partir du début d’une chaine
ou d’une position donnée :

• La première occurrence d’un caractère donné ,

• La première occurrence d’une autre chaine.

Dans tous les cas , elle fournit :

• La position du caractère ( ou du début de la chaine recherchée) si une correspondance a effectivement

été trouvée.
• La valeur -1 sinon.

Il existe également une méthode lastIndexOf , surdéfinie pour effectuer les mêmes recherches que
indexOf , mais en examinant la chaine depuis sa fin.

String mot = “ anticonstitutionnellement” ;

int n ; n = mot.indexOf ( ‘ t ‘) ; // n vaut 2

4
n = mot.lastIndexOf ( ‘ t ‘ ) ; // n vaut 24

3. Comparaison de chaines

3.1 La méthode equals

La méthode equals compare le contenu de deux chaines :

String ch1 = “ hello “ ;

String ch2 = “ bonjour“ ;

…….

ch1.equals ( ch2) // cette expression est fausse

ch1.equals (“hello”) // cette expression est vraie

La méthode equalsIgnoreCase effectue la même comparaison , mais sans distinguer les majuscules des
minuscules :

String ch1 = “ Hello “ ;

String ch2 = “ hello “ ;

…….

ch1.equalsIgnoreCase (ch2) // cette expression est vraie

ch1.equalsIgnoreCase (“hello” ) // cette expression est vraie

Mais :

Object o1 , o2 ;

String ch1 = “….” , ch2 = “…” ;

o1 = ch1 ; o2 = ch2 ;

o1.equals (o2) // utilise equals de Object → comparaison de références

o1.equals (ch2) // utilise equals de Object → comparaison de références

ch1.equals (o2) // utilise equals de String → comparaison de valeurs

ch1.equals (ch2) // utilise equals de String → comparaison de valeurs

Cependant , dans les implémentations qui fusionnent les chaines identiques , ces quatre expressions
auront toujours la même valeur.

3.2 La méthode compareTo

La méthode compareTo s’utilise ainsi :

chaine1.compareTo (chaine2 )

5
Elle fournit :

• un entier négatif si chaine1 arrive avant chaine2,

• un entier nul si chaine1 et chaine2 sont égales ( on a alors chaine == chaine2) ,
• un entier positif si chaine1 arrive après chaine2.

4. Modification de chaines

Les objets de type String ne sont pas modifiables.

Remplacement de caractères

La méthode replace crée une chaine en remplaçant toutes les occurences d’un caractère donné par un
autre. Par exemple :

String ch = “bonjour” ;

String ch1 = ch.replace (‘o’ , ‘a’) ; // ch n’est pas modifiée , ch1 contient “banjaur”

Extraction de sous-chaine

La méthode substring permet de créer une nouvelle chaine en extrayant de la chaine courante :

• Soit tous les caractères depuis une position donnée ,

String ch = “anticonstitutionnellement” ;

String ch1 = ch.substring (5) ; // ch n’est pas modifiée , ch1 contient “constitutionnellement”

• Soit tous les caractères compris entre deux positions données ( la première incluse , la secode exclue ) :

String ch = “anticonstitutionnellement” ;

String ch1 = ch.substring (4 , 16) ; // ch n’est pas modifiée , ch1 contient “ constitution”

5. Conversion d’un type primitif en une chaine

Dans la classe String , la méthode statique valueOf est surdéfinie avec un argument des différents types
primitif. Par exemple , pour le type int :

int n = 427 ;

String ch = String.valueOf (n) ; // fournit une chaine obtenue par formattage de la valeur contenue dans
n , soit ici “427”

En fait , l’affectation ch = String.valueOf (n) produit le même résultat que l’affectation :

ch = “ “ + n ; // utilisation artificielle d’une chaine vide pour pouvoir recourir à l’opérateur +

6
Voici un programme qui lit des entiers au clavier et les convertir en chaine ( On s’interrompt lorsque
l’utilisateur fournit un entier nul ) :

public class ConvICh

public static void main ( String args [ ] )

int n ;

while ( true ) // on s’arrêtera quand n == 0

System.out.print ( “ donnez un entier (0 pour finir ) : “ ) ;

n = Clavier.lireInt () ;

if ( n == ) break ;

String ch = String.valueOf ( n ) ;

System.out.println ( “ chaine correspondante , de longueur “ + ch.length () + “ : “ + ch ) ;

Donnez un entier ( 0 pour finir ) : 427

Chaine correspondante , de longueur 3 : 427

Donnez un entier ( 0 pour finir ) : -4351

Chaine correspondante , de longueur 5 : -4351

Donnez un entier (0 pour finir) : 0

6. Conversion d’une chaine en un type primitif

String ch = “3587” ;

int n = Integer.parseInt (ch) ;

D’une manière générale , on dispose des méthodes suivantes :

• Byte.parseByte ,
• Short.parseShort,
• Intege.rparseInt,

7
• Long.parseLong,
• Float.parseFloat,
• Double.parseDouble.

public class ConvChI

public static void main ( String args [ ] )

String ch ;

while ( true ) // on s’arrêtera quand chaine est vide

System.out.print ( “ donnez une chaine (vide pour finir ) : “ ) ;

ch = Clavier.lireString () ;

if ( ch.length () ==0 ) break ;

int n = Integer.parseInt ( n ) ;

System.out.println ( “ entier correspondant , de longueur “ + n ) ;

La classe StringBuffer

Java dispose d’une classe StringBuffer destinée à manipuler les chaines , mais dans laquelle les objets sont
modifiables.

La classe Stringbuffer dispose de fonctionnalités classiques mais elle n’a aucun lien d’héritage avec String
et ses méthodes ne portent pas toujours le même nom. On peut créer un objet de type StringBuffer à
partir d’un objet de type String. Il existe des méthodes :

• de modification d’un caractère de rang donné : setCharAt ,

• d’accès à un caractère de ran donné : charAt ,
• d’ajout d’une chaine en fin : la méthode append accepte des arguments de tout type primitif et de type
String ,
• d’insertion d’une chaine en un emplacement donné : insert ,
• de remplacement d’une partie par une chaine donnée : replace ,
• de conversion de Stringbuffer en String :toString

8
class TestStB

public static void main ( String args [ ] )

String ch = “ la java “ ;

StringBuffer chBuf = new StringBuffer (ch) ;

System.out.println (chBuf) ;

chBuf.setChartAt ( 3 , ‘J’) ; System.out.println (chBuf) ;

chBuf.setChartAt ( 1 , ‘e’) ; System.out.println (chBuf) ;

chBuf.append ( “2”) ; System.out.println (chBuf) ;

chBuf.insert( 3 , “langage”) ; System.out.println (chBuf) ;

la java

la java

le java

le Java 2

le langage Java 2

9
Classe Date
import java.util.Date;

public class Test {

public static void main (String [] args)

Date d;

int a, m, j;

System.out.print (“saisir l’année “);

a = Clavier.lireInt ();

System.out.print (“saisir le mois“);

m = Clavier.lireInt ();

System.out.print (“saisir le jour“);

j = Clavier.lireInt ();

d = new Date (a-1900, m-1,j );

Comparer deux dates

if (d.compareTo(new Date())<0) :

•> 0 si d est supérieure à la date du jour

•< 0 si d est inférieure à la date du jour

•== 0 si d est égale à la date du jour

•Date datedujour=newDate ();

10
La gestion des exceptions
Même lorsqu’un programme est au point , certaines circonstances exceptionnelles peuvent
compromettre la poursuite de son exécution ; il peut s’agir par exemple de données incorrectes ou de la
rencontre d’une fin de fichier prématurée.

Par ailleurs , dans des programmes relativement importants , il est fréquent que le traitement d’une
anomalie ne puisse pas être fait par la méthode l’ayant détectée, mais seulement par une méthode ayant
provoqué son appel.

Java dispose d’un mécanisme nommé gestion d’exception , qui permet à la fois :

• de dissocier la détection d’une anomalie de son traitement ,

• `de séparer la gestion des anomalies du reste du code, donc de contribuer à la lisibilité des
programmes.

D’une manière générale , une exception est une rupture de séquence déclenche par une instruction throw
comportant une expression de type classe.

Considérons une classe Point , au sein du constructeur , nous vérifions la validité des paramètres fournis.
Lorsque l’un d’entre eux est incorrect , nous déclenchons une exception à l’aide de l’instruction throw.

Nous créons une classe dérivant de la classe standard Exception.

class ErrConst extends Exception

class Point

public Point (int x , int y ) throws ErrConst

if ( ( x < 0 ) ( y < 0) ) throw new ErrConst () ;

this.x = x ; this.y = y ;

public void affiche ()

System.out.println ( “coordonnées : “ +x + “ “ + y ) ;

private int x , y ; }

11
Utilisation d’un gestionnaire d’exception

Voyons comment procéder pour gérer convenablement les éventuelles exceptions de type ErrConst que
son emploi peut déclencher. Pour ce faire , il faut :

• inclure dans un bloc particulier dit “ bloc try “ les instructions dans lesquelles on risque de voir
déclenche une telle exception ; un tel bloc se présente ainsi :

try

// instructions

• faire suivre ce bloc de la définition des différents gestionnaires d’exception. Chaque définition de
gestionnaire est précédée d’un en-tête introduit par le mot clé catch

catch ( ErrConst e )

System.out.println ( “ Erreur construction “ ) ;

System.exit ( -1) ;

Le programme complet

class Point

public Point (int x , int y ) throws ErrConst

if ( ( x < 0 ) ( y < 0) ) throw new ErrConst () ;

this.x = x ; this.y = y ;

public void affiche ()

System.out.println ( “coordonnées : “ +x + “ “ + y ) ;

private int x , y ;

12
class ErrConst extends Exception

public class Except1

public static void main ( String args [ ] )

try

Point a = new point ( 1, 4) ;

a.affiche () ;

a = new Point (-3 , 5 ) ;

a.affiche () ;

catch (ErrConst e )

System.out.println ( “ Erreur construction “ ) ;

System.exit (-1) ;

Coordonnees : 1 4

Erreur construction

La construction suivante serait rejetée par le compilateur :

Public void static main (…)

try { Point a = new Point (2 , 5) ; a.deplace ( 2, 5 ) ;

catch (Errconst) { … } }

13
En effet , dès qu’une méthode est susceptible de déclencher une exception , celle-ci doit obligatoirement
être traitée dans la méthode ou déclarée dans son en-tête ( clause throws . Ainsi , même si l’appel de
deplace ne pose pas de problème ici , nous devons soit prévoir un gestionnaire pour ErrDepl , soit indiquer
throws ErrDepl dans l’en-tête de la méthode main.

Toute méthode susceptible de déclencher une exception qu’elle ne traite pas localement doit mentionner
son type dans une clause throws figurant dans son en-tête.

class Point

public Point (int x , int y ) throws ErrConst

if ( ( x < 0 ) ( y < 0) ) throw new ErrConst () ;

this.x = x ; this.y = y ;

public void f () throws ErrConst

try

{ Point p = new Point (-3 , 2 ) ;

catch ( ErrConst e )

{ System.out.println (“ dans catch (ErrConst) de f “) ;

throw e ; // on repasse l’exception à un niveau supérieur

private int x , y ;

class ErrConst extends Exception

public class Redecl

14
public static void main ( String args [ ] )

try

Point a = new point ( 1, 4) ;

a.f () ;

catch (ErrConst e )

System.out.println ( “ dans catch ( ErrConst ) de main “ ) ;

System.out.println ( “ après bloc try main “) ;

Cette possibilitéde redéclenchement d’une exception s’avère très précieuse lorsque l’on ne peut pas
résoudre localement qu’une partie du problème posé.

Le bloc finally

Java permet d’introduire , à la suite d’un bloc try , un bloc particulier d’instructions qui seront toujours
exécutées :

• soit après la fin “ naturelle” du bloc try , si aucune exception n’a été déclenche ,
• soit après le gestionnaire d’exception ( à condition que ce dernier n’ait pas provoqué d’arrêt de
l’exécution ).

Ce bloc est introduit par le mot clé finally et doit obligatoirement être placé après le dernier gestionnaire.

N.B.- Cette possibilité n’a aucun intérêt lorsque les exceptions sont traitées localement.

try {……}

catch ( Ex e ) {…….}

finally { //instructions A

15
public class Erreur extends Exception

public class Compte

{ private float montant;

public Compte (float n) throws Erreur

if (n<100) throw new Erreur();

montant = n;

...

“throws Erreur” spécifie que la méthode est susceptible de déclencher une exception de type Erreur.

Pour gérer convenablement les éventuelles exceptions de type Erreur, il faut :

•Inclure dans un bloc dit “bloc try” les instructions dans lesquelles on risque de voir déclencher une telle
exception.

•Faire suivre ce bloc de la définition des différents gestionnaires d’exception. Chaque définition de
gestionnaire est précédée d’un entête introduit par le mot catch.

public class Test {

public static void main (String args [])

try

Compte c = new Compte (1500);

System.out.println(c.getMontant());

c = new Compte (50);

System.out.println(c.getMontant());

16
catch (Erreur e)

System.out.println("Erreur de construction");

System.exit (-1); //interrompt le programme

Plusieurs exceptions
Transmettre un message au gestionnaire sous forme d’une chaîne

La classe Exception dispose d’un constructeur avec un argument de type String, dont on peut récupérer
la valeur à l’aide de la méthode getMessage().

public class Erreur extends Exception

public Erreur (String m)

super(m);

public class Compte

private float montant;

public Compte (float n) throws Erreur

if (n<100) throw new Erreur("Erreur de construction, valeur: " + n);

montant = n;

public void retrait (float r) throws Erreur

if ((montant -r) < 0) throw new Erreur (“Erreur de retrait, de valeur : ” + r);

17
montant = montant -r;

...

public class Test

public static void main (String args [])

{ try

Compte c = new Compte (1500);

System.out.println(c.getMontant());

c.retrait (1600);

c = new Compte (50);

System.out.println(c.getMontant());

catch (Erreur e) { System.out.println(e.getMessage());

System.exit (-1);// ou return;

Finally

{ // fermer la base de données ou le fichier }

Ce n’est pas une obligation de mettre fin à l’exécution du programme.

L’instruction return provoque la sortie de la méthode concernée.

Java permet d’introduire, à la suite du bloc try, un bloc qui sera toujours exécuté. Ce bloc est introduit par
le mot clé finally et doit obligatoirement être placé après le dernier gestionnaire.

18