FAQ Langage JavaConsultez toutes les FAQ

Il est possible de représenter un nombre en Java en utilisant un des types numériques primitifs suivants : byte, char, short, int, long, float et double. Ces types sont directement pris en charge par le langage en tant que type de base ; ce sont donc les types numériques que vous utiliserez le plus souvent. Par exemple :

1
2
int a = 3; 
double b = 0.5;

1
2
Integer a = new Integer(2); 
Double b = new Double(0.5);

1
2
Integer a = 2; 
Double b = 0.5;

• byte (classe wrapper java.lang.Byte) - des octets : des nombres entiers signés sur 8 bits ;
• char (classe wrapper java.lang.Character) - des caractères : des symboles pour écrire du texte, mais également des nombres entiers non signés sur 16 bits ;
• short (classe wrapper java.lang.Short) - des entiers courts : des nombres entiers signés sur 16 bits ;
• int (classe wrapper java.lang.Integer) - des entiers normaux ou mots : des nombres entiers signés sur 32 bits.
• long (classe wrapper java.lang.Long) - des entiers longs : des nombres entiers signés sur 64 bits.
• java.math.BigInteger - des nombres entiers signés à précision arbitraire.
  

• float (classe wrapper java.lang.Float) - des nombres flottants simple précision : des nombres à virgule flottante signés sur 32 bits ;
• double (classe wrapper java.lang.Double) - des nombres flottants double précision : des nombres à virgule flottante signés sur 64 bits ;
• java.math.BigDecimal - des nombres à virgule flottante signés à précision arbitraire.
  

Les limites et capacités des différents types de nombres sont définies dans les spécifications du langage Java. Ainsi, ces spécifications demeurent identiques que vous ayez une JVM 32 bitsou 64 bits. Par exemple, contrairement à d'autres langages ou compilateur, en Java un int fait toujours 32 bits et définit toujours un nombre entier signé.

Nombres entiers
Au niveau de la capacité : byte < char et short < int < long.

De manière générale, il vous suffit d’écrire une variable du type approprié et de lui affecter une valeur numérique.

Le compilateur acceptera n'importe quelle valeur tant que cette dernière entre dans la limite des valeurs supportées par ce type. Une erreur sera générée si la valeur dépasse la capacité du type utilisé et un cast sera requis pour être capable de compiler ; la valeur ainsi obtenue sera tronquée pour pouvoir être stockée dans le type choisi.

Il est également possible d'utiliser le caractère _ pour effectuer des groupements de chiffres.

Octets (byte)

1
2
3
4
5
byte b0 = 1; 
byte b1 = -128; 
byte b2 = 127; 
byte b3 = 1_00; // Fonctionne sans problème. 
byte b4 = 500; // Erreur, dépassement de capacité.

1
2
3
4
5
6
short s0 = 1; 
short s1 = -32768; 
short s2 = 32767; 
short s3 = 32_767; // Fonctionne sans problème. 
short s4 = 3_27_67; // Fonctionne sans problème. 
short s5 = 1000000; // Erreur, dépassement de capacité.

1
2
3
4
int s0 = 1; 
int s1 = -1000000; 
int s2 = 1000000; 
int s3 = 1_000_000; // Fonctionne sans problème.

1
2
3
4
5
6
long l0 = 1; 
long l2 = 1000000; // Inférieur à la capacité d'un entier. 
long l1 = -10000000000l; // Supérieur à la capacité d'un entier. 
long l3 = 10000000000l; // Supérieur à la capacité d'un entier. 
long l4 = 10000000000L; // Supérieur à la capacité d'un entier. 
long l5 = 10_000_000_000L;  // Fonctionne sans problème.

Il est possible de déclarer nativement des nombres entiers en octal directement dans le code source Java. La valeur octale du nombre doit être préfixée par la valeur 0 et ne peut contenir que les caractères [0-7] et le caractère - pour les valeurs négatives.

