Types entiers

L'interprétation non signée (unsigned) consiste à interpréter un vecteur de bits comme un nombre exprimé en base 2. Dans ce cas, la valeur \(n\) de l'entier représenté par le vecteur de \(N\) bits \(b_{N-1}b_{N-2}\ldots b_{1}b_{0}\) est donnée par la formule suivante :

\[ n = \sum_{i=0}^{N-1} b_i\cdot 2^i \]

Par exemple, le vecteur de \(N=8\) bits 10001100 est interprété comme l'entier 140 :

Dans un vecteur de bits interprété comme un entier, tous les bits n'ont pas la même importance :

• le bit le plus à droite (\(b_0\)) vaut 1 s'il est à 1, 0 sinon,
• le second bit depuis la droite (\(b_1\)) vaut 2 s'il est à 1, 0 sinon,
• le troisième bit depuis la droite (\(b_2\)) vaut 4 s'il est à 1, 0 sinon,
• etc.

De manière générale, le bit à la position n vaut 2ⁿ s'il est à 1, 0 sinon. Pour cette raison, le bit le plus à gauche est dit bit de poids (le plus) fort (most-significant bit, ou MSB) tandis que le bit le plus à droite est dit bit de poids (le plus) faible (least-significant bit ou LSB).

L'interprétation non signée a l'inconvénient de ne pas permettre la représentation de valeurs négatives. Pour cette raison, elle n'est utilisée en Java que pour les valeurs de type char, qui sont toutes positives pour les raisons évoquées plus haut. Les valeurs des quatre autres types entiers sont quant à elles interprétées en complément à deux, comme décrit ci-après.

L'interprétation (signée) en complément à deux (two's complement) est similaire à l'interprétation non signée, la seule différence étant que le poids de bit de poids le plus fort a un signe négatif. Ainsi, dans cette interprétation, la valeur \(n\) de l'entier représenté par le vecteur de \(N\) bits \(b_{N-1}b_{N-2}\ldots b_{1}b_{0}\) est donnée par la formule suivante :

\[ n = -b_{N-1}\cdot 2^{N-1} + \sum_{i=0}^{N-2} b_i\cdot 2^i \]

Par exemple, le vecteur de \(N=8\) bits 10001100 présenté plus haut est interprété en complément à deux comme l'entier –116 :

Le complément à deux a plusieurs propriétés importantes :

1. le bit de poids fort donne le signe de la valeur : s'il vaut 0, elle est positive ou nulle, s'il vaut 1, elle est négative,
2. un vecteur de n bits peut représenter :
   • 2^n-1 – 1 valeurs strictement positives,
   • 2^n-1 valeurs strictement négatives, et
   • zéro (qui n'a qu'une représentation).

Il est important de comprendre que la notion de signe n'est qu'une question d'interprétation. C'est-à-dire qu'un vecteur de bits donné peut être interprété soit comme une valeur non signée (c-à-d non négative), soit comme une valeur signée en complément à deux.

En Java, les valeurs de tous les types entiers sauf char sont interprétées comme des valeurs signées en complément à deux, tandis que les valeurs de type char sont interprétées comme non signées. Ainsi, un vecteur de 16 bits valant tous 1 est interprété comme l'entier -1 si on lui donne le type short, mais comme l'entier 65'535 (2¹⁶ – 1) si on lui donne le type char, comme l'illustre le programme ci-dessous :

short s = (short)0b11111111_11111111;
char c  = (char) 0b11111111_11111111;
System.out.println((int)s);     // affiche -1
System.out.println((int)c);     // affiche 65535

(La notation 0b11…11 utilisées aux deux premières lignes représente une constante entière donnée en base 2, et est décrite en détail à la section suivante.)

En résumé, les types short et char font tous les deux 16 bits, la seule différence entre les deux étant la manière dont ces bits sont interprétés.

L'inversion ou complément parallèle ou bit à bit (bitwise complement), noté ~, inverse chaque bit de son opérande.

Par exemple, ~0b11110000 vaut 0b00001111.

Etant donné que les valeurs négatives sont représentées au moyen du complément à deux, l'inversion et la négation sont liées par l'égalité suivante, valable pour toute valeur x d'un type entier, char excepté :

