Categories
Informatique

La manipulation des chaines de caractères en Java

La manipulation des chaines de caractères
La définition d’un caractère :
Exemple :
char touche = '%';
La définition d’une chaine :
Exemple :
String texte = « bonjour »;
Les variables de type String sont des objets. Partout ou des constantes chaines figurent entre guillemets, le compilateur Java génère un objet de type String avec le contenu spécifié. Il est donc possible d’ecrire :

String texte = « Java Java Java ».replace('a','o');
Les chaines ne sont pas des tableaux : il faut utiliser les méthodes de la classes String d’un objet instancié pour effectuer des manipulations.
Il est impossible de modifier le contenu d’un objet String contruit à partir d’une constante. Cependant, il est possible d’utiliser les méthodes qui renvoient une chaine pour modifier le contenu de la chaine
Exemple :
String texte = « Java Java Java »;
texte = texte.replace('a','o');

Java ne fonctionne pas avec le jeu de caractères ASCII ou ANSI, mais avec Unicode (Universal Code). Ceci concerne les types char et les chaines de caractères. Le jeu de caractères Unicode code un caractère sur 2 octets. Les caractères 0 à 255 correspondent exactement au jeu de caractères ASCII
1. Les caractères spéciaux dans les chaines de caractères

Caractères spéciaux Affichage
\’ Apostrophe
\ » Guillemet
\\ anti slash
\t Tabulation
\b retour arrière (backspace)
\r retour chariot
\f saut de page (form feed)
\n saut de ligne (newline)
\0ddd caractère ASCII ddd (octal)
\xdd caractère ASCII dd (hexadécimal)
\udddd caractère Unicode dddd (hexadécimal)

2 L’addition de chaines de caractères

Java admet l’opérateur + comme opérateur de concaténation de chaines de caractères.
L’opérateur + permet de concatener plusieurs chaines. Il est possible d’utiliser l’opérateur +=
Exemple :
String texte = « »;
texte += « Hello »;
texte += « World3 »;

Cet opérateur sert aussi à concatener des chaines avec tous les types de bases. La variable ou constante est alors convertie en chaine et ajoutée à la précédente. La condition préalable est d’avoir au moins une chaine dans l’expression sinon le sinon ‘+’ est évalué comme opérateur mathématique.
Exemple :
System.out.println(« La valeur de Pi est : »+Math.PI);
int duree = 121;
System.out.println(« durée = » +duree);

3. La comparaison de deux chaines de caractères
Il faut utiliser la méthode equals()
Exemple :
String texte1 = « texte 1 »;
String texte2 = « texte 2 »;
if ( texte1.equals(texte2) )...

4. La détermination de la longueur d’une chaine de caractères
La méthode length() permet de déterminer la longueur d’une chaine.
Exemple :
String texte = « texte »;
int longueur = texte.length();

5. La modification de la casse d’une chaine de caractères
Les méthodes Java toUpperCase() et toLowerCase() permettent respectivement d’obtenir une chaine tout en majuscule ou tout en minuscule.
Exemple :
String texte = « texte »;
String textemaj = texte.toUpperCase();

 

 

Categories
Informatique

Les conversions de types en Java

Les conversions de types

Lors de la déclaration, il est possible d’utiliser un cast :
Exemple :
int entier = 5;
float flottant = (float) entier;

La conversion peut entrainer une perte d’informations.
Il n’existe pas en java de fonction pour convertir : les conversions de type ce font par des méthodes. La bibliothèque de classes API fournit une série de classes qui contiennent des méthodes de manipulation et de conversion de types élémentaires.

Classe Role
String pour les chaines de caractères Unicode
Integer pour les valeurs entières (integer)
Long pour les entiers long signés (long)
Float pour les nombres à virgules flottante (float)
Double pour les nombres à virgule flottante en double précision (double)

Les classes portent le même nom que le type élémentaires sur lequel elles reposent avec la première lettre en majuscule.
Ces classes contiennent généralement plusieurs constructeurs. Pour y accéder, il faut les instancier puisque de sont des objets.
Exemple :
String montexte;
montexte = new String(«test»);