Le compilateur acceptera n'importe quelle valeur tant que cette dernière entre dans la limite des valeurs supportées par ce type. Une erreur sera générée si la valeur dépasse la capacité du type utilisé et un cast sera requis pour être capable de compiler ; la valeur ainsi obtenue sera tronquée pour pouvoir être stockée dans le type choisi.

Par exemple, il est tout à fait possible d’écrire :

1
2
3
byte unByte = 010; // UnByte vaut 8. 
short unShort = 063675; 
int unEntier = 06367512354;

long unLong = 06367512354523L;

1
2
3
4
byte unByte = 0_1_0; 
short unShort = 06_36_75; 
int unEntier = 0636_751_2354; 
long unLong = 06_3675_1235_4523L;

Il est possible de déclarer nativement des nombres entiers en hexadécimal directement dans le code source Java. La valeur binaire du nombre doit être préfixée par la valeur 0x et ne peut contenir que les caractères [0-9A-Fa-f] et le caractère - pour les valeurs négatives.

Le compilateur acceptera n'importe quelle valeur tant que cette dernière entre dans la limite des valeurs supportées par ce type. Une erreur sera générée si la valeur dépasse la capacité du type utilisé et un cast sera requis pour être capable de compiler ; la valeur ainsi obtenue sera tronquée pour pouvoir être stockée dans le type choisi.

Par exemple, il est tout à fait possible d’écrire :

1
2
3
byte unByte = 0x1A; 
short unShort = 0xFF; 
int unEntier = 0xADAFF01;

long unLong = 0xFFFFFFFFFFL;

1
2
3
4
byte unByte = 0x1_A; 
short unShort = 0xF_F; 
int unEntier = 0xAD_AFF01; 
long unLong = 0xFF_FFFF_FFFFL;

Depuis le JDK7, il est possible de déclarer nativement des nombres entiers en binaire directement dans le code source Java. La valeur binaire du nombre doit être préfixée par la valeur 0b et ne peut contenir que les caractères [01] et le caractère - pour les valeurs négatives.

Note : en Java, les nombres binaires sont au format big endian.

Le compilateur acceptera n'importe quelle valeur tant que cette dernière entre dans la limite des valeurs supportées par ce type. Une erreur sera générée si la valeur dépasse la capacité du type utilisé et un cast sera requis pour être capable de compiler ; la valeur ainsi obtenue sera tronquée pour pouvoir être stockée dans le type choisi.

Par exemple, il est tout à fait possible d’écrire :

1
2
3
byte unByte = 0b00100001; 
short unShort = 0b10100001010001; 
int unEntier = 0b10101010; // unEntier vaut 170.

long unLong = 0b1010000101000101101000010100010110100001010001011010000101000101L;

1
2
3
4
byte unByte = 0b00_10_00_01; 
short unShort = 0b1010000_1010001; 
int unEntier = 0b1010_1010; // unEntier vaut 170. 
long unLong = 0b10100001_01000101_10100001_01000101_10100001_01000101_10100001_01000101L;

int decimal = Integer.parseInt("1001", 2); // decimal vaut 9.

De manière générale, il vous suffit d’écrire une variable du type appropriée et de lui affecter une valeur numérique. En Java, l’arithmétique des nombres flottants suit le standard IEEE 754.

Attention : la notation des nombres se fait en suivant la syntaxe anglo-saxonne. Ici, c'est donc le caractère point (.) et non pas la virgule qui sert de séparateur entre la partie entière et partie flottante du nombre.

Le compilateur acceptera n'importe quelle valeur tant que cette dernière entre dans la limite des valeurs supportées par ce type. Une erreur sera générée si la valeur dépasse la capacité du type utilisé et un cast sera requis pour être capable de compiler ; la valeur ainsi obtenue sera approximée pour pouvoir être stockée dans le type choisi.

Il est également possible d'utiliser le caractère _ pour effectuer des groupements de chiffres. Ces groupements peuvent s'effectuer avant ou après le point qui sert de séparation entre la partie entière et partie flottante.

Simple précision (float)
Lorsque le nombre est écrit en simple précision, il peut être nécessaire de le suffixer par la lettre F minuscule ou majuscule (f ou F) pour forcer le compilateur à comprendre qu'il s'agit d'un nombre flottant en simple précision.