-x == ~x + 1

Les opérateurs binaires parallèles ou bit à bit (binary bitwise operators) &, | et ^ appliquent la même opération à chacun des bits de leurs opérandes. Ces opérations sont définies par les tables ci-dessous.

Par exemple, appliquées aux opérandes 11110000 et 00111100, ces trois opérations produisent les résultats illustrés dans la figure suivante.

La valeur de l'expression x << y est obtenue par décalage vers la gauche, de y positions, des bits de x.

Par exemple, 0b00001100 << 3 vaut 0b01100000, car tous les bits de la première opérande sont décalés de 3 positions sur la gauche, les trois de poids fort sont perdus, et trois bits nuls sont insérés à droite. Cela est illustré sur la figure ci-dessous.

Attention : seuls les 5 (respectivement 6) bits de poids faible de la seconde opérande sont pris en compte pour déterminer l'amplitude du décalage lors du décalage d'une valeur de type int (respectivement long).

Les deux opérateurs de décalage à droite, >> et >>>, sont similaires à celui de décalage à gauche, mais travaillent dans la direction opposée.

Le décalage dit arithmétique, noté >>, copie le bit de poids fort dans toutes les positions laissées libres par le décalage. Le décalage dit logique, noté >>>, insère quant à lui des bits nuls, comme l'opérateur de décalage à gauche.

Les deux opérateurs de décalage à droite ne diffèrent que pour les valeurs dont le bit de poids fort vaut 1, c-à-d les valeurs représentant des entiers négatifs. Pour de telles valeurs, le décalage arithmétique préserve le signe et produit donc une valeur négative, tandis que le décalage logique produit une valeur positive pour tout décalage d'amplitude non nulle.

Un décalage à gauche de n bits est équivalent à une multiplication par 2ⁿ, pour la même raison que, en base 10, un décalage à gauche de n positions des chiffres d'un nombre est équivalent à une multiplication par 10ⁿ :

x << n == x * pow(2, n)

où pow(2, n) représente 2ⁿ.

Un décalage à droite de n bits est équivalent à une division entière par 2ⁿ, pour les valeurs non négatives seulement :

x >> n == x / pow(2, n)         // (si x ≥ 0)

Pour les valeurs négatives, les deux expressions diffèrent d'une unité dans certains cas.

Certaines constructions impliquant les opérateurs bit à bit sont fréquemment utiles, et il est donc bon de les connaître. Les plus importantes d'entre elles sont présentées ci-après.

Chaque classe d'entiers fournit des attributs statiques donnant des informations quant à la taille du type entier correspondant :

• MIN_VALUE et MAX_VALUE donnent respectivement la plus petite et la plus grande valeur représentable par le type entier,
• SIZE donne la taille, en bits, du type entier,
• BYTES donne la taille, en octets (groupe de 8 bits), du type entier.

Les attributs SIZE et BYTES dépendent bien entendu l'un de l'autre, SIZE valant toujours huit fois BYTES.

Par exemple, Byte.MIN_VALUE vaut –128, Byte.MAX_VALUE vaut 127, Byte.SIZE vaut 8 et Byte.BYTES vaut 1.

Les classes Integer et Long offrent deux variantes d'une méthode statique permettant de convertir un entier en chaîne de caractères. Par exemple, Integer offre :

• String toString(int i, int b) : retourne la chaîne représentant l'entier i en base b (où 2 ≤ b ≤ 36),
• String toString(int i) : idem pour la base 10.

Les classes Byte et Short offrent uniquement la seconde variante.

Chaque classe d'entiers offre deux variantes d'une méthode statique permettant de transformer une chaîne en l'entier signé correspondant. Par exemple, Integer offre :

• int parseInt(String s, int b) : retourne l'entier dont la représentation en base b (où 2 ≤ b ≤ 36) est la chaîne s, ou lève une exception si la chaîne est invalide ;
• int parseInt(String s) : idem pour la base 10.

Les classes Byte, Short et Long offrent des méthodes similaires, nommées respectivement parseByte, parseShort et parseLong.

Integer et Long offrent des méthodes statiques permettant de compter certains types de bits. Par exemple, Integer offre :