L’objet montexte permet d’accéder aux méthodes de la classe java.lang.String
La conversion d’un entier int en chaine de caractère String
Exemple :
int i = 10;
String montexte = new String();
montexte =montexte.valueOf(i);

valueOf est également définie pour des arguments de type boolean, long, float, double et char
La conversion d’une chaine de caractères String en entier int
Exemple :
String montexte = new String(« 10 »);
Integer nomnombre=new Integer(montexte);
int i = monnombre.intValue(); //convertion d'Integer en int

La conversion d’un entier int en entier long
Exemple :
int i=10;
Integer monnombre=new Integer(i);
long j=monnombre.longValue();

 

Categories
Informatique

Les Tableaux en Java – déclaration, initialisation et le parcours d’un tableau

Les tableaux

Ils sont dérivés de la classe Object : il faut utiliser des méthodes pour y accéder dont font parti des messages de Object tel que equals() ou getClass(). Le premier élément possède l’indice 0.
La déclaration des tableaux
Java permet de placer les crochets après ou avant le nom du tableau dans la déclaration.

Exemple :
int tableau[ ] = new int[50]; // déclaration et allocation
OU int[ ] tableau = new int[50];
OU int tab[ ]; // déclaration
tab = new int[50]; //allocation

Java ne supporte pas directement les tableaux à plusieurs dimensions : il faut déclarer un tableau de tableau.
Exemple :
float tableau[][] = new float[10][10];
La taille des tableaux de la seconde dimension peut ne pas être identiques pour chaque occurrences.
Exemple :
int dim1[ ][ ] = new int[3][ ];
dim1[0] = new int[4];
dim1[1] = new int[9];
dim1[2] = new int[2];

Chaque élément du tableau est initialisé selon son type par l’instruction new : 0 pour les numériques, ‘\0′ pour les caractères, false pour les booléens et nil pour les chaines de caractères et les autres objets.
L’initialisation explicite d’un tableau
Exemple :
int tableau[5] = {10,20,30,40,50};
int tableau[3][2] = {{5,1},{6,2},{7,3}};

La taille du tableau n’est pas obligatoire si le tableau est initialisé à sa création.
Exemple :
int tableau[] = {10,20,30,40,50};
Le nombre d’élément de chaque lignes peut ne pas être identique :
Exemple :
int[ ][ ] tabEntiers = {{1,2,3,4,5,6},
{1,2,3,4},
{1,2,3,4,5,6,7,8,9}};

Le parcours d’un tableau
Exemple :
for (int i = 0; i < tableau.length ; i ++) { ... }
La variable length retourne le nombre d’éléments du tableau.
Pour passer un tableau à une méthode, il suffit de déclarer les paramètres dans l’en tête de la méthode
Exemple :
public void printArray(String texte[ ]){ ...
}

Les tableaux sont toujours transmis par référence puisque se sont des objets.
Un accès a un élément d’un tableau qui dépasse sa capacité, lève une exception du type
java.lang.arrayIndexOutOfBoundsException.

Categories
Informatique

Les structures de contrôles en Java

Les Boucles
while ( boolean )
{
... // code a éxécuter dans la boucle
}