1
2
3
4
5
6
float f0 = 0; 
float f1 = -5.25f; 
float f2 = 5.25f; 
float f3 = 377.845f; 
float f4 = 377.845F; 
float f5 = 84_377.845_875F

1
2
3
4
5
6
7
double d0 = 0; 
double d1 = -5.25; 
double d2 = 5.25; 
double d3 = 377.845d; 
double d4 = 377.845D; 
double d5 = 84_377.845_875; 
double d6 = 84_377.845_875D;

Le standard IEEE 754 définit l’arithmétique des nombres flottants. Cette norme permet l’existence de deux valeurs pour le nombre 0 : le +0.0 (zéro positif ou positive zero) et le -0.0 (zéro négatif ou negative zero). Par convention, certains opérateurs considèrent ces valeurs comme égales tandis que d'autres peuvent tenir compte du signe. La représentation binaire exacte de 0.0 et -0.0 varie suivant le type utilisé.

Par exemple :

1
2
3
4
5
6
float a = 0f; // 0f s’écrit 00000000000000000000000000000000 en binaire. 
float b = -0f; // -0f s’écrit 10000000000000000000000000000000 en binaire. 
boolean c = a == b; // c contient true. 
boolean d = a > b; // d contient false. 
double e = 1 / a; // e contient Infinity. 
double f = 1 / b; // f contient -Infinity.

• - (0.0) a pour résultat -0.0.
• - (-0.0) a pour résultat 0.0.
• 0.0 == -0.0, 0.0 <= -0.0 et 0.0 >= -0.0 retournent true tandis que 0.0 != -0.0 retourne false. Cependant, les méthodes des bibliothèques numériques (ex. : Math.min()) peuvent valider le test -0.0 < 0.0. De même, la comparaison d'instances de classes wrapper par la méthode equals() échoue, car cette dernière teste la représentation binaire des valeurs.
  
  Par exemple :
  
  

  Code Java :

  Sélectionner tout

  1
  2
  3
  4
  5
  Double a = 0.0; 
  Double b = -0.0; 
  boolean c = a.doubleValue() == b.doubleValue()); // c contient true. 
  boolean d = a == b; // d contient false : teste les références de a et de b. 
  boolean e = a.equals(b); // e contient false : teste la représentation binaire des valeurs.

Dans le standard IEEE 754, deux valeurs sont censées représenter les limites extérieures de la plage de valeurs qu'il est possible de représenter par des nombres à virgule flottante : +∞ (infini positif ou positive infinity) et −∞ (infini négatif ou negative infinity). Ces nombres sont représentés par des constantes spéciales POSITIVE_INFINITY NEGATIVE_INFINITY définies dans les classes Float et Double. Ces valeurs peuvent être retournées en résultat de certaines opérations arithmétiques. La représentation binaire exacte de +∞ et −∞ varie suivant le type utilisé.

Par exemple :

1
2
double a = 1 / 0.0; // a contient Infinity.  
double b = 1 / -0.0; // b contient -Infinity.

• - Positive Infinity retourne Negative Infinity.
• - Negative Infinity retourne Positive Infinity
• Positive Infinity + Positive Infinity retourne Positive Infinity.
• Negative Infinity + Negative Infinity retourne Negative Infinity.
• x + y retourne Infinity si x ou y vaut Infinity ou si la valeur de la somme est trop grande (le signe de l’infinité dépend du signe de la variable).
• x - y retourne Infinity si x ou y vaut Infinity ou si la valeur de la différence est trop grande (le signe de l’infinité dépend du signe de la variable).
• x * Infinity (x est un nombre quelconque, hors 0) retourne Infinity (le signe de l’infinité dépend du signe de la variable).
• x / y peut retourner Infinity si le quotient de la division est trop grand (le signe de l’infinité dépend du signe de la variable).
• Infinity / y retourne Infinity (le signe de l’infinité dépend du signe de la variable).
• x / Infinity retourne 0 (le signe du zéro dépend du signe de la variable).
• f / 0F et f / 0D (f est un nombre flottant quelconque, hors 0) retournent Infinity (le signe de l’infinité dépend du signe de la variable) ; tandis que n / 0 et n / 0L (n est un entier quelconque) génèrent une exception de type java.lang.ArithmeticException contenant le message « / by zero ».
• positive Infinity toujours plus grand que n'importe quelle valeur flottante.
• Negative Infinity toujours plus petit que n'importe quelle valeur flottante.
• Positive Infinity est toujours égal à lui-même et toujours différent de toute autre valeur.
• Negative Infinity est toujours égal à lui-même et toujours différent de toute autre valeur.
  

