flotteur r = 5.0f
ou
r double = 5,0
La valeur 5.0 est un nombre représenté sous forme de fraction décimale (a un nombre entier et une partie fractionnaire). En informatique, ces nombres sont appelés réels
Le nombre réel est un nombre composé d'une partie entière et d'une partie fractionnaire. Les parties entière et fractionnaire sont séparées l'une de l'autre par un point, et non par une virgule comme en mathématiques.
Même si la partie fractionnaire du nombre est zéro, comme dans la variable \(r\) dans l'exemple, le traducteur créera toujours une variable réelle en mémoire. Le point, pour ainsi dire, un signal pour le traducteur qu'il est nécessaire de créer une variable réelle.
Nombres très grands et très petits sont écrits en "virgule flottante" (dans le soi-disant format scientifique).
Dans le format scientifique, un nombre est représenté par mantisse (partie significative du nombre) et exposant. Lorsqu'ils sont notés, la mantisse et l'exposant sont séparés l'un de l'autre par la lettre e (indiquant 10 dans une certaine mesure).
Par exemple, vous pouvez stocker la valeur de la charge d'un électron ( \(1.60217662 \times 10^{-19}\) C) dans un variable, s'écrivant sous la forme suivante
float El = 1.60217662e-19f //pour un ordre positif, le signe + peut être omis
ou
doubleEl= 1.60217662e-19
Presque tous les nombres réels ne peuvent pas être stockés dans la mémoire de l'ordinateur avec une précision parfaite, car un nombre limité de bits est alloué pour leur stockage. Par conséquent, lors du calcul avec des nombres réels, les erreurs liées à l'imprécision de la représentation s'accumulent. De plus, moins il y a d'espace alloué, plus cette erreur sera importante. Afin de réduire l'erreur en Java, le type double est utilisé, qui stocke un nombre réel avec double précision en mémoire (occupe huit octets en mémoire, tandis que le type tapez \(float \)- 4 octets)
|
Entrez
Vous pouvez saisir plusieurs variables réelles à partir du flux d'entrée et les écrire dans des variables de la manière standard :
double x = in.nextDouble();
float y = in.nextFloat();
Le premier nombre va dans la variable \(x\), le second va dans la variable \(y\)
Sortie
Java a plusieurs façons d'afficher les nombres réels.
1) ; System.out.printf pour une sortie console simple
Par défaut, lors de l'utilisation de printf, les nombres réels sont imprimés avec une précision allant jusqu'à 6 décimales. Mais il y a des cas qui doivent être sortis avec une précision différente. Dans ce cas, vous devez spécifier le nombre de familiarités à allouer après la virgule décimale.
a double = 0,5 ;
System.out.printf("%f",a); // à l'écran 0.500000
System.out.printf("%.2f",a); // à l'écran 0.5
System.out.printf("%10.2f",a); // vous pouvez définir le nombre total de positions allouées pour la sortie du nombre
System.out.printf("%.2e",a); // affiche le nombre au format scientifique avec une précision de 2 chiffres
2) DecmialFormat pour obtenir une chaîne à partir d'un nombre en utilisant un modèle donné
La classe DecmialFormat vous permet de contrôler la sortie des zéros de début et de fin, des préfixes et des suffixes, des séparateurs de milliers et des séparateurs de dix mille, mais cela rend le code un peu plus complexe.
un double = 123,45 ;
DecimalFormat df = new DecimalFormat("#.###");
Chaîne formatée = df.format(a); System.out.println(formaté); //123.45
| Entrée |
Modèle |
Sortie |
Remarque |
| 123,45 |
#.# |
123,5 |
Affiché à une décimale avec arrondi |
| 123,45 |
#.### |
123,45 |
Affiche le nombre entier sans zéros non significatifs |
| 123,45 |
#.0 |
123,5 |
Affiché à une décimale avec arrondi |
| 123,45 |
#.000 |
123.450 |
Affiché jusqu'au troisième caractère avec un zéro non significatif à la fin |
|
Lorsque vous travaillez avec des nombres réels, vous pouvez utiliser la classe M ath déjà familière, qui contient un grand nombre de fonctions intégrées.
Lors de la résolution de problèmes, il est souvent nécessaire d'arrondir les nombres réels aux valeurs entières les plus proches. Il y a deux fonctions pour cela.
SOUVENEZ-VOUS
1 avec conversion de type explicite ( float x=1.5f; int y = int (x) ) - la partie fractionnaire d'un nombre réel est coupée ( y = 1)
2 Maths. plancher(x) - ; renvoie le plus grand entier inférieur ou égal à \(x\) (arrondi à l'inférieur)
3 Maths. ceil(x) - ; renvoie le plus petit entier supérieur ou égal à \(x\) (arrondi)
Voici les fonctions les plus utiles contenues dans le module cmath.
| Fonction |
Description |
| Arrondi |
rond(x) |
Arrondit un nombre à l'entier le plus proche. Si la partie fractionnaire du nombre est 0,5, le nombre est arrondi au nombre entier le plus proche. |
étage(x) |
Arrondit un nombre inférieur ("floor"), donc floor(1.5) == 1, floor(-1.5) == ; -2 |
plafond(x) |
Arrondit un nombre supérieur ("plafond"), tandis que ceil(1.5) == 2, ceil(-1.5) == ; -1 |
abs(x) |
Modulo (valeur absolue). |
| Racines, logarithmes |
sqrt(x) |
Racine carrée. Utilisation : y = sqrt(x) |
pow(x, y) |
Élève x à la puissance y. \(x^y\) |
log(x) |
Logarithme naturel. |
exp(x) |
La base des logarithmes naturels e = 2,71828... |
| Trigonométrie |
sin(x) |
Sinus d'un angle spécifié en radians |
cos(x) |
Cosinus d'un angle spécifié en radians |
tan(x) |
La tangente d'un angle spécifié en radians |
asin(x) |
Arcsinus, renvoie la valeur en radians |
acos(x) |
Arc cosinus, renvoie la valeur en radians |
atan(x) |
Arctangente, renvoie la valeur en radians |
atan2(y, x) |
Angle polaire (en radians) du point (x, y). |
Exemple d'utilisation :
Élever 2 à une puissance, car pow renvoie un double en réponse, puis une conversion en int est requise.
public classe principal {
public statique vide principal(Chaîne[] arguments) < spanstyle="color:#666666">{
int un = 2 ;
int b = (< span style="color:#b00040">int)Mathématiques.pouvoir(a,2);
}
}
|