Types primitifs, tableaux et
chaines de caractères (en Java)
1. Types primitifs,
2. tableaux
3. chaines de caractères
DR. YOUSSEF ELMIR ELMIR@[Link]
1. Types primitifs
2
Une variable de type primitif représente juste une
valeur stockée dans un espace mémoire dont la taille
dépend du type.
l’espace mémoire occupé par un primitif est fixé par
la spécification du langage et non par la machine
cible.
1. Types primitifs
3
Taille mémoire
Type Espace mémoire Signé
boolean indéterminé non
char 2 octets (16 bits) non
int 4 octets (32 bits) oui
byte 1 octet (8 bits) oui
short 2 octets (16 bits) oui
long 8 octets (64 bits) oui
float 4 octets (32 bits IEEE 754 floating point) oui
double 8 octets (64 bits IEEE 754 floating point) oui
1. Types primitifs
4
Le type booléen : boolean
Les variables de type booléen ne peuvent prendre que deux valeurs
: true ou false.
• Par défaut, un attribut de type boolean vaut false.
On ne peut utiliser que des opérateurs booléens
comme ==, != et ! sur des variables de type booléen (pas
d’opération arithmétique autorisée).
1. Types primitifs
5
Le type caractère : char
Les variables de type char sont codées sur 2 octets non signés car la
représentation interne des caractères est l’UTF-16. Cela signifie que la
valeur va de 0 à 2^16 - 1.
Par défaut, un attribut de type char vaut 0.
Pour représenter un littéral, on utilise l’apostrophe (simple quote) :
char c = 'a';
1. Types primitifs
6
Le type caractère : char
Même si les caractères ne sont pas des nombres, Java autorise les
opérations arithmétiques sur les caractères en se basant sur le
code caractère.
• Cela peut être pratique si l’on veut parcourir l’alphabet par exemple :
for (char i = 'a'; i <= 'z'; ++i) { // ... }
1. Types primitifs
7
Le type caractère : char
On peut également affecter un nombre à une variable caractère. Ce
nombre représente alors le code caractère :
char a = 97; // 97 est le code caractère de la lettre a en UTF-16
1. Types primitifs
8
Les types entiers : byte, short, int, long
Les types entiers différent entre-eux uniquement par l’espace de
stockage mémoire qui leur est alloué.
• Ils sont tous des types signés. Par défaut, un attribut de type byte,
short, int ou long vaut 0.
byte b = 1;
short s = 2;
int i = 3;
long l = 4;
1. Types primitifs
9
Les types entiers : byte, short, int, long
La règle de conversion implicite est simple : on peut affecter une variable d’un type
à une variable d’un autre type que si la taille mémoire est au moins assez grande.
s = b;
i = s;
i = b;
l = b;
l = s;
l = i;
Dans tous les autres cas, il faut réaliser un transtypage avec un risque de perte
de valeur :
b = (byte) s;
s = (short) i;
i = (int) l;
1. Types primitifs
10
Les types entiers : byte, short, int, long
Lorsqu’on affecte une valeur littérale à une variable, le
compilateur contrôlera que la valeur est acceptable pour ce type :
byte b = 0;
b = 127; // ok
b = 128; // ko car le type byte accepte des valeurs entre -128 et 127
1. Types primitifs
11
Les types entiers : byte, short, int, long
Exemples
2
(binaire) : 0b0010 ou 0B0010
8 (octal) : 0174
10 (décimal) : 129
16 (hexadécimal) : 0x12af ou 0X12AF
On peut forcer une valeur littérale à être interprétée comme un entier long en
suffixant la valeur par L ou l :
long l = 100L;
Pour plus de lisibilité, il est également possible de séparer les milliers par _ :
long l = 1_000_000;
1. Types primitifs
12
Les types à virgule flottante : float, double
Les types float et double permettent de représenter les nombres à virgule.
• Par défaut, un attribut de type float ou double vaut 0.
float est dit en simple précision et est codé sur 4 octets (32 bits) tandis
que double est dit en double précision et est codé sur 8 octets (64 bits).
Il est possible d’ajouter une valeur entière à un type à virgule flottante mais
l’inverse nécessite une transtypage (cast) avec une perte éventuelle de valeur.
int i = 2;
double d = 5.0;
d = d + i;
i = (int) (d + i);
1. Types primitifs
13
Les valeurs littérales peuvent s’écrire avec un . pour signifier
la virgule et/ou avec une notation scientifique en donnant
l’exposant en base 10 :
double d1 = .0; // le 0 peut être omis à gauche de la virgule
double d2 = -1.5;
double d3 = 1.5E1; // 1.5 * 10, c'est-à-dire 15.0
double d4 = 0.1234E-15;
Une valeur littérale est toujours considérée en double
précision. Pour l’affecter à une variable de type float, il faut
suffixer la valeur par F ou f :
float f = 0.5f;
1. Types primitifs
14
Les classes enveloppes
Type Classe associée
boolean [Link]
char [Link]
int [Link]
byte [Link]
short [Link]
long [Link]
float [Link]
double [Link]
1. Types primitifs
15
Il est possible de créer une instance d’une classe
enveloppe soit en utilisant son constructeur soit en
utilisant la méthode de classe valueOf (il s’agit de la
méthode recommandée).
Integer i = [Link](2);
Pour obtenir la valeur enveloppée, on fait appel à la
méthode xxxValue(), xxx étant le type sous-jacent :
Integer i = [Link](2); int x = 1 + [Link]();
1. Types primitifs
16
Pourquoi avoir créé ces classes ? Cela permet d’offrir un
emplacement facile à mémoriser à des méthodes utilitaires.
Par exemple, toutes les classes enveloppes définissent une
méthode de classe de la forme parseXXX qui permet de
convertir une chaîne de caractères en un type primitif :
boolean b = [Link]("true");
byte by = [Link]("1");
short s = [Link]("1");
int i = [Link]("1");
long l = [Link]("1");
float f = [Link]("1");
double d = [Link]("1"); // enfin presque toutes car Character
n'a pas cette méthode
1. Types primitifs
17
Une variable de type d’une des classes enveloppes
référence un objet donc elle peut avoir la valeur
spéciale null.
Ce cas permet de signifier l’absence de valeur.
1. Types primitifs
18
L’autoboxing
Il n’est pas rare dans une application Java de devoir convertir des
types primitifs vers des instances de leur classe enveloppe et
réciproquement.
Afin d’alléger la syntaxe, on peut se contenter d’affecter une
variable à une autre et le compilateur se chargera d’ajouter le code
manquant.
1. Types primitifs
19
L’autoboxing
L’opération qui permet de passer d’un type primitif à
une instance de sa classe enveloppe s’appelle
le boxing et l’opération inverse
s’appelle l’unboxing.
1. Types primitifs
20
L’autoboxing
Integer i = 1; -> Integer i = [Link](1); // boxing
Integer i = 1; int j = i; ->
Integer i = [Link](1); // boxing
int j = [Link](); // unboxing
On peut ainsi réaliser des opérations arithmétiques sur des
instances de classes enveloppes
Integer i = 1; Integer j = 2; Integer k = i + j;