Dans le standard IEEE 754, la valeur NaN (Not a Number, soit littéralement « pas un nombre ») est une valeur spéciale des types float et double destinée à représenter la valeur résultat d'une opération arithmétique non valide, par exemple 0F/0F. La représentation binaire exacte de NaN varie suivant le type utilisé.

Toute opération arithmétique dans laquelle au moins un des deux opérandes est à la valeur NaN retournera la valeur NaN.

Étant donné que NaN est une valeur particulière, il convient donc de la traiter avec précaution. Ainsi, il ne faut pas utiliser les opérateurs == (égalité) ou != (différence) pour vérifier si une variable ou une constante est à la valeur NaN. En effet, le test d’égalité sur NaN retourne tout le temps la valeur false, même en testant NaN à lui-même ; respectivement, le test de différence retourne tout le temps true. De la même manière, tous les opérateurs de comparaison entre deux valeurs (ex. : < (plus petit que), > (plus grand que), etc.) retourneront tout le temps la valeur false si au moins un des deux opérandes est à la valeur NaN.

Par exemple :

1
2
3
4
5
6
7
8
9
10
float a = Float.NaN; 
float b = 5f; 
System.out.println(a == Float.NaN); // Imprime false. 
System.out.println(b == Float.NaN); // Imprime false. 
System.out.println(a != Float.NaN); // Imprime true. 
System.out.println(b != Float.NaN); // Imprime true. 
System.out.println(a < Float.NaN); // Imprime false. 
System.out.println(b < Float.NaN); // Imprime false. 
System.out.println(a > Float.NaN); // Imprime false. 
System.out.println(b > Float.NaN); // Imprime false.

1
2
3
4
float a = Float.NaN; 
float b = 5f; 
System.out.println(Float.isNaN(a)); // Imprime true. 
System.out.println(Float.isNaN(b)); // Imprime false.

• -NaN retourne NaN ;
• x + y retourne NaN si x ou y vaut NaN.
• x - y retourne NaN si x ou y vaut NaN.
• x * y retourne NaN si x ou y vaut NaN.
• x / y retourne NaN si x ou y vaut NaN.
• x % y retourne NaN si x ou y vaut NaN.
• Positive Infinity + Negative Infinity retourne NaN.
• Positive Infinity - Negative Infinity retourne NaN.
• 0F * Infinity et 0D * Infinity retournent NaN.
• 0 / 0F et 0 / 0D retournent NaN.
• Infinity / Infinity retourne NaN.
• Infinity % x retourne NaN.
• x % 0F et x % 0D retournent NaN.
• x == y, x != y, x < y, x <= y, x > y et x >= y retournent false si x ou y vaut NaN.
  

La promotion numérique (numeric promotion) est un mécanisme par lequel certains opérateurs Java peuvent modifier les opérandes qui leur sont fournis de manière à pouvoir effectuer le calcul. Il existe deux cas de figure :

Promotion numérique unaire
La promotion numérique unaire (unary numeric promotion) peut s'effectuer sur les opérateurs qui prennent un seul et unique opérande. Elle applique les règles suivantes :

• si l’opérande est une référence des types wrapper Byte, Short, Character ou Integer, il peut être soumis à l'auto-unboxing. La valeur résultat peut être convertie en int ou conserver son type primitif (si c'est déjà int) ;
• sinon, si l’opérande est une référence des types wrapper Long, Float ou Double, il peut être soumis à l'auto-unboxing ;
• sinon, si l’opérande est de type byte short ou char ou Double, il est converti en int ;
• sinon, il conserve son type.
  

