La classe scanner.

Nouveau avec Java 1.5/5.0

• Java permet maintenant l’utilisation de la classe
Scanner :
– Créez un nouveau scanner et assignez-le à une
variable clavier.
– Invoquez des méthodes sur la variable clavier
pour lire au clavier, et assignez/affichez le
résultat.
• nextInt( )
• nextDouble( )
• nextBoolean( )
• nextLine(
Exemples d’utilisation de Scanner
• Initialisation du scanner:
Scanner clavier = new Scanner( System.in );

int x = clavier.nextInt( );
• Si vous entrez 123 et appuyez sur ENTER, x vaudra 123 .
boolean b = clavier.nextboolean ( );
• Si vous entrez true et appuyez sur ENTER, b vaudra true.
String s = clavier.nextLine( );
• La méthode nextLine place TOUS les caractères (incluant les
espaces) que vous tapez sur la ligne dans la variable s.

1
 Classes String et StringBuffer

Construction des objets chaînes

• Les objets de la classe String ne sont pas des tableaux de caractères en Java, comme
c'est le cas en C.
• Ce sont des objets à part entière, qui doivent être déclarés et construits.
• Ils ont une taille fixée et définitive à leur création.
• Si on veut traiter de chaînes de caractères modifiables, il faut utiliser la classe
java.lang.StringBuffer.

Constructions directes

Le langage a cherché à simplifier le maniement des chaines, quitte à déroger aux règles
générales de construction et de manipulation des classes d'objets.

• Construction normale
La façon générale et normale de définir une chaine est d'utiliser un constructeur
comme pour les autres objets. Par exemple :
• String ch = new String("Voici une chaine !") ;
• System.out.println( ch ) ;
• Construction simplifiée
Mais pour simplifier, on utilise couramment la construction équivalente :
• String ch = "Voici une chaine !" ;

En l'absence de l'opérateur de construction new, lorsque le compilateur rencontre une

série de caractères entre guillemets, il se charge de créer automatiquement un objet
String. Il s'agit alors d'une dérogation qui simplifie le code du programmeur!

• Reconstruction automatique
Non seulement les objets String sont automatiquement construits, mais ils sont aussi
reconstruits lors d'une réaffectation d'une même variable.
• String ch = "Voici une chaine !" ;
• System.out.println( ch ) ;
• ch = "Bonjour !"
• System.out.println( ch ) ;

La 2ème affectation est correcte car elle a reconstruit la chaine, ce qui a permis le
changement de sa taille.

Autres schémas de construction

• la construction d'une chaine à partir d'un tableau de byte.

• // table est un tableau de 7 octets

2
 • byte[] table = {'B', 'o', 'n' , 'j' , 'o' , 'u' , 'r'} ;
• String ch = new String(table, 0 , table.length) ;
• System.out.println( ch ) ;
• De même on peut construire une chaine à partir d'un tableau de char
• char[] table = {'a', 'b', 'c'};
• String ch = new String( table );
• est équivalent à :String ch = "abc";

Les méthodes de String

• Les méthodes d'examen et d'extraction
o ch.toUpperCase(); mise en majuscule de la chaine ch
o ch.toLowerCase() ;mis en minuscule la chaine ch.
o ch.length(); renvoie un entier, sa longueur
o ch.charAt(i); renvoie le ième caractère de ch, i variant de 0 à
ch.length()-1
o ch.indexOf('Z'); renvoie le rang de la première apparition de 'Z' dans
ch, -1 sinon
o ch.indexOf("java"); renvoie le rang de la première apparition de "java"
dans ch, sinon -1
o ch.substring(i, k); renvoie la sous-chaine extraite de ch, à partir du
rang i (le i+1 ème caractère) jusqu'au rang k inclus.
o Ch.replace(oldechar,newchar) ;remplace les chaine oldchar par newchar.
o Ch.trime() ; permet de supprimer l’espace au début eu à la fin.
• Les méthodes equals et compareTo
Exemple
• String r = "essai";
• String s = "es" + "sai";
• String u = "ESSAI".toLowerCase();
• System.out.println(" (r == s) : " + (r == s));
• System.out.println(" (r == u) : " + (r == u));
• System.out.println(" r.equals(u) : " + (r.equals u));
• exécution
• (r == s) : true
• (r == u) : false
• r.equals (u) : true
o r == s : la valeur de cette expression (true) montre que les références r et s
sont ici égales ; cela est ainsi car une seule instance de la classe String a été
créée pour les deux chaînes de caractères, qui ont été repérées comme
identiques.
o r == u : cette expression vaut false ; les variables r et u référencent deux
instances différentes de la classe String qui contiennent la même chaîne de
caractères.
o r.equals(u) : cette expression vaut true; ici ce sont bien les valeurs pointées
par les références qui sont comparées.
Conclusion :il ne faut donc pas tester l'égalité de deux chaînes avec "==", mais
utiliser la méthode equals() (ou bien la méthode compareTo()).

L'opérateur de concaténation +
Le langage définit l'opérateur + capable de concaténer des objets String
Cet opérateur offre des facilités pour rendre plus aisé l'assemblage de constantes et de

3
variables primaires en chaine. Un "cast" (conversion) automatique est appliqué entre 2
arguments de types différents, reliés par cet opérateur + :
si l'un des deux arguments est une constante ou une variable String, ou un nombre, l'autre est
converti en chaine, de sorte que l'opérateur + renvoie une nouvelle chaine en résultat.

Exemples

/** concaténer une chaine et des caractères par l'opérateur + */

System.out.println("Quel est votre numéro de groupe ?");
String ch = "Stage TIC014";
ch = ch + 'A';
System.out.print(ch); // sans passage à la ligne

Classe StringBuffer
• Il s'agit de créer des objets buffer ou zone de travail qui contient des caractères.
On réserve un buffer simplement en indiquant la taille ou la valeur initiale, comme :
• str=StringBuffer (128) ;
• str=StringBuffer ("Bonjour ") ;

La différence avec un objet String est que la taille d'un StringBuffer est variable.
Une telle chaine peut être modifiée et ainsi être utilisée lors d'une construction
dynamique.

• Méthodes spécifiques
append(ch) ajoute la chaine ch à la fin de l'actuelle chaine
setLength(n) fixe la nouvelle longueur à n, ce qui peut tronquer la chaine actuelle.
• reverse()

Exemple:

• String s;

StringBuffer s1=new StringBuffer(s);

s2=s1.reverse().toString();

• Remarque :
La concaténation + entre String est en fait implémentée en utilisant StringBuffer et
la méthode toString().

Par exemple, ch étant un objet String :

ch = ch + "abc" signifie

StringBuffer str = new StringBuffer();

str=str.append("abc"); // la chaine "abc" est ajoutée à la fin de str
ch=str.toString(); // str est tranformée en chaine de type String

4
 classe StringTokenizer :
• découpe une chaîne de caractères en "mots" selon certains séparateurs ; les séparateurs
sont précisés ou par défaut : espace, tabulation, retour-chariot et newline
• constructeurs :
o StringTokenizer(String chaine) découpe la chaîne selon les séparateurs par
défaut
o StringTokenizer(String chaine, String Séparateurs) découpe la chaîne selon les
Séparateurs précisés
• méthodes :
o countTokens() retourne le nombre de "mots à séparer" qui reste dans la chaine
o hasMoreTokens() retourne true s'il reste des "mots à séparer" dans la chaine
o nextToken() retourne un nouveau "mot" (String ) séparé de la chaine String

Exemple
String s=" java est un langage moderne ";
StringTokenizer st=new StringTokenizer(s);
System.out.println("nombre mots "+st.countTokens());
while(st.hasMoreTokens())
System.out.println(st.nextToken());

5
 La classe Math
Cette classe contient des méthodes de calcul sur les entiers et les réels conformes à la norme
IEEE 754 ce qui assure leur portabilité sur les clients.
Elle contient également des approximations (en double) de e et de π.

Toutes les méthodes doivent être préfixées par le nom de la classe.

Les fonction abs( x ), min(x,y) et max(x,y ) admettent les types int, long, float et double
comme arguments.

int i,j = -4;

double a = 4.2, b = Math.PI, c;
i = Math.abs(j); //préfixer par Math !!!
c = Math.min(a,b);

Les fonctions trigonométriques, exponentielle, logarithme et puissance utilisent uniquement

des doubles comme arguments. Si on utilise des arguments illégaux, les méthodes de la classe
Math génèrent une exception. Elles retournent NaN (Not a Number).

1 Fonctions trigonométriques

Ces fonctions travaillent toujours sur des valeurs en radians. On trouve les fonctions :
sin (double) : sinus de l'argument exprimé en radian
cos (double) : cosinus
tan (double) : tangente
asin(double) : arc sinus (valeur dans l'intervalle [-π / 2, + π / 2])
acos(double) : arc cos (valeur dans l'intervalle [0, + π]
atan (double) : arc tangente (valeur dans l'intervalle [-π / 2, + π / 2])

2 Autres fonctions

exp (double) : exponentielle

log (double) : logarithme népérien
sqrt (double) : racine carrée
pow (double, double) : élévation du premier argument à la puissance dont la valeur est le
second argument. Si le premier argument est nul, le second doit être strictement positif. Si le
premier argument est strictement négatif, le second doit être une valeur entière.
random (génération à chaque appel d'un nombre pseudo-aléatoire compris entre 0 et 1.0).
(Il existe également dans le package java.util une classe Random qui permet une
gestion plus complète des nombres aléatoires.)
On dispose aussi de trois méthodes pour les arrondis : ceil (arrondi à l'entier supérieur), floor
(arrondi à l'entier inférieur), round (arrondi par rapport à 0,5). Ces trois méthodes admettent
des "double" comme arguments et elles retourne un double sans partie décimale et non pas un
entier. round admet aussi des arguments de type "float" auquel cas la valeur retournée est du
type "int".

double x = 0.751, z;
z = Math.ceil ( x ); // z = 1.0
z = Math.floor ( x ); // z = 0.0
z = Math.round ( x ); // z = 1.0