Le code est exécuté tant que le booléen est vrai. Si avant l’instruction while, le booléen est faux, alors le code de la boucle ne sera jamais exécuté
Ne pas mettre de ; après la condition sinon le corps de la boucle ne sera jamais exécuté
do {
...
while ( boolean )

Cette boucle est au moins exécuté une fois quelque soit la valeur du booléen;
for ( initialisation; condition; modification) {
...
}

Exemple :
for (i = 0 ; i < 10; i++ ) { ....}
for (int i = 0 ; i < 10; i++ ) { ....}
for ( ; ; ) { ... } // boucle infinie

L’initialisation, la condition et la modification de l’index sont optionels.
Dans l’initialisation, on peut déclarer une variable qui servira d’index et qui sera dans ce cas locale à la boucle.
Il est possible d’inclure plusieurs traitements dans l’initialisation et la modification de la boucle : chacun des traitements doit etre séparé par une virgule.
Exemple :
for (i = 0 , j = 0 ; i * j < 1000;i++ , j+= 2) { ....}
La condition peut ne pas porter sur l’index de la boucle :
Exemple :
boolean trouve = false;
for (int i = 0 ; !trouve ; i++ ) {
if ( tableau[i] == 1 )
trouve = true;... //gestion de la fin du parcours du tableau
}

Il est possible de nommer une boucle pour permettre de l’interrompre même si cela est peu recommendé :
Exemple :
int compteur = 0;
boucle:
while (compteur < 100) {
for(int compte = 0 ; compte < 10 ; compte ++) {
compteur += compte;
System.out.println("compteur = "+compteur);
if (compteur> 40) break boucle;
}
}

Les branchements conditionnels
if (boolean) {
...
} else if (boolean) {
...
} else {
...

}
swith (expression) {
case constante1 :
instr11;
instr12;
break;
case constante2 :
...
default :
...
}

On ne peut utiliser switch qu’avec des types primitifs d’une taille maximum de 32 bits (byte, short, int, char).
Si une instruction case ne contient pas de break alors les traitements associés au case suivant sont éxécutés.
Il est possible d’imbriquer des switch
L’opérateur ternaire : ( condition ) ? valeur−vrai : valeur−faux
Exemple :
if (niveau == 5) // equivalent à total = (niveau ==5) ? 10 : 5;
total = 10;
else total = 5 ;
System.out.println((sexe == « H ») ? « Mr » : « Mme »);

Les débranchements
break : permet de quitter immédiatement une boucle ou un branchement. Utilisable dans tous les controles de flot
continue : s’utilise dans une boucle pour passer directement à l’itération suivante
break et continue peuvent s’excuter avec des blocs nommés. Il est possible de préciser une étiquette pour indiquer le point de retour lors de la fin du traitement déclenché par le break.
Une étiquette est un nom suivi d’un deux points qui définit le début d’une instruction.

 

Categories
Informatique

La priorité des opérateurs en Java

Java définit les priorités dans les opérateurs comme suit ( du plus prioriotaire au moins prioritaire )

les parenthèses ( )
les opérateurs d’incrémentation ++
−−
les opérateurs de multiplication, division, et modulo *
/
%
les opérateurs d’addition et soustraction +
les opérateurs de décalage <<
>>
les opérateurs de comparaison <
>
<=
>=
les opérateurs d’égalité ==
!=
l’opérateur OU exclusif ^
l’opérateur ET &
l’opérateur OU |
l’opérateur ET logique &&
l’opérateur OU logique ||
les opérateurs d’assignement =
+=
−=

Les parenthèses ayant une forte priorité, l’ordre d’interprétation des opérateurs peut être modifié par des parenthèses.

Categories
Informatique

L’incrémentation et la décrémentation en java

Les opérateurs d’incrémentation et de décrémentation en java sont : n++ ++n n−− −−n
Si l’opérateur est placé avant la variable (préfixé), la modification de la valeur est immédiate sinon la modification n’a lieu qu’à l’issu de l’exécution de la ligne d’instruction (postfixé)
L’opérateur ++ renvoie la valeur avant incrémentation s’il est postfixé, après incrémentation s’il est préfixé.
Exemple :
System.out.println(x++); // est équivalent à
System.out.println(x); x = x + 1;
System.out.println(++x); // est équivalent à
x = x + 1; System.out.println(x);

Exemple :
/* test sur les incrementations prefixees et postfixees */
class test4 {
public static void main (String args[]) {
int n1=0;
int n2=0;
System.out.println("n1 = " + n1 + " n2 = " + n2);
n1=n2++;
System.out.println("n1 = " + n1 + " n2 = " + n2);
n1=++n2;
System.out.println("n1 = " + n1 + " n2 = " + n2);
n1=n1++; //attention
System.out.println("n1 = " + n1 + " n2 = " + n2);
}
}

Résultat :
int n1=0;
int n2=0; // n1=0 n2=0
n1=n2++; // n1=0 n2=1
n1=++n2; // n1=2 n2=2
n1=n1++; // attention : n1 ne change pas de valeur

 

Categories
Informatique

Les opérations arithmétiques en Java

Les opérateurs arithmétiques se notent + (addition), − (soustraction), * (multiplication), / (division) et % (reste de la division). Ils peuvent se combiner à l’opérateur d’affectation
Exemple :
nombre += 10;
L’arithmétique entière
Pour les types numériques entiers, Java met en oeuvre une sorte de mécanisme de conversion implicite vers le type int appelée promotion entière. Ce mécanisme fait partie des règles mise en place pour renforcer la sécurité du code.
Exemple :
short x= 5 , y = 15;
x = x + y ; //erreur à la compilation< Incompatible type for =. Explicit cast needed to convert int to short. x = x + y ; //erreur à la compilation ^ 1 error 

Les opérandes et le résultat de l'opération sont convertis en type int. Le résultat est affecté dans un type short : il y a donc risque de perte d'informations et donc erreur à la compilation est émise. Cette promotion évite un débordement de capacité sans que le programmeur soit pleinement conscient du risque : il est nécessaire, pour régler le problème, d'utiliser une conversion explicite ou cast
Exemple :
x = (short) ( x + y );
Il est nécessaire de mettre l'opération entre parenthèse pour que ce soit son résultat qui soit converti car le cast a une priorité plus forte que les opérateurs arithmétiques.
La division par zéro pour les types entiers lève l'exception ArithmeticException
Exemple :
/* test sur la division par zero de nombres entiers */
class test3 {
public static void main (String args[]) {
int valeur=10;
double résultat = valeur / 0;
System.out.println("index = " + résultat);
}
}

L'arithmétique en virgule flottante
Avec des valeurs float ou double, la division par zéro ne produit pas d'exception mais le résultat est indiqué par une valeur spéciale qui peut prendre trois états :

•indéfini : Float.NaN ou Double.NaN (not a number)
•indéfini positif : Float.POSITIVE_INFINITY ou Double.POSITIVE_INFINITY, +∞
• indéfini négatif : Float.NEGATIVE_INFINITY ou Double.NEGATIVE_INFINITY, +∞

Conformément à la norme IEEE754, ces valeurs spéciales représentent le résultat d'une expression invalide NaN, une valeur supérieure au plafond du type pour infini positif ou négatif.

X Y X/Y X % Y
valeur finie 0 +∞ NaN
valeur finie +/−∞ 0 X
0 0 NaN NaN
+/−∞ valeur finie +/−∞ NaN
+/−∞ +/−∞ NaN NaN

Exemple :
/* test sur la division par zero de nombres flottants */
class test2 {
public static void main (String args[]) {
float valeur=10f;
double résultat = valeur / 0;
System.out.println("index = " + résultat);
}
}

Categories
Informatique

La déclaration et l’utilisation de variables JAVA

La déclaration de variables
Une variable possède un nom, un type et une valeur. La déclaration d’une variable doit donc contenir deux choses : un nom et le type de données qu’elle peut contenir. Une variable est utilisable dans le bloc ou elle est définie.
La déclaration d’une variable permet de réserver la mémoire pour en stocker la valeur.
Le type d’une variable peut être un type élémentaire ou un objet :
type_élémentaire variable;
classe variable ;

Exemple :
long nombre;

Rappel : les noms de variables en Java peuvent commencer par un lettre, par le caractère de soulignement ou par le signe dollars. Le reste du nom peut comporter des lettres ou des nombres mais jamais d’espaces.
Il est possible de définir plusieurs variables de même type en séparant chacune d’elles par une virgule.

Exemple :
int jour, mois, annee ;

Java est un langage à typage rigoureux qui ne possède pas de transtypage automatique lorsque ce transtypage risque de conduire à une perte d’information.
Pour les objets, il est nécessaire en plus de la déclaration de la variable de créer un objet avant de pouvoir l’utiliser. Il faut réserver de la mémoire pour la création d’un objet ( remarque : un tableau est un objet en java ) avec l’instruction new. La libération de la mémoire se fait automatiquement grâce au garbage collector.

Exemple :
MaClasse instance; // déclaration de l'objet
instance = new maClasse(); // création de l'objet
OU MaClasse instance = new MaClasse(); // déclaration et création de l'objet

 

Exemple :
int[] nombre = new int[10];

Il est possible en une seule instruction de faire la déclaration et l’affectation d’une valeur à une variable ou plusieurs variables.

Exemple :
int i=3 , j=4 ;

Les types élémentaires
Les types élémentaires ont une taille identique quelque soit la plate−forme d’exécution : c’est un des  éléments qui permet à java d’être indépendant de la plate−forme sur lequel le code s’exécute.

Type Désignation Longueur Valeurs Commentaires
boolean valeur logique : true ou false 8 bits True ou false pas de conversion possible vers un
autre type
byte octet signé 8 bits −128 à 127
short entier court signé 16 bits −32768 à 32767
char caractère Unicode 16 bits \u0000 à \uFFFF entouré de cotes simples dans un
programme Java
int entier signé 32 bits −2147483648 à
2147483647
float virgule flottante simple
précision (IEEE754)
32 bits 1.401e−045 à
3.40282e+038
double virgule flottante double
précision (IEEE754)
64 bits 2.22507e−308 à
1.79769e+308
long entier long 64 bits −9223372036854775808 à
9223372036854775807

Les types élémentaires commencent tous par une minuscule.
Le format des types élémentaires
Le format des nombres entiers :
Les types byte, short, int et long peuvent être codés en décimal, hexadécimal ou octal. Pour un nombre hexadécimal, il suffit de préfixer sa valeur par 0x. Pour un nombre octal, le nombre doit commencer par un zéro. Le suffixe l ou L permet de spécifier que c’est un entier long.
Le format des nombres décimaux :
Les types float et double stockent des nombres flottants : pour être reconnus comme tel ils doivent posséder soit un point, un exposant ou l’un des suffixes f, F, d, D. Il est possible de préciser des nombres qui n’ont pas le partie entière ou décimale.

Exemple :
float pi = 3.141f;
double v = 3d
float f = +.1f , d = 1e10f;

Par défaut un littéral est de type double : pour définir un float il faut le suffixer par la lettre f ou F.

Exemple :
double w = 1.1;

Attention : float pi = 3.141; // erreur à la compilation
Le format des caractères :
Un caractère est codé sur 16 bis car il est conforme à la norme Unicode. Il doit être entouré par des apostrophes. Une valeur de type char peut être considérée comme un entier non négatif de 0 à 65535. Cependant la conversion implicite par affectation n’est pas possible.

Exemple :
/* test sur les caractères */
class test1 {
public static void main (String args[]) {
char code = 'D';
int index = code − 'A';
System.out.println("index = " + index);
}
}

L’initialisation des variables

Exemple :
int nombre; // déclaration
nombre = 100; //initialisation
OU int nombre = 100; //déclaration et initialisation

En java, toute variable appartenant à un objet (définie comme étant un attribut de l’objet) est initialisée avec une valeur par défaut en accord avec son type au moment de la creation. Cette initialisation ne s’applique pas aux variables locales des méthodes de la classe.
Les valeurs par défaut lors de l’initialisation automatique des variables d’instances sont :

Type Valeur par défaut
boolean false
byte, short, int, long 0
float, double 0.0
char \u000

Remarque : Dans une applet, il est préférable de faire les déclarations et initialisation dans la méthode init().
L’affectation
le signe = est l’opérateur d’affectation et s’utilise avec une expression de la forme variable = expression. L’opération d’affectation est associatif de droite à gauche : il renvoie la valeur affectée ce qui permet d’écrire :
x = y = z = 0;
Il existe des opérateurs qui permettent de simplifier l’écritures d’une opération d’affectation associée à un opérateur mathématique :

Opérateur Exemple Signification
= a=10 équivalent à : a = 10
+= A+=10 équivalent à : a = a + 10
-= a-= équivalent à : a = a − 10
*= A*= équivalent à : a = a * 10
/= a/=10 équivalent à : a = a / 10
%= A%=10 reste de la division
^= a^=10 équivalent à : a = a ^ 10
<<= A<<=10 équivalent à : a = a << 10 a est complété par des zéros à droite
>>= a>>=10 équivalent à : a = a >> 10 a est complété par des zéros à gauche
>>>= a>>>=10 équivalent à : a = a >>> 10 décalage à gauche non signé

Attention : Lors d’une opération sur des opérandes de type différents, le compilateur détermine le type du résultat en prenant le type le plus précis des opérandes. Par exemple, une multiplication d’une variable de type float avec une variable de type double donne un résultat de type double. Lors d’une opération entre un opérande entier et un flottant, le résultat est du type de l’opérande flottant.
Les comparaisons
Java propose des opérateurs pour toutes les comparaisons :

Opérateur Exemple Signification
> a > 10 strictement supérieur
< a < 10 strictement inférieur
>= a >= 10 supérieur ou égal
<= a <= 10 inférieur ou égal
== a == 10 Egalité
!= a != 10 diffèrent de
& a & b ET binaire
^ a ^ b OU exclusif binaire
| a | b OU binaire
&& a && b ET logique (pour expressions booléennes) : l’évaluation de l’expression
cesse dès qu’elle devient fausse
|| a || b OU logique (pour expressions booléennes) : l’évaluation de
l’expression cesse dès qu’elle devient vraie
? : a ? b : c opérateur conditionnel : renvoie la valeur b ou c selon l’évaluation de
l’expression a (si a alors b sinon c) : b et c doivent retourner le même
type

Les opérateurs sont exécutés dans l’ordre suivant à l’intérieure d’une expression qui est analysée de gauche à droite:
•incréments et décréments
•multiplication, division et reste de division (modulo)
•addition et soustraction
•comparaison
•le signe = d’affectation d’une valeur à une variable
L’usage des parenthèse permet de modifier cet ordre de priorité.

Categories
Informatique

Les Commentaires Java, Comment bien Commenter son code?

Les commentaires permettent d’insérer du texte qui ne sera pas compilé ni interprété avec le reste du code. Il sert à ajouter du texte au code source. Il est utile pour expliquer ce que fait le code sourcepas plus.

Séparons une fois pour toute l’expression documenter de commenter.
Documenter, c’est fournir la description de son application, de tous ses points d’accès publics et de ses dépendances. La documentation s’occupe de décrire l’objet tel qu’il est utilisable par l’utilisateur.

Commenter, c’est décrire l’implémentation d’un objet, d’une méthode, d’une propriété, ou de toute variable spéciale d’une classe et de ses membres, quand la nécessité ou le besoin de confort l’exigent.
Les Commentaires ne sont pas pris en compte par le compilateur donc ils ne sont pas inclus dans le pseudo code. Ils ne se terminent pas
par un ;.
Il existe trois type de commentaire en Java :

Type de commentaires Exemple
commentaire abrégé // commentaire sur une seule ligne
int N=1; // déclaration du compteur
commentaire multiligne /* commentaires ligne 1
commentaires ligne 2 */
commentaire de documentation automatique /** commentaire */

 

Categories
Informatique

Les identificateurs Java

Chaque objet, classe, programme ou variable est associer à un nom : l’identificateur java qui peut se composer de tous les caractères alphanumériques et des caractères _ et $. Le premier caractère doit être une lettre, le caractère de soulignement ou le signe dollars.
Un identificateur java est un nom qui permet d’identifier une classe, une variable ou une méthode dans un programme. Il doit être valide, c’est-à-dire composé seulement de caractères Unicode.
Rappel : Java est sensible à la casse.

  • Un identificateur java doit commencer soit par une lettre, le symbole “$“, ou un caractère de soulignement “_“.
  • Il ne doit pas commencer par un chiffre.
  • Après le premier caractère, il peut contenir n’importe quelle combinaison de lettres, dollar “$“, caractère de soulignement “_“, ou des chiffres.
  • Dans la pratique, il n’y a pas de limite au nombre de caractères qu’un identificateur java peut contenir.
  • Les identificateurs en Java sont sensibles à la casse, supinfo et SUPINFO sont deux identificateurs différents.
  • Vous ne pouvez pas utiliser un mot-clé comme un identifiant dans vos programmes. Voici ci-dessous la liste complète des mots-clés disponibles.