• si les opérandes sont des références (les types wrapper des classes numériques), ils peuvent être soumis à l'auto-unboxing ;
• les valeurs peuvent être « agrandies dans un type conteneur plus grand » suivant les règles suivantes :
  
  • si un des opérandes est de type double, l'autre est converti en double,
  • sinon, si un des opérandes est de type float, l'autre est converti en float,
  • sinon, si un des opérandes est de type long, l'autre est converti en long,
  • sinon, les deux opérandes sont convertis en int ;
    
• si besoin, les règles de conversion régissant la précision des calculs des types flottants s'appliquent alors.
  

Pour comparer des nombres entre eux, vous devez utiliser les opérateurs conditionnels == (« égalité » ou equals to) ou != (« différence » ou different from ou is not). Vous pouvez également utiliser les opérateurs < (« plus petit que » ou lesser than), <= (« plus petit ou égal à » ou lesser or equal than), > (« plus grand que » ou bigger than) et >= (« plus grand ou égal à » ou bigger or equal than). Tous ces opérateurs produisent des résultats de type boolean. Le mécanisme de la promotion numérique binaire s'applique sur ces opérateurs.

Par exemple :

1
2
3
4
5
6
7
8
int a = 3;  
int b = 9;  
boolean c = a == b; // c vaut false.  
boolean d = a != b; // d vaut true. 
boolean e = a < b; // e vaut true. 
boolean f = a <= b; // f vaut true. 
boolean g = a > b; // g vaut false. 
boolean h = a >= b; // h vaut false.

Il existe quatre opérateurs permettant d’incrémenter et de décrémenter rapidement les valeurs de variables numériques : le ++ préfixe (« incrément préfixe » ou Prefix Increment) et le ++ postfixe (« incrément postfixe » ou Postfix Increment), le -- préfixe (« décrément préfixe » Prefix Decrement) et le -- postfixe (« décrément postfixe » ou Postfix Decrement). La promotion numérique binaire s'applique à la fois sur l’opérande explicite de ces opérateurs (la valeur à incrémenter ou décrémenter) ainsi que sur son opérande implicite (l’incrément ou le décrément qui vaut tout le temps 1).

Opérateurs préfixes

Les opérateurs préfixes précédent la variable à incrémenter ou décrémenter de 1. Avec ces opérateurs, l’opération d’incrémentation ou de décrémentation est appliquée à la variable ; puis, l'expression retourne la nouvelle valeur de la variable.

Par exemple :

1
2
3
int a = 0; // Valeur initiale. 
int b = ++a; // a et b valent 1. 
int c = --a; // a et c valent 0.

1
2
3
int a = 0; // Valeur initiale. 
int b = a++; // a vaut 1 mais b vaut 0. 
int c = a--; // a vaut 0 mais c vaut 1.

Pour effectuer des opérations arithmétiques sur des nombres, vous devez utiliser les opérateurs arithmétiques + (« plus » ou « addition » ou added to), - (« moins » ou « soustraction » ou subtracted from), * (« fois » ou « multiplication par » ou multiplied y), / (« divisé par » ou « division par » ou divided by) ou % (« reste de la division » ou remainder). Le mécanisme de la promotion numérique binaire s'applique sur ces opérateurs.

Par exemple :

1
2
3
4
5
6
7
8
9
int a = 3;   
int b = 9;   
int c = a + b; // c vaut 12.   
int d = a - b; // d vaut  -6.  
int e = a * b; // e vaut 27.  
int f = a / b; // f vaut 0 (division entière).  
float g = a / (float)b; // g vaut 0.333333...f (division flottante).  
int h = a % b; // h vaut 3.  
float i = a % (float) b; // i vaut 3.0f.