• int bitCount(int i) : retourne le nombre de bits à 1 dans i ;
• int numberOfLeadingZeros(int i) : retourne le nombre de bits à 0 en tête (à gauche) de i ;
• int numberOfTrailingZeros(int i) : retourne le nombre de bits à 0 en queue (à droite) de i.

Les méthodes de Long sont identiques mais prennent un argument de type long.

Integer et Long offrent des méthodes statiques permettant de déterminer la position de certains bits. Par exemple, Integer offre :

• int lowestOneBit(int i) : retourne 0 si i vaut 0, ou une valeur ayant un seul bit à 1, dont la position est celle du bit à 1 de poids de plus faible de i,
• int highestOneBit(int i) : idem, mais pour le bit de poids le plus fort.

Ainsi :

• Integer. lowestOneBit(0b1110) == 0b0010
• Integer.highestOneBit(0b1110) == 0b1000

Les classes Integer et Long offrent chacune des méthodes statique permettant d'effectuer une rotation des bits. Par exemple, Integer offre :

• int rotateLeft(int i, int d) : retourne l'entier obtenu par rotation des bits de i de d positions vers la gauche ;
• int rotateRight(int i, int d) : idem, mais vers la droite.

Une rotation est similaire à un décalage, mais les bits qui sont éjectés d'un côté sont réinjectés de l'autre.

Les classes Integer et Long offrent des méthodes statiques permettant d'inverser l'ordre des bits ou des octets d'un entier. Par exemple, Integer offre :

• int reverse(int i) : retourne l'entier obtenu en inversant l'ordre des bits de i ;
• int reverseBytes(int i) : retourne l'entier obtenu en inversant l'ordre des octets de i.

Short offre également reverseBytes.

En informatique, une couleur est souvent représentée par ses trois composantes rouge, verte et bleue, chacune étant — conceptuellement — un nombre réel compris entre 0 et 1 (inclus).

La manière la plus naturelle de représenter une telle couleur en Java consiste à créer une classe dotée de trois champs de type double (ou float). Bien que naturelle, cette représentation est coûteuse en espace : sachant qu'une valeur de type double fait 8 octets (64 bits), chaque couleur nécessite au moins 3×8 = 24 octets (192 bits), ou la moitié si le type float est utilisé.

Une manière plus compacte, mais moins précise, de représenter une couleur consiste à représenter chacune de ses composantes par un entier de 8 bits — compris entre 0 et 255 — puis à les empaqueter dans un entier de 32 bits. Les 8 bits restants sont soit inutilisés, soit utilisés pour stocker l'opacité de la couleur. De la sorte, une couleur occupe exactement 32 bits au lieu de 192 dans la représentation précédente, un gain appréciable.

Les composantes d'une couleur peuvent être empaquetées de nombreuses manières. Dans ce qui suit, la composante bleue est placée dans les huit bits de poids faible, suivie de la verte puis la rouge. Cette technique d'empaquetage est souvent désignée par l'acronyme RGB.

La notation hexadécimale convient assez bien pour écrire directement des couleurs empaquetées de la sorte, car chaque composante occupe exactement deux chiffres hexadécimaux (8 bits). Par exemple 0xFF_00_00 représente un rouge pur (1,0,0).

Le passage d'une couleur exprimée sous la forme de trois composantes réelles comprises entre 0 et 1 à une couleur empaquetée RGB se fait en combinant décalages et « ou » parallèle :

double r = …, g = …, b = …;
int r0 = (int)(r * 255.9999); // 0 ≤ r0 ≤ 255
int g0 = (int)(g * 255.9999); // 0 ≤ g0 ≤ 255
int b0 = (int)(b * 255.9999); // 0 ≤ b0 ≤ 255
int rgb = (r0 << 16) | (g0 << 8) | b0;

Une composante quelconque d'une couleur empaquetée peut être extraite en combinant un décalage avec un masquage. Par exemple, la composante verte peut être obtenue par un décalage à droite de 8 bits suivi d'un masquage pour ne garder que les 8 bits de poids faible :

int rgb = …;
int g0 = (rgb >> 8) & 0xFF;

Cette valeur entière, comprise entre 0 et 255, peut être ramenée à l'intervalle [0;1] par une simple division :

double g = (double)g0 / 255d;