| précédent | sommaire | accueil | suivant |
Ces classes permettent de manipuler des caractères et des chaines de caractères.
Cette classe possède un seul champ. Il est static et c' est un objet de type Comparator. La classe Comparator est ce qu' on appelle en Java :
une interface. Nous verrons les interfaces plus tard. Ce champ est déclaré :
public static final Comparator CASE_INSENSITIVE_ORDER
Ce champ représente un comparateur qui ordonne les objets String par ordre alphabétique sans tenir compte des majuscules. Un exemple ?...
plus tard.
La classe String possède 11 constructeurs. Nous ne les étudierons pas tous. Quelques exemples.
Exemple 1 :
1. public class ConstructeursString
2. {
3. public static void main (String [] args )
4. {
5. String chaine; chaine = new String();
6. System.out.println("chaine = " + chaine);
7. System.out.println();
8. char [] lettres = new char[3];
9. lettres[0] = 'm'; lettres[1] = 'e'; lettres[2] = 's'; lettres[3] = 's'; lettres[4] = 'e';
10. chaine = new String(lettres);
11. System.out.println("chaine = " + chaine);
12. System.out.println();
13. chaine = new String(lettres, 0, 3);
14. System.out.println("chaine = " + chaine);
15. System.out.println();
16. chaine = new String("magic");
17. System.out.println("chaine = " + chaine);
18. System.out.println();
19. }
20. }
compilez puis exécutez. Il sera affiché :
chaine =
chaine = messe
chaine = mes
chaine = magic
Ligne 5 : String chaine; permet de réserver un emplacement mémoire pour un objet de type String. Puis on crée un nouvel objet String avec new
String(). Puis on place sa référence dans la variable chaine. On utilise ainsi un constructeur sans arguments. Ce constructeur permet de créer
une chaine vide. C' est pourquoi, à l' affichage, on a seulement chaine =
ligne 10 : on crée un nouvel objet new String(lettres) en utilisant un constructeur qui requiert un argument tableau de char. lettres est en
effet une référence à un objet de type tableau de char. Ce constructeur permet de créer une chaine dont chaque caractère est celui du tableau de
caractères. Les caractères du tableau lettres sont respectivement : m, e, s, s et e. C' est pourquoi, à l' affichage, on chaine = messe.
ligne 13 : on crée un objet new String(lettres, 0, 3) et on place sa reférence dans chaine. On utilise ainsi un constructeur qui requiert 3
arguments : le premier étant un objet tableau de char, le deuxième étant l' indice d' un élément du tableau de char et le dernier étant la
longueur de la chaine. Ce constructeur permet de créer un objet chaine ayant les caractéristiques suivantes : le premier caractère de la
chaine est celui de l' indice d' un élément du tableau de char. Ici, c' est 0. Donc le premier caractère de la chaine est le caractère du
tableau de char qui se troouve à l' indice 0. C' est m. Puis la ongueur de la chaine étant 3, on ajoute encore 2 caractères du tableau. e et s.
On a donc à l' affichage : chaine = mes.
Autre exemple de ce constructeur. Supposons toujours le tableau de char lettres instancié en ligne 9.
L' instruction : String chaine = new String(lettres, 1, 4); permet de créer la chaine : esse. Car 1 est l' indice du caractère e. La chaine commence
donc par e. Puis 4 est la longueur de la chaine. On continue donc à mettre les caractères suivantes du tableau jusqu' à atteindre 4 caractères.
e, puis s, puis s, puis e.
On dit parfois qu' une chaine de caractères peut être assimilée à un tableau de caractères.
Ligne 16 : on crée l' objet new String("magic") en utilisant un constructeur qui requiert un seul argument. Cet argument est une chaine de
caractères tout simplement. C' est pourquoi, à l' affichage, on a : chaine = magic.
Voilà donc 4 façons de construire un objet String. Il y en a d' autres. Vous les trouverez sur la page web :
La classe String
N' oubliez pas qu' on peut aussi construire un objet String comme avec les types primitifs. En faisant simplement : String chaine = "marge";
La classe String possède plus de 45 méthodes. Certaines étant plutôt surchargées. C' est à dire que plusieurs méthodes ont le même nom. Evidement, pas la même signature. La signature d' une méthode, rappelons que c' est le nombre de ses arguments, le type des arguments, et l' ordre dans lequel se succèdent ses arguments.
Exemple 2 :
1. public class MethodesString
2. {
3. public static void main (String [] args )
4. {
5. String chaine1 = new String("programmer en Java");
6. System.out.println("Dans chaine1, en position 3, on trouve le caractère : " + chaine1.charAt(3));
7. String chaine2 = new String("c' est facile");
8. System.out.println("chaine1 comparée à chaine2 avec la méthode compareTo() donne : " + chaine1.compareTo(chaine2));
9. if(chaine1.compareTo(chaine2) > 0)
10. {
11. System.out.println("l' ordre alphabétique est donc : " + chaine2 + " - " + chaine1);
12. }
13. else
14. {
15. System.out.println("l' ordre alphabétique est donc : " + chaine1 + " - " + chaine2);
16. }
17. System.out.println();
18. String chaine3 = "paris"; String chaine4 = "Paris";
19. System.out.println("chaine3 comparée à chaine4 avec la méthode compareTo() donne : " + chaine3.compareTo(chaine4));
20. if(chaine3.compareTo(chaine4) > 0)
20. {
21. System.out.println("l' ordre alphabétique est donc : " + chaine4 + " - " + chaine3);
22. }
23. else
24. {
25. System.out.println("l' ordre alphabétique est donc : " + chaine3 + " - " + chaine4);
26. }
27. String chaine5 = "achille"; String chaine6 = "Zapata";
28. System.out.println();
29. System.out.println("chaine5 comparée à chaine6 avec la méthode compareTo() donne : " + chaine5.compareTo(chaine6));
30. if(chaine5.compareTo(chaine6) > 0)
31. {
32. System.out.println("l' ordre alphabétique est donc : " + chaine6 + " - " + chaine5);
33. }
34. else
35. {
36. System.out.println("l' ordre alphabétique est donc : " + chaine5 + " - " + chaine6);
37. }
38. System.out.println();
38. System.out.println("chaine5 comparée à chaine6 avec la méthode compareToIgnoreCase() donne : " + chaine5.compareToIgnoreCase(chaine6));
39. if(chaine5.compareToIgnoreCase(chaine6) > 0)
40. {
41. System.out.println("l' ordre alphabétique est donc : " + chaine6 + " - " + chaine5);
42. }
43. else
44. {
45. System.out.println("l' ordre alphabétique est donc : " + chaine5 + " - " + chaine6);
46. }
47. }
48. }
compilation, puis exécution donnent à l' affichage :
Dans chaine1, en position 3, on trouve le caractère : g
chaine1 comparée à chaine2 avec la méthode compareTo() donne : 13
l' ordre alphabétique est donc : c' est facile - programmer en Java
chaine3 comparée à chaine4 avec la méthode compareTo() donne : 32
l' ordre alphabÚtique est donc : Paris - paris
chaine5 comparée à chaine6 avec la méthode compareTo() donne : 7
l' ordre alphabétique est donc : Zapata - achille
chaine5 comparée à chaine6 avec la méthode compareToIgnoreCase() donne : -25
l' ordre alphabétique est donc : achille - Zapata
La méthode charAt() de la classe String est déclarée : public char charAt(int x)
Cette méthode (non static) est de type char. Elle requiert un argument de type int, correspondant à la position d' un caractère dans la chaine
sur laquelle on applique la méthode. La valeur renvoyée est le caractère dont la position est la valeur de l' argument. Ici, c' est 3.
L' objet chaine1 a pour valeur "programmer". position zéro, on trouve la lettre p. En position 1, la lettre r. position 2, on trouve la lettre o. Et en position 3, on trouve
la lettre g.
La méthode compareTo() est déclarée : public int compareTo(String chaineArgument)
Cette méthode requiert un argument de type String. Elle permet de comparer 2 objets String selon l' ordre alphabétique. L' objet sur lequel
on applique la méthode et l' objet argument. Si la valeur renvoyée est un entier positif, alors la chaine argument arrive en tête dans l' ordre
alphabétique. Si la valeur renvoyée est négative, alors, c' est que la chaine sur laquelle on applique la méthode arrive en tête dans l' ordre
alphabétique. Lorsque les deux chaines sont identiques, la valeur renvoyée est égale à zéro.
La méthode copareToIgnoreCase() est déclarée :
public int compareToIgnoreCase(String chaineArgument)
Cette méthode fait la même chose que compareTo(). Sauf qu' elle ne tient pas compte des majuscules. En effet, dans l' ordre alphabétique selon java,
les lettres majuscules arrivent avant les lettres miniscules. On a d' abord A, B, C, ... X, Y, Z puis a, b, c, ...., x, y, z. C' est pourquoi
avec la méthode compareTo(), Zapata arrive avant achille. Mais lorsqu' on utilise la méthode compreToIgnoreCase(), alors, tout redevient normal.
C' est achille qui arrive avant Zapata.
La méthode compareTo() transforme d' abord tout ce qui est en majuscule en miniscule. Ensuite, il y a comparaison.
Exemple 3 :
1. public class MethodesString2
2. {
3. public static void main (String [] args )
4. {
5. String chaine1 = "retour"; String chaine2 = "vers le futur";
6. System.out.println("concatener les 2 chaines donne : " + chaine1.concat(chaine2));
7. System.out.println();
8. char [] lettres = new char[5];
9. lettres[0] = 'm'; lettres[1] = 'e'; lettres[2] = 'd'; lettres[3] = 'i'; lettres[4] = 'a';
10. System.out.println("la somme des caractères du tableau donne le mot : " + String.copyValueOf(lettres));
11. System.out.println();
12. System.out.println("la somme de certains caractères du tableau donne le mot : " + String.copyValueOf(lettres, 1, 3));
13. System.out.println("est-ce que le mot retour se termine bien par our ? réponse = : " + chaine1.endsWith("our"));
14. }
15. }
compilez puis exécutez. On a à l' affichage :
concatener les 2 chaines donne : retourvers le futur
la somme des caractÞres du tableau donne le mot : media
la somme de certains caractères du tableau donne le mot : edi
est-ce que le mot retour se termine bien par our ? réponse = : true
La méthode concat() est déclarée :
public String concat(String chaineArgument)
Cette méthode requiert un argument de type String. Puis elle renvoie un objet de type String qui est la concaténation de la chaine sur laquelle
on applique la méthode et de la chaine argument. La concaténation de 2 chaines. C' est ajouter une chaine juste à la suite de l' autre. c' est
comme si vous écriviez : chaine1 + chaine2. Aucun espace entre les deux chaines. Si vous voulez de l' espace entre les 2, vous savez quoi faire.
chaine1 = chaine1 + ""; ou chaine2 = " " + chaine2. Avant d' appliquer la méthode.
La méthode copyValueOf() est déclarée : public static String copyValueOf()
Elle requiert un argument de type tableau de caractères. Elle est de type String. Elle renvoie une chaine dont les caractères sont respectivement
ceux du tableau de caractères. Elle est statique. On l' utilise en écrivant : nom de la classe, suivi d' un point, suivi du nom de la méthode.
C' est pourquoi en ligne 10, j' ai écrit : String.copyValueOf(lettres). lettres étant bien entendu, le tableau de caractères.
La méthode copyValueOf() possède une variante. Surcharge de méthode. L' autre méthode copyValueOf() s' utilise de la même façon. Une chose change
, c' est l' argument. Ici, on a 3 arguments qui sont respectivement : le tableau de char, un entier qui est l' indice du premier caractère dans
le tableau de la chaine renvoyée. Ici, c' est 1. Donc le caractère situé en position 1 dans le tableau sera le premier caractère de la chaine
renvoyée. C' est e. Puisque lettre[1] = 'e'. Et le troisième argument, c' est la longueur de la chaine. Ici, c' est 3. D' où edi. la chaine edi
a bel et bien 3 caractères.
La méthode endsWith() est déclarée : public boolean endsWith(String chaineArgument)
Cette méthode permet de savoir si la chaine sur laquelle on applique la méthode se termine par les caractères de la chaine argument. Elle renvoie
true si c' est le cas. Et false dans le cas contraire.
Exemple 4 :
1. public class MethodesString3
2. {
3. public static void main (String [] args )
4. {
5. String chaine1 = "retour"; String chaine2 = "retour";
6. System.out.println(chaine1.equals(chaine2));
7. String chaine3 = "java"; String chaine4 = "Java";
8. System.out.println(chaine3.equals(chaine4));
9. System.out.println(chaine3.equalsIgnoreCase(chaine4));
10. System.out.println();
11. char [] lettres = new char [7];
12. String chaine5 = "tournai";
13. chaine5.getChars(1, 5, lettres, 0);
14. for(int i = 0; i < lettres.length; i++)
15. {
16. System.out.println("caractere en position " + i + " = " + lettres[i] );
17. }
18. }
19. }
compilation puis exécution donnent à l' affichage :
true
false
true
caractere en position 0 = o
caractere en position 1 = u
caractere en position 2 = r
caractere en position 3 = n
caractere en position 4 =
caractere en position 5 =
caractere en position 6 =
La méthode equals() est déclarée : public boolean equals(Object autreObjet)
Elle est de type booléenne. Elle permet de comparer deux objets. L' objet sur laquelle on applique la méthode et l' objet argument. Ces 2 objets
sont de type Object (remarquez le c dans Object). La classe Object est ce qu' on appelle en java la super classe. La mère de toutes les classes.
On le verra en héritage et polymorphysme. Sachez pour l' instant que tous les objets, qu' ils soient issus des classes prédéfinies ou des classes
que le programmeur crée, sont de type Object. Pour revenir à notre chapitre actuel, sachez que cette méthode permet de comparer deux objets de
type String. On peut alors transformer la déclaration par : public boolean equals(String objetArgument)
Lorsque cette méthode compare 2 objets de type String, elle renvoie true si les deux chaines de caractères ont la même séquence. Succession des
mêmes caractères. C' est pourquoi la comparaison de chaine1 et chaine2 renvoie true.. Mais chaine3 et chaine4 renvoie false. Parce que Java est
un langage sensible à la casse. Il fait la différence entre majuscule et minuscule. Mais la méthode equalsIgnoreCase() ne fait aucune différence
entre majuscule et minuscule. c' est pourquoi la comparaison de chaine3 et chaine4 avec equalsIgnoreCase() renvoie true.
La méthode getChars() est déclarée :
public void getChars(int debutSource, int finSource, char [] tabChar, int debutTabChar)
Cette méthode va chercher un certain nombre de caractères appartenant à la chaine sur laquelle on applique la méthode. Cette chaine est la source.
Ces caractères sont pris à partir d' une certaine position dans la chaine (debutSource) jusqu' à une autre position (finSource). Le dernier
caractère étant exclu. Puis ces caractères sont mis un à un dans un tableau de caractères, ici tabChar. Et ce, à partir d' une certaine position
du tableau appelée debut TabChar.
Pour l' exemple ci-dessus, la chaine est chaine5 = "tournai"; La position de début est 1. Le caractère en position 1 dans chaine5 est o. La
position zéro étant occupée par le caractère t. La position finSource = 5 est occupée par la lettre a.. Mais le dernier caractère est exclu. Donc,
on n' utilisera pas ce caractère. Les caractères de chaine5 concernés sont donc, o, u, r et n. On met donc ces caractères dans le tableau de char.
Ici, c' est lettres. On les met à partir d' une certaine position qui est 0. Donc à partir du début du tableau. D' où position 0 -> o,
position 1 -> u, position 2 -> r, position 3 -> n.
Exemple 5 :
1. public class MethodesString4
2. {
3. public static void main (String [] args )
4. {
5. String chaine = "retournure";
6. System.out.println("première position de r dans chaine1 : " + chaine1.indexOf('r'));
7. System.out.println("première position de r dans chaine1 à partir de e: " + chaine1.indexOf('r', 5));
8. System.out.println("première position de ur dans chaine1 : " + chaine1.indexOf("ur"));
9. System.out.println("première position de ur dans chaine1 à partir de position 5 = " + chaine1.indexOf("ur", 5));
10. System.out.println("dernière position de ur dans chaine1 : " + chaine1.lastIndexOf("ur"));
11. System.out.println("nombre de caractères de chaine1 : " + chaine1.length() );
12. System.out.println("Le remplacement de tous les u par i dans chaine1 donne : " + chaine1.replace('u', 'i') );
13. System.out.println("est-ce que chaine1 commence par tra ? Réponse = " + chaine1.startsWith("tra") );
14. }
15. }
compil + exéc, donnent :
première position de r dans chaine1 : 0
première position de r dans chaine1 à partir de e: 5
première position de ur dans chaine1 : 4
première position de ur dans chaine1 à partir de position 5 = 7
dernière position de ur dans chaine1 : 7
nombre de caractères de chaine1 : 10
Le remplacement de tous les u par i dans chaine1 donne : retoirnire
est-ce que chaine1 commence par tra ? Réponse = false
Exemple 6 :
1. public class MethodesString5
2. {
3. public static void main (String [] args )
4. {
5. String chaine = "paribass";
6. System.out.println("La sous-chaine de chaine qui commence à l' indice 3 est : " + chaine.substring(3));
7. System.out.println("La sous-chaine de chaine qui commence à l' indice 3...");
8. System.out.println("... et se termine à l' indice 6( - 1 ) est : " + chaine.substring(3, 6));
9. System.out.println("La transformation de chaine en majuscules donne : " + chaine.toUpperCase() );
10. String ville = "PARIS";
11. System.out.println("La transformation de ville en miniscules donne : " + ville.toLowerCase() );
12. String autreVille = "MaRSeilLe";
13. System.out.println("La transformation de autreVille tout en majuscules donne : " + autreVille.toUpperCase() );
14. System.out.println("La transformation de autreVille tout en miniscules donne : " + autreVille.toLowerCase() );
14. }
15. }
compil + exéc, donnent :
La sous-chaine de chaine qui commence à l' indice 3 est : ibass
La sous-chaine de chaine qui commence à l' indice 3...
... et se termine à l' indice 6( - 1 ) est : iba
La transformation de chaine tout en majuscules donne : PARIBASS
La transformation de ville tout en miniscules donne : paris
La transformation de autreVille tout en majuscules donne : MARSEILLE
La transformation de autreVille tout en miniscules donne : marseille
Pour les autres méthodes de la classe String, une rechercher et des efforts personnels ne vous feront pas de mal. Au boulot !
La Classe String
Pour trouver rapidement le contenu d' une classe java, vous devez taper les mots suivants dans le moteur de recherche google :
java platform class nomDeLaClasse remarquez l' absence de e dans la mot class.
exemple : java platform class ArrayList.
Le premier site trouvé par Google correspondra à ce que vous cherchez.
Comme la classe String, la classe StringBuffer permet de manipuler elle aussi les caractères et les chaines de caractères. Avec cette différence
fondamentale. Les objets StringBuffer sont modifiables. Je m' explique.
Lorsqu' on écrit l' instruction : String ch = new String("tuile");
On crée un objet String (new String("tuile") ). Puis on place sa
référence (son adresse mémoire) dans la variable ch.
En écrivant ch = new String("tuilerie"); , on n' a pas modifié la variable ch. On a créé un nouvel objet String (new String("tuilerie") ).
Puis on a placé sa référence dans la variable ch. Maintenant, la variable ch pointe vers l' objet new String("tuilerie"). L' objet new
String("tuile") quand à lui, n' est plus référencé.
Imaginer un programme dans lequel une chaine doit subir de multiples modifications telles que des ajouts sur la chaine. chaine = chaine + "ajout";
A chaque fois, il faudra créer un nouvel objet. Et cela vous bouffe la mémoire. Et en plus ça prend du temps. Le logiciel que vous allez créer
et dont le programme (ou l' un des programmes) permettra de multiples modifications s' avèrera pas très performant. Prenons 2 exemples.
Exemple 1 :
1. public class TesterString
2. {
3. public static void main (String [] args )
4. {
5. String s = "";
6. for(int i = 0; i < 10000; ++i)
7. {
8. s = s + i;
9. }
10. }
11. }
Exemple 2 :
1. public class TesterStringBuffer
2. {
3. public static void main (String [] args )
4. {
5. StringBuffer s = new StringBuffer("");
6. for(int i = 0; i < 10000; ++i)
7. {
8. s.append(i);
9. }
10. }
11. }
La méthode append() de la classe StringBuffer permet d' ajouter des bouts de chaine à l' objet StringBuffer.
Compilez puis exécutez chacun des programmes ci-dessus. Comparer les temps d' exécution. J' ai bien dit les temps d' exécution et pas de compilation.
Car le temps de compilation est quasiment le même. Mais chronométrez le temps d' exécution. Moi j' ai noté une différence. Le programme avec
StringBuffer prend 5 à 6 fois moins de temps. Pas la peine de vous dire combien de temps ça prend. Le temps d' exécution d' un programme
dépend du matériel. En l' occurence, tous les PC n' ont pas la même vitesse d' exécution d' un prorgramme.
Conséquence : Si vous devez créer un programme dans lequel les chaines seront modifiés, vaut mieux choisir la classe StringBuffer. Mais il n' y a
pas que ça comme raison pour choisir cette classe. En étudiant les diverses méthodes de StringBuffer, vous verrez d' autres raisons.
La classe StringBuffer possède au moins 3 constructeurs. Tout dépend des versions de java évidement.
Exemple 3 :
1. public class ConstructeursStringBuffer
2. {
3. public static void main (String [] args )
4. {
5. String chaine = "madison";
5. StringBuffer s1 = new StringBuffer();
6. StringBuffer s2 = new StringBuffer(10);
7. StringBuffer s3 = new StringBuffer(chaine);
8.
9. System.out.println("s1 = " + s1);
10. System.out.println("s2 = " + s2);
11. System.out.println("s3 = " + s3);
12. }
13. }
Le constructeur utilisé en ligne 5 est déclaré : public StringBuffer()
Ce constructeur permet de créer un objet StringBuffer vide (sans aucun caractère) avec une capacité initiale de 16 caractères. On peut donc
ajouter à cet Objet, 16 caractères sans avoir à aggrandir sa capacité. Ce qui est une opération qui consomme du temps.
Le constructeur utilisé en ligne 6 est déclaré : public StringBuffer(int taille)
Ce constructeur permet de créer un objet StringBuffer vide (sans aucun caractère) avec une capacité initiale d' un nombre de caractères égal à
la valeur de taille. Argument de type int. On peut donc ajouter à cet objet, autant de caractères que la valeur de taille sans avoir à aggrandir
sa capacité. Ce qui est une opération qui consomme du temps.
Le constructeur utilisé en ligne 7 est déclaré : public StringBuffer(String chaine)
Ce constructeur permet de créer un objet StringBuffer qui est transforme l' objet String argument en objet StringBuffer.
Exemple 4 :
1. public class MethodessStringBuffer
2. {
3. public static void main (String [] args )
4. {
5. StringBuffer chaine = new StringBuffer("madison");
6. boolean b = true;
7. chaine.append(b);
8. System.out.println("nouvelle chaine = " + chaine);
9. StringBuffer chaine2 = new StringBuffer("HALA"); char c = 'L';
10. chaine2.append(c);
11. System.out.println("nouvelle chaine = " + chaine2);
12. StringBuffer chaine3 = new StringBuffer("M");
13. char [] lettres = {'y', 'J', 'a', 'v', 'a'};
14. chaine3.append(lettres);
15. System.out.println("nouvelle chaine = " + chaine3);
16. StringBuffer chaine4 = new StringBuffer("crac");
17. chaine4.append(lettres, 1, 2);
18. System.out.println("nouvelle chaine = " + chaine4);
19. StringBuffer chaine5 = new StringBuffer("pur"); double d = 22.45;
20. chaine5.append(d);
21. System.out.println("nouvelle chaine = " + chaine5);
22. Cercle A = new Cercle(1, 2, 3);
23. chaine5.append(A);
24. System.out.println("nouvelle chaine = " + chaine5);
25. String ch = "ret";
26. chaine.append(ch);
27. System.out.println("nouvelle chaine = " + chaine);
28. StringBuffer chB = new StringBuffer("retB");
29. chaine.append(chB);
30. System.out.println("nouvelle chaine = " + chaine);
31. }
32. }
compilez puis exécutez. il sera affiché :
nouvelle chaine = madisontrue
nouvelle chaine = HALAL
nouvelle chaine = MyJava
nouvelle chaine = cracJa
nouvelle chaine = pur22.45
nouvelle chaine = pur22.45Cercle@4f1d0d
nouvelle chaine = madisontrueret
nouvelle chaine = madisontrueretretB
La méthode append() de la classe StringBuffer est surchargée, (je dirais même hyperchargée). Cela veut dire qu' on la trouve sous plusieurs
formes. Elle permet d' ajouter un bout de chaine à la chaine de type StringBuffer.
En ligne 7, on a utilisé la forme qui requiert un argument de type boolen. Puis la méthode ajoute la représentation sous forme de chaine de la
variable booléenne. Ici, b = true. donc, sa représentation sous forme de chaine est "true". Et voilà pourquoi à l' affichage, on voit :
madisontrue. Car "true" a été ajoutée à "madison".
En ligne 10, on a utilisé la forme qui requiert un argument de type char. Puis la méthode ajoute sa représentation sous forme de chaine
à la chaine StringBuffer sur laquelle la méthode est appliquée. "HALA" + "L" donne "HALAL". D' où l' affichage de HALAL
En ligne14, on a utilisé la forme qui requiert un argument de type tableau de caractères. Ici, c' est lettres. Puis la méthode ajoute sa
représentation sous forme de chaine à la chaine StringBuffer sur laquelle la méthode est appliquée. Représentation sous forme de chaine du
tableau de char, c' est la chaine contenant tous les caractères du tableau. Donc, c' est "yJava". La chaine StringBuffer sur laquelle on applique
la méthode est "M". D' où à l' affichage : "MyJava".
En ligne 17, on a utilisé la forme qui requiert 3 arguments : un tableau de caractères, la position dans le tableau du premier caractère ajouté
à la chaine StringBuffer et le nombre total de caractères ajouté à l' objet StringBuffer.
Cette position est 1. Et le caractère en position 1 du tableau lettres est J. Le nombre total de caractères ajoutés étant 2, on ajoute simplement
un 2ème caractère qui est forcément le suivant. Donc, le caractère a. La méthode append() ajoute donc Ja à la chaine4, chaine sur laquelle la
méthode est appliquée. Et c' est "crac". D' où cracJa à l' affichage.
En ligne 20, on a utilisé la forme qui requiert comme argument une variable de type double. Cette méthode ajoute à la chaine StringBuffer sur
laquelle la méthode est appliquée, la représentation sous forme de chaine de la variable d = 22.45; Et sa représentation sous forme de chaine est
"22.45". "pur" + "22.45" = pur22.45 à l' affichage.
De même qu' on a utilisé la représentation sous forme de chaine d' une variable de type double, on pourra utiliser celle d' une variable de type
float, int, long, short, byte.
En ligne 23, on a utilisé la forme qui permet d' ajouter la représentation sous forme de chaine d' un objet à la chaine StringBuffer sur
laquelle on applique la méthode. La chaine sur laquelle la méthode est appliquée est chaine5. Et c' est pur22.45, puisque "22.45" a été
ajouté à "pur" (voir méthode précédente). A l' affichage, on voit une chaine bizarre. pur22.45Cercle@4f1d0d. Sur votre ordinateur,
vous ne verrez pas forcément la même chose; En fait, vous verrez pur22.45Cercle@ suivi d' autres chiffres et lettres. Ici, la chaine
Cercle@4f1d0d représente la fameuse adresse mémoire dont je vous ai parlé dans le chapitre consacré à la référence à un objet. Cette adresse
dépend de l' ordinateur et du moment où le programme est exécuté.Puisque en créant un objet, l' ordinateur le place à l' endroit de la mémoire
imméditaement disponible. Et c' est endroit peut varier d' un PC à un autre et d' un moment à un autre sur le même PC.
En ligne 26, on a utilisé la forme qui permet d' ajouter un objet String (ici, ch = "ret") à un objet StringBuffer (ici, chaine a pour valeur
madisontrue (voir explication de la ligne 7). D' où à l' affichage : madisontrueret.
Et enfin, en ligne 29, on a utilisé la forme qui permet d' ajouter un objet StringBuffer à un autre objet StringBuffer. Ici, "madisontrueret" et
"retB". D' où l' affichage de madisontrueretretB.
Note : La représentation d' un objet sous forme de chaine est son adresse mémoire. En fait, c' est vrai par défaut. On peut faire en sorte que sa
représentation sous forme de chaine soit autre chose. On peut choisir soi même la chaine que doit représenter un objet. Pour cela, il faudra
procéder à ce qu' on appelle la redéfinition de sa méthode toString(). On parlera de redéfinition de méthode dans le chapitre consacré à
l' héritage et au polymorphisme.
Autre chose : Vous devez vous arranger à ce que la classe Cercle soit dans le même répertoire que le programme ci-dessus. La classe Cercle que
j' ai utilisée a été définie au chapitre C.2 : constructeurs d' objets.
Exemple 5 :
1. public class MethodessStringBuffer2
2. {
3. public static void main (String [] args )
4. {
5. StringBuffer chaine1 = new StringBuffer();
6. System.out.println("nombre possible de caractères sans agrandir = " + chaine1.capacity());
7. System.out.println();
8.
9. StringBuffer chaine2 = new StringBuffer("retourner");
10. System.out.println(chaine2.charAt(2));
11. System.out.println();
12.
13. chaine2.delete(1, 4);
14. System.out.println(chaine2);
15. System.out.println();
16.
17. StringBuffer chaine3 = new StringBuffer("malade");
18. chaine3.deleteCharAt(2);
19. System.out.println(chaine3);
20. System.out.println();
21.
22. chaine3.ensureCapacity(22);
23. System.out.println("nombre possible de caractères sans agrandir = " + chaine3.capacity());
24. }
25. }
compilez puis exécutez ce programme, il sera affiché :
nombre possible de caractÞres sans agrandir = 16
t
rurner
maade
nombre possible de caractÞres sans agrandir = 22
En ligne 5, on instancie un objet StringBuffer à partir d' un constructeur sans arguments. Celui-ci permet de créer un objet StringBuffer avec
une capacité minimale de 16 caractères. Voir programme sur les constructeur en exemple 3. En ligne 6, on demande l' affichage de cette capacité.
D' où l' affiche de 16.
En ligne 10, on demande l' affichage du caractère en position 2 de la chaine2. C' est comme la méthode charAT() de la classe String. C' est
pourquoi à l' affichage, on a t. position zéro = r, position 1 = e et position 2 = t.
En ligne 13, on applique à la chaine2, la méthode delete(). Celle-ci requiert 2 arguments de type int. La méthode permet d' effacer un certain
nombre de caractères dans l' objet StringBuffer sur lequel elle est appliquée. Ces caractères vont de la position 1 (premier argument), à la
position 4 (2ème argument. Mais attention, le caractère de la position 4 n 'est pas effacé. On s' arrête juste avant. Dans chaine2 ("retourner"),
on a enlevé les caractères e (position 1), t(position 2), o (position 3). C' est pourquoi, à l' affichage, on a rurner.
En ligne 18, on a appliqué la méthode deleteCharAt(). Elle requiert un argument de type int. Puis elle supprime le caractère en position de
l' argument (ici 2) de l' objet StringBuffer sur lequel elle est appliquée. Ainsi, "malade" devient "maade". Le l, en position 2 dans "malade"
est ainsi supprimé. D' où à l' affichage, on a : maade.
La méthode ensureCapacity() utilisée en ligne 22requiert un argument de type int. Elle assure à l' objet StringBuffer sur lequel on l' applique,
une capacité minimale de caractères correspondant à l' argument. Ici, c' est 22.
Exemple 5 :
1. public class MethodessStringBuffer2
2. {
3. public static void main (String [] args )
4. {
5. boolean b = true; int debut = 2;
6. StringBuffer chaine1 = new StringBuffer("partir");
7. System.out.println(chaine1.insert(debut, b) );
8. System.out.println();
9.
10. char c = 'e'; int initial = 3;
11. StringBuffer chaine2 = new StringBuffer("amrica");
12. System.out.println(chaine2.insert(initial, c) );
13. System.out.println();
14.
15. char [] lettres = {'m', 'i', 'r', 'a'}; int d = 2;
16. StringBuffer chaine3 = new StringBuffer("Hal");
17. System.out.println(chaine3.insert(d, lettres) );
18. System.out.println();
19.
20. StringBuffer chaine4 = new StringBuffer("moir");
21. System.out.println(chaine4.insert(1, lettres, 1, 2) );
22. System.out.println();
23.
24. StringBuffer chaine5 = new StringBuffer("pure");
25. double reel = 22.45;
26. System.out.println(chaine5.insert(2, reel) );
27. System.out.println();
28.
29. Cercle A = new Cercle(1, 5, 3);
30. StringBuffer chaine6 = new StringBuffer("megaTUFF");
31. System.out.println(chaine6.insert(4, A) );
32. System.out.println();
33.
34. String ch = "retour";
35. StringBuffer chaine7 = new StringBuffer("MAG");
36. System.out.println(chaine7.insert(0, ch) );
37. }
38. }
compilez puis exécutez. Il sera affiché :
patruertir
amreica
Hamiral
miroir
pu22.45re
megaCercle@4f1d0dTUFF
retourMAG
La méthode insert() est aussi surchargée que la méthode append(). La méthode append() permettait d' ajouter un bout de chaine à un objet StringBuffer.
La méthode insert() aussi. append() ajoute toujours à la fin. Alors que insert() permet d' insérer un bout de chaine n' importe où dans le
StringBuffer.
Quelque soit la forme utilisée, la méthode insert() a pour premier argument, une variable de type int dont la valeur est la position que prendra
le premier caractère de la chaine à insérer dans l' objet StringBuffer.
En ligne 7, on a utilisé la forme qui requiert en plus de la variable int, une variable booléenne. Sa représentation sous forme de chaine est
insérée dans le StringBuffer ("partir") de sorte que le premier caractère de "true" soit en position 2. D' où à l' affichage, on a : patruertir.
En ligne 12, la méthode insere le caractère de c, c' est à dire, 'e' en position 3 de la chaine amrica. D' où à l' affichege : amreica.
En ligne 17, la méthode insere toute les caractères du tableau de caractères lettres dans la chaine "Hal". Et ce, de façon à ce que le premier
caractère de ce tableau (m) soit en position 2. D' où à l' affichage : Hamiral.
En ligne 21, la méthode insere une partie du tableau de caractères lettres à partir de la position 1 (premier argument de la méthode. Le
troisième argument indique la position dans le tableau, du premier caractère pris. Ici, c' est i qui est en position 1. Le dernier argument
indique le nombre de caractères pris. Ici, c' est 2. Comme on a déjà pris i, il ne reste plus qu' à prendre le caractère suivant qui est r. La
chaine sur laquelle on applique la méthode est "moir". On insere donc ir dans moir en mettant i en position 1. D' où à l' affichage :
miroir.
En ligne 26, la méthode insere la représentation sous forme de chaine de la variable double ("22.45") dans la chaine5 ("pure"). Et ce, à partir
de la position 2. D' où à l' affichage : pu22.45re. On peut faire de même avec les variables de type byte, short, int, long et float.
En ligne 31, c' est la représentation sous forme de chaine de l' objet Cercle qu' on insere dans la chaine6 ("megaTUFF"). La représentation
sous forme de chaien d' un objet est son adresse mémoire. L' insertion se fait à partir de la position 4. D' où à l' affichage : megaCercle@4f1d0dTUFF
En ligne 37, on insere un objet de type String "retour" dans un objet de type StringBuffer "MAG" et ce à partir de la position zéro. Donc, on fait
le contraire de append(). On insere au début. D' où à l' affichage : retouMAG.
Je rappelle encore que la représentation sous forme de chaine d' un objet est, par défaut, son adresse mémoire. Mais on peut faire en sorte
que cela soit autre chose. Une chaine qu' on aura préalablement définie. On verra cela dans le chapitre Héritage et Polymorphisme.
Bien entendu, en utilisant un objet cercle, on s' assurera que la classe Cercle se trouve dans le même répertoire que le programme.
D' autres méthodes de la classe StringBuffer existent. A vous de les étudier en allant sur la page
La classe StringBuffer
Quand choisir StringBuffer plutôt que String. Je dirais que lorsque des chaines doivent subir des modifications régulières, préférez StringBuffer.
Un ultime exemple pour vous montrer la grosse différence entre String et StringBuffer.
Exemple 6 :
1. public class StringContreStringBuffer
2. {
3. public static void main (String [] args )
4. {
5. String chaine1 = new String("tour");
6. String chaine2 = chaine1;
7. System.out.println("chaine1 = " + chaine1 + " et chaine2 = " + chaine2);
8. chaine1 = chaine1 + "noi";
9. System.out.println("chaine1 = " + chaine1 +" et chaine2 = " + chaine2);
10. System.out.println();
11.
12. StringBuffer chaineB1 = new StringBuffer("tour");
13. StringBuffer chaineB2 = chaineB1;
14. System.out.println("chaineB1 = " + chaineB1 +" et chaineB2 = " + chaineB2);
15. chaineB1 = chaineB1.append("noi");
16. System.out.println("chaineB1 = " + chaineB1 +" et chaineB2 = " + chaineB2);
17. }
18. }
compilez puis exécutez. L' affichage sera :
chaine1 = tour et chaine2 = tour
chaine1 = tournoi et chaine2 = tour
chaineB1 = tour et chaineB2 = tour
chaineB1 = tournoi et chaineB2 = tournoi
Ligne 5 : j' instancie un objet String et je mets sa référence dans chaine1. Ligne 6 : Je crée une référence de type String chaine2. Puis je
mets la référence chaine1 dans chaine2. Maintenant, chaine1 et chaine2 représentent le même objet new String("tour").
C' est pourquoi à l' affichage, j' ai : chaine1 = tour et chaine2 = tour
En ligne 8, je modifie chaine1. En fait, en écrivant chaine1 = chaine1 + "noi", je crée un nouvel objet qui est la concaténation de l' objet
représenté par chaine1 ( new String("tour") ) et d' un nouvel objet "noi". Je mets la référecne de ce nouvel objet dans la variable
chaine1. Mais chaine2 est toujours une référence à l' objet new String("tour"). C' est pourquoi à l' affichage, on a :
chaine1 = tournoi et chaine2 = tour
En ligne 12, j' instancie un nouvel objet StringBuffer et je mets sa référence dans la variable chaineB1. En ligne 13, Je crée une référence
de type StringBuffer chaine2B. Puis j' y mets la référence chaineB1. C' est pourquoi à l' affichage, j' ai : chaineB1 = tour et chaineB2 = tour
En ligne 15: Je modifie chaineB1 en y ajoutant la chaine "noi" à la fin. J' ai bien dit : je modifie. Je ne crée pas de nouvel objet. Donc,
chaineB1 et chaineB2 pointent toujours vers le même objet. C' est pouquoi à l' affichage, on a : chaineB1 = tournoi et chaineB2 = tournoi
Pigé ?... Maintenant, à vous d' approfondir l' étude des 2 classes afin de faire votre choix selon le problème à résoudre
| précédent | sommaire | accueil | suivant |