Pour effectuer des opérations bit à bit (bitwise) sur des nombres entiers (byte, char, short, int et long), vous devez utiliser les opérateurs & (« et bit à bit » ou bitwise and), | (« ou inclusif bit à bit » ou bitwise inclusive or), ^ (« ou exclusif bit à bit » ou bitwise exclusive or ou xor). Il est également possible d'utiliser l’opérateur à un seul opérande ~ (« complément bit à bit » ou bitwise complement) qui remplace le contenu binaire d'un nombre par son complément. Ces opérateurs peuvent s'appliquer à des valeurs entières provenant de constantes ou de variables et ils produisent des résultats de type int ou long en fonction du type des opérandes. Le mécanisme de la promotion numérique binaire s'applique sur ces opérateurs.

Par exemple :

1
2
3
4
5
6
7
int a = 3; // 3 s’écrit 0011 en binaire. 
int b = 9; // 9 s’écrit 1001 en binaire. 
int c = a & b; // c vaut 1 donc 0001 en binaire. 
int d = a | b; // d vaut 11 donc 1011 en binaire. 
int e = a ^ b; // e vaut 10 donc 1010 en binaire. 
int f = ~a; // c vaut -4 donc 11111111111111111111111111111100 en binaire. 
int g = ~b; // d vaut -10 donc 11111111111111111111111111110110 en binaire.

1
2
3
4
5
3 & 9 ↔ 0000000000000000000000000000011 & 0000000000000000000000000001001 ↔ 00000000000000000000000000000001 ↔ 1 
3 | 9 ↔ 0000000000000000000000000000011 | 0000000000000000000000000001001 ↔ 00000000000000000000000000001011 ↔ 11 
3 ^ 9 ↔ 0000000000000000000000000000011 ^ 0000000000000000000000000001001 ↔ 00000000000000000000000000001010 ↔ 10 
~ 3 = ~ 0000000000000000000000000000011                                   ↔ 11111111111111111111111111111100 ↔ -4 
~ 9 = ~ 0000000000000000000000000001001                                   ↔ 11111111111111111111111111110110 ↔ -10

Pour effectuer des décalages sur des nombres, vous devez utiliser les opérateurs << (« décalage à gauche » ou left shift), >> (« décalage à droite avec préservation du signe » ou signed right shift) et >>> (« décalage à droite sans préservation du signe » ou unsigned right shift). L’opérande de gauche est la valeur sur laquelle on opère le décalage tandis que l’opérande de droite est le nombre de bits qui doivent être décalés vers un côté ou l'autre en fonction de la nature de l’opérateur. Le mécanisme de la promotion numérique unaire s'applique sur chaque opérande de ces opérateurs (bien qu'il s'agisse d’opérateurs acceptant deux opérandes).

Par exemple :

1
2
3
4
5
6
7
8
int a = 3; // 3 s’écrit 0011 en binaire.  
int b = -9; // -3 s’écrit 11111111111111111111111111110111 en binaire.  
int c = a << 1; // c vaut 6 donc 0110 en binaire.  
int d = b << 1; // d vaut -18 donc 11111111111111111111111111101110 en binaire.  
int e = a >> 1; // e vaut 1 donc 0001 en binaire.  
int f = b >> 1; // f vaut -5 donc 11111111111111111111111111111011 en binaire.  
int g = a >>> 1; // g vaut 1 donc 0001 en binaire.  
int h = b >>> 1; // h vaut 2147483643 donc 01111111111111111111111111111011 en binaire.

1
2
3
4
5
6
3 << 1   ↔ 00000000000000000000000000000011 << 1  ↔ 00000000000000000000000000000110 ↔ 6 
3 >> 1   ↔ 00000000000000000000000000000011 >> 1  ↔ 00000000000000000000000000000001 ↔ 1 
3 >>> 1  ↔ 00000000000000000000000000000011 >>> 1 ↔ 00000000000000000000000000000001 ↔ 1 
-9 << 1  ↔ 11111111111111111111111111110111 << 1  ↔ 11111111111111111111111111101110 ↔ -18 
-9 >> 1  ↔ 11111111111111111111111111110111 >> 1  ↔ 11111111111111111111111111111011 ↔ -5 
-9 >>> 1 ↔ 11111111111111111111111111110111 >>> 1 ↔ 01111111111111111111111111111011 ↔ 2147483643

Si vous essayez ceci :

System.out.println(1.3-1.2);

1
2
3
BigDecimal bd1 = new BigDecimal("1.3");  
BigDecimal bd2 = new BigDecimal("1.2");  
System.out.println(bd1.substract(bd2));

Arrondir un réel en entier :

Il suffit d'utiliser la méthode Math.floor() pour arrondir un réel à l'entier inférieur le plus proche :

double a = Math.floor(1.99); // 1.0

double a = Math.ceil(1.01); // 2.0

double a = Math.floor(1.99+0.5); // 2.0

double a = Math.floor(1.49+0.5); // 1.0

• Si la valeur de la partie décimale est inférieure à 0.5, la valeur sera arrondie à l'entier inférieur.
• Si la valeur la partie décimale est supérieur ou égale à 0.5, la valeur sera arrondie à l'entier supérieur.
  

1
2
3
4
5
double a = 1.6666666; 
// Arrondir la valeur a 10^-2  
a *= 100.0; 
a = Math.floor(a+0.5); 
a /= 100.0; // 1.67

1
2
3
4
5
6
7
8
9
10
/** 
 * Arrondi d'un double avec n éléments après la virgule. 
 * @param a La valeur à convertir. 
 * @param n Le nombre de décimales à conserver. 
 * @return La valeur arrondie à n décimales. 
 */ 
public static double floor(double a, int n) { 
    double p = Math.pow(10.0, n); 
    return Math.floor((a*p)+0.5) / p; 
}

double a = floor(1.6666666, 2); // 1.67

Pour effectuer un tirage aléatoire, il faut utiliser la classe java.util.Random. Cette classe va nous permettre d'effectuer des générations de nombre pseudoaléatoire.

On peut tirer des valeurs de différents types : boolean, byte, double, float, int et long. Tout cela au moyen des méthodes nextXXX() de la classe Random.

Une particularité avec un tirage d'un entier (int) est le fait que l'on puisse configurer la séquence sur laquelle le nombre va être tiré. On peut en effet passer un paramètre à la méthode nextInt() qui sera le nombre maximum à tirer, le nombre minimal étant zéro.

1
2
3
4
Random random = new Random();  
  
int pseudoRandomNumber = random.nextInt(); //Un nombre aléatoire 
int pseudoRandomNumberTwo = random.nextInt(25); //Un nombre aléatoire entre 0 et 25.

Voici la description de différents « outils » pouvant vous permettre de faire des calculs mathématiques. Les deux premiers sont des classes faisant partie du JDK standard, le dernier est une API du projet Jakarta Commons.

java.lang.Math
La classe Math contient un ensemble de méthodes statiques permettant de faire des opérations numériques basiques (logarithmes, exponentielles ou fonctions trigonométriques). Contrairement à la classe StrictMath, les différentes implémentations d'une même méthode ne donnent pas le même résultat « bit à bit ». On peut quand même noter que, en général, les implémentations des méthodes de la classe Math font appel aux méthodes de StrictMath. Si la précision n'est pas le critère primordial, vous pouvez préférer Math à StrictMath pour des raisons de performance.

java.lang.StrictMath
Les méthodes de StrictMath sont les mêmes que celles de Math, à la différence que les résultats obtenus sont les mêmes que ceux produits par la version 5.3 de la bibliothèque FDLIBM (Freely Distributable Math Library).

Math 1.0 (Jakarta Commons)
Cette API (disponible sur http://commons.apache.org/proper/commons-math/) met à la disposition du développeur Java un plus grand nombre d'algorithmes mathématiques et statistiques.

Il en existe bien d'autres, plus d'informations sur la page API de Développez.

Methode toString(valeur)
La conversion d'un nombre en chaîne de caractères est assurée par les différentes classes de gestion des types de base de Java : java.lang.Integer, java.lang.Double, java.lang.Float, java.lang.Long, java.lang.Byte.

Par exemple :

1
2
3
4
String chaine = Integer.toString(monInt); 
String chaine = Long.toString(monLong); 
String chaine = Byte.toString(monByte); 
// etc.

La classe java.text.DecimalFormat permet de formater une valeur numérique dans le format de son choix en utilisant un pattern dont les symboles principaux sont les suivants :

• 0 - permet de représenter un chiffre qui devra obligatoirement être présent, même s'il s'agit d'un zéro inutile ;
• # - permet de représenter un chiffre en ignorant les zéros inutiles ;
• . (le point) - permet de représenter le séparateur de la partie décimale ;
• , (la virgule) - permet de représenter le séparateur des groupes (milliers, millions, etc.).
  

1
2
DecimalFormat df = new DecimalFormat("0.00"); 
System.out.println(df.format(mon_nombre));

System.out.printf ("%d", 12); // Affiche 12

System.out.printf ("%f", 1234.567); // Affiche 1234,567000

Conversion en base 2, 8, 16 : int toXXXString()

La classe Integer dispose de trois méthodes statiques permettant de convertir un entier décimal en une chaîne représentant son équivalent binaire, octal et hexadécimal.

1
2
3
4
int intBase10 = 192; 
String intBase2 = Integer.toBinaryString(intBase10); // "11000000" 
String intBase8 = Integer.toOctalString(intBase10);  // "300" 
String intBase16 = Integer.toHexString(intBase10);   // "c0"

1
2
3
4
int intBase10 = 19587; 
String intBase2 = Integer.toString(intBase10,2);   // "100110010000011" 
String intBase5 = Integer.toString(intBase10,5);   // "1111322" 
String intBase27 = Integer.toString(intBase10,27); // "qnc"

Méthode parseXXX()
La conversion de chaînes de caractères en valeurs numériques est assurée par les différentes classes de gestion des types de base de Java : java.lang.Integer, java.lang.Double, java.lang.Float, java.lang.Long et java.lang.Byte. La chaîne de caractères ne doit contenir que le nombre à convertir : toute erreur génère l'exception java.lang.NumberFormatException.

1
2
3
4
int i = Integer.parseInt(maString); 
long l = Long.parseLong(maString); 
byte b = Byte.parseByte(maString); 
// etc.

Integer.parseInt(hexa, 16);

1
2
3
4
5
NumberFormat monFormatteurDeNombre = NumberFormat.getInstance(); 
// par défaut localisation France sur mon ordinateur 
String maChaine = "1053,52"; 
double resultat = monFormatteurDeNombre.parse(maChaine).doubleValue(); 
// Le parse doit attraper l'exception ParseException

Méthode parseInt()
La méthode statique parseInt() de la classe Integer permet de convertir une chaîne représentant un nombre entier en base quelconque en un entier décimal.

1
2
3
4
5
6
parseInt("99", 8); // throws a NumberFormatException 
parseInt("Kona", 10); // throws a NumberFormatException 
parseInt("Kona", 27); //returns 411787 
parseInt("-0", 10); //returns 0 
parseInt("-FF", 16); //returns -255 
parseInt("1100110", 2); //returns 102

• (-) DecimalNumeral
• (-) 0x HexDigits
• (-) 0X HexDigits
• (-) # HexDigits
• (-) 0 OctalDigits
  

En Java les types de base sont passés aux méthodes par valeur, ils ne peuvent pas être modifiés. Il va falloir utiliser une instance de classe « encapsulant » un entier pour effectuer la modification. Attention la classe fournie Integer ne permet pas la modification et est donc inutile dans ce cas.

Exemple :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class MonEntier { 
   /** champ privé : */ 
   private int value; 
  
   /** mise à jour de la valeur */ 
   public void setValue(int newValue) { 
       value = newValue; 
   }  
  
   /** Accès à la valeur */ 
   public int getValue() { 
       return( value); 
   }  
}

1
2
3
public void maMethode (MonEntier i) { 
    i.setValue(maNouvelleValeur); 
}