Bienvenue dans ce tutoriel approfondi sur la manipulation des types flottants en Java. Nous allons explorer en détail chaque aspect, des fondamentaux aux concepts avancés.

accès rapide

• Les Types Flottants en Java
• Opérations Arithmétiques et de comparaison sur les Types Flottants
• Conversion de Types Flottants
• Manipulation des Résultats de Calculs Flottants
• Exercices d’application
• Quiz de ce tuto

Les Types Flottants en Java

La démo

1. Introduction aux Types Flottants

Les types flottants en Java fournissent une méthode de représentation de nombres réels, permettant ainsi aux programmeurs de manipuler des valeurs décimales avec précision.

La principale différence entre les types flottants et les types entiers réside dans leur capacité à stocker des valeurs fractionnaires. Alors que les types entiers sont limités aux nombres entiers sans fraction, les types flottants peuvent représenter une gamme plus large de valeurs réelles. Par exemple, un int peut stocker 5, mais pas 5.5, tandis qu’un double peut stocker 5.5 avec précision.

2. Les deux types Flottants

1. Le type float

• Taille : Le type float en Java est un type à virgule flottante simple précision qui occupe 32 bits en mémoire.
• Précision : Il offre une précision d’environ 7 chiffres décimaux significatifs.
• Plage de valeurs : La plage de valeurs d’un float est de l’ordre de ±3.4E+38.
• Syntaxe de déclaration : Pour déclarer une variable de type float, utilisez le mot-clé float, suivi du nom de la variable, par exemple :

float myFloatVariable;

2. Le type double

• Taille : Le type double en Java est un type à virgule flottante double précision qui occupe 64 bits en mémoire.
• Précision : Il offre une précision d’environ 15 chiffres décimaux significatifs.
• Plage de valeurs : La plage de valeurs d’un double est de l’ordre de ±1.7E+308.
• Syntaxe de déclaration : Pour déclarer une variable de type double, utilisez le mot-clé double, suivi du nom de la variable, par exemple :

double myDoubleVariable;

3. Initialisation des Variables Flottantes

Dans cette section, nous aborderons la manière d’initialiser des variables flottantes en Java.

3.1. Initialisation des Variables Flottantes

Les variables flottantes peuvent être initialisées avec des valeurs littérales lors de leur déclaration ou ultérieurement dans le code.

Exemple :

float pi = 3.14f;          // Initialisation de la variable pi avec la valeur de pi en float
double temperature = 25.5; // Initialisation de la variable temperature avec une valeur de température en double

3.2. Exemple de déclaration simple :

public class DeclarationSimple{
    public static void main(String[] args) {
        float myFloat = 10.5f;
        double myDouble = 20.5;
        
        System.out.println("Valeur de myFloat : " + myFloat);
        System.out.println("Valeur de myDouble : " + myDouble);
    }
}

3.3 Exemple d’utilisation enrichi avec une écriture scientifique

public class Main {
    public static void main(String[] args) {
        float myFloat = 1.25e-3f; // Notation scientifique pour une valeur float
        double myDouble = 2.5e6; // Notation scientifique pour une valeur double
        
        System.out.println("Valeur de myFloat : " + myFloat);
        System.out.println("Valeur de myDouble : " + myDouble);
    }
}

Dans cet exemple, la notation scientifique est utilisée pour définir les valeurs des variables myFloat et myDouble. La lettre e (ou E) est utilisée pour indiquer une puissance de 10. Par exemple, 1.25e-3f signifie 1.25 multiplié par 10 puissance -3, ce qui est équivalent à 0.00125. De même, 2.5e6 signifie 2.5 multiplié par 10 puissance 6, ce qui est équivalent à 2 500 000.

3.4 Exemple d’explication des arrondis

public class RoundingExample {
   public static void main(String[] args) {
        float floatValueExemple1 = 98765.4321f;
        System.out.println("Valeur de floatValueExemple1 : " + floatValueExemple1);
        float floatValueExemple2 = 98765.4351f;
        System.out.println("Valeur de floatValueExemple2 : " + floatValueExemple2);
        
         double doubleValueExemple1 = 98765.4321;
        System.out.println("Valeur de doubleValueExemple1 : " + doubleValueExemple1);
        double doubleValueExemple2 = 98765.4351;
        System.out.println("Valeur de doubleValueExemple2 : " + doubleValueExemple2);
        
        double doubleValueExemple3 = 98765.432125896322580;
        System.out.println("Valeur de doubleValueExemple3 : " + doubleValueExemple3);
        double doubleValueExemple4 = 98765.432125896326580;
        System.out.println("Valeur de doubleValueExemple4 : " + doubleValueExemple4);
        
    }
}

Opérations Arithmétiques et de comparaison sur les Types Flottants

La démo

1. Opérations Arithmétiques

Dans cette section, nous aborderons en détail les opérations arithmétiques que vous pouvez effectuer sur les types flottants en Java.

1.1. Opérations d’Addition, Soustraction, Multiplication , Division et modulo

Les opérations arithmétiques de base, telles que l’addition, la soustraction, la multiplication, la division et le modulo , peuvent être effectuées sur les types flottants de la même manière que sur les types entiers.

public class Calculatrice {

    public static void main(String[] args) {
        double a = 10.5;
        double b = 5.3;

        double somme = a + b;               // Addition
        double difference = a - b;           // Soustraction
        double produit = a * b;              // Multiplication
        double quotient = a / b;             // Division
        double reste = a % b;                // Reste de la division

        // Affichage des résultats
        System.out.println("Somme : " + somme);
        System.out.println("Différence : " + difference);
        System.out.println("Produit : " + produit);
        System.out.println("Quotient : " + quotient);
        System.out.println("Reste de la division : " + reste);
    }
}

Ces opérations se comportent comme prévu, mais il est important de noter que les résultats peuvent être arrondis en raison de la précision limitée des types flottants.

1.2. Règles de Promotion des Types

Lorsque vous effectuez des opérations entre des types flottants et des types entiers, les types entiers sont automatiquement promus en types flottants pour la compatibilité.

int intValue = 10;
double doubleValue = 5.0;

double result = intValue + doubleValue;   // La variable intValue est automatiquement promue en double pour l'addition

Cela permet d’éviter les erreurs de type lors des opérations mixtes entre les types flottants et les types entiers.

1.3. Les valeurs Flottants possibles

Lorsque vous effectuez des opérations arithmétiques sur des types flottants, nous pouvons avoir ces trois cas :

• Une valeur flottante
• Une valeur NAN ( not a number)
• Une valeur infinie

Exemple :

public class ValeursSpeciales {

    public static void main(String[] args) {
        // Définition des valeurs spéciales
        float floatVal1 = 10.5f;
        double floatVal2= 5.0 / 0; //Double.POSITIVE_INFINITY;
        double floatVal3= 0.0 / 0; //Double.NaN;

        // Affichage des valeurs
        System.out.println("Valeur Float : " + floatVal1 );
        System.out.println("Valeur Infinity : " + floatVal2);
        System.out.println("Valeur NaN : " + floatVal3);
    }
}

Méthodes de Test pour les Valeurs Flottantes

Java fournit des méthodes dans les classes Float et Double pour tester ces valeurs spéciales.

• Float.isFinite(floatValue) : Retourne true si la valeur n’est pas infinie ou NaN.
• Float.isInfinite(floatValue) : Retourne true si la valeur est infinie (positif ou négatif).
• Float.isNaN(floatValue) : Retourne true si la valeur est NaN.

Exemples d’Utilisation :

Tester Fini ou Infini :

float valeurF = 123.45f;

if (Float.isFinite(valeurF)) {
    System.out.println("La valeur est finie.");
} else {
    System.out.println("La valeur est infinie ou NaN.");
}

Test d’Infini ou NaN :

double valeurD = Double.POSITIVE_INFINITY;

if (Double.isInfinite(valeurD)) {
    System.out.println("La valeur est infinie.");
} else {
    System.out.println("La valeur n'est pas infinie.");
}

Test de NaN :

double nanValue = Double.NaN;

if (Double.isNaN(nanValue)) {
    System.out.println("La valeur est NaN.");
} else {
    System.out.println("La valeur n'est pas NaN.");
}

2. Comparaison de Nombres Flottants

Lorsque vous travaillez avec des nombres flottants en Java, il est important de comprendre que leur précision peut entraîner des résultats inattendus lors de comparaisons directes. Dans cet exemple, nous examinerons comment comparer l’égalité et l’inégalité de nombres flottants en tenant compte des limitations de précision.

Comparaison d’Égalité :

• Sans utilisation de BigDecimal:

public class ComparaisonFlottants {

    public static void main(String[] args) {
        double a = 0.1 + 0.2;  // Addition de deux nombres flottants
        double b = 0.3;

        // Comparaison des nombres flottants
        if (a == b) {
            System.out.println("a est égal à b.");
        } else {
            System.out.println("a n'est pas égal à b.");
        }
        
        // Comparaison en utilisant une marge d'erreur
        double epsilon = 0.0001;  // Marge d'erreur acceptable
        if (Math.abs(a - b) < epsilon) {
            System.out.println("a est quasiment égal à b (avec une marge d'erreur).");
        } else {
            System.out.println("a n'est pas quasiment égal à b.");
        }
    }
}

• Avec utilisation de BigDecimal:

import java.math.BigDecimal;

public class ComparaisonBigDecimal {

    public static void main(String[] args) {
        BigDecimal a = new BigDecimal("0.1");
        BigDecimal b = new BigDecimal("0.2");
        BigDecimal c = new BigDecimal("0.3");

        // Addition de deux BigDecimals
        BigDecimal somme = a.add(b);

        // Comparaison avec BigDecimal
        if (somme.equals(c)) {
            System.out.println("La somme de 0.1 et 0.2 est égale à 0.3.");
        } else {
            System.out.println("La somme de 0.1 et 0.2 n'est pas égale à 0.3.");
        }
    }
}

Comparaison d’Inégalité :

// Exemple de comparaison d'inégalité de nombres flottants
float nombre1 = 10.5f;
float nombre2 = 20.3f;

if (nombre1 != nombre2) {
    System.out.println("nombre1 est différent de nombre2");
} else {
    System.out.println("nombre1 est égal à nombre2");
}

Comparaison de l’Ordre :

Lorsque vous comparez l’ordre de deux nombres flottants, vous devez tenir compte de la précision et de la direction de la comparaison. Utilisez les opérateurs <, >, <= et >= avec prudence, en tenant compte des cas de débordement et de sous-débordement.

Exemple de comparaison d’ordre :

double x = 1.0;
double y = 2.0;
if (x < y) {
    System.out.println("x est inférieur à y");
} else if (x > y) {
    System.out.println("x est supérieur à y");
} else {
    System.out.println("x est égal à y");
}

En comprenant ces nuances de comparaison de nombres flottants, vous pouvez éviter les pièges courants et obtenir des résultats précis dans vos programmes Java.

Conversion de Types Flottants

La démo

Dans cette section, nous aborderons la conversion entre les types flottants en Java. Nous verrons comment convertir un type flottant en un autre type flottant de taille différente, ainsi que la conversion entre les types flottants et les types entiers.

Conversion entre Types Flottants de Taille Différente

En Java, vous pouvez convertir un type flottant en un autre type flottant de taille différente en utilisant une conversion implicite ou explicite.

• Conversion implicite : Lorsque vous affectez une valeur d’un type flottant de plus grande taille à un type flottant de plus petite taille, Java effectue automatiquement la conversion sans perte de données, car la plage de valeurs du type source est incluse dans celle du type cible.Exemple :

float smallValue = 3.14f;
double bigValue = smallValue; // Conversion implicite d'un float en double

Conversion explicite : Lorsque vous affectez une valeur d’un type flottant de plus petite taille à un type flottant de plus grande taille, une conversion explicite est nécessaire pour éviter la perte de données potentielle.

Exemple :

double bigValue = 3.14159;
float smallValue = (float) bigValue; // Conversion explicite d'un double en float

Conversion entre Types Flottants et Types Entiers

En Java, vous pouvez également convertir entre les types flottants et les types entiers. Lorsque vous convertissez un type flottant en un type entier, la partie décimale est tronquée. Lorsque vous convertissez un type entier en un type flottant, le résultat est une valeur flottante avec une partie fractionnaire de zéro.

• Conversion de type flottant en type entier :

double floatValue = 3.14;
int intValue = (int) floatValue; // La partie décimale est tronquée

• Conversion de type entier en type flottant :

int intValue = 5;
float floatValue = intValue; // Le résultat est 5.0

La conversion entre les types flottants en Java est une opération courante et peut être effectuée de manière implicite ou explicite selon les besoins du programme. Dans la prochaine section, nous examinerons comment gérer les dépassements de capacité lors de la manipulation des types flottants.

Manipulation des Résultats de Calculs Flottants

La démo

Lorsque vous effectuez des calculs impliquant des nombres flottants en Java, il est essentiel de comprendre comment gérer les arrondis et les décimales dans les résultats. Les calculs flottants peuvent souvent entraîner des résultats avec un grand nombre de décimales, ce qui peut nécessiter une gestion appropriée pour obtenir des résultats précis et significatifs. Voici quelques éléments à considérer lors de la manipulation des résultats de calculs flottants :

1. Utilisation de la classe Math

L’arithmétique flottante peut produire des résultats avec plus de décimales que nécessaire. Pour arrondir un nombre flottant à un certain nombre de décimales, vous pouvez utiliser la méthode Math.round() ou la méthode BigDecimal.setScale() pour obtenir le résultat souhaité.

1.1.Arrondir un nombre à l’entier le plus proche :

double nombre = 12.345;
long arrondi = Math.round(nombre);
System.out.println("Arrondi : " + arrondi);

1.2. Calcul de la racine carrée :

double nombre = 25;
double racineCarree = Math.sqrt(nombre);
System.out.println("Racine carrée : " + racineCarree);

1.3. Calcul de la puissance:

double base = 2;
double exposant = 3;
double puissance = Math.pow(base, exposant);
System.out.println("Puissance : " + puissance);

1.4. Obtention de la valeur absolue :

int nombre = -10;
int absolu = Math.abs(nombre);
System.out.println("Valeur absolue : " + absolu);

1.5. Calcul du logarithme naturel :

double nombre = 10;
double logarithme = Math.log(nombre);
System.out.println("Logarithme naturel : " + logarithme);

1.6. Génération de nombres aléatoires :

double aleatoire = Math.random(); // Génère un nombre aléatoire entre 0 et 1
System.out.println("Nombre aléatoire : " + aleatoire);

1.7. Trigonométrie – Calcul du sinus :

double angleEnRadians = Math.toRadians(30); // Convertit l'angle de degrés en radians
double sinus = Math.sin(angleEnRadians);
System.out.println("Sinus : " + sinus);

2. Utilisation de Formats de Sortie :

Lorsque vous affichez des nombres flottants, il est recommandé d’utiliser des formats de sortie appropriés pour garantir la lisibilité et la précision des résultats. Vous pouvez utiliser la classe DecimalFormat pour formater un nombre flottant selon un modèle spécifique.

Exemple de formatage d’un nombre flottant avec deux décimales :

double value = 123.456789;
DecimalFormat df = new DecimalFormat("#.##");
String formattedValue = df.format(value);
System.out.println("Formatted Value: " + formattedValue);

En utilisant des techniques d’arrondi appropriées et des formats de sortie adaptés, vous pouvez manipuler efficacement les résultats de calculs flottants en Java pour obtenir des résultats précis et lisibles.

3.La Classe Ramdom

import java.util.Random;

public class RandomExample {
    public static void main(String[] args) {
        // Création d'une instance de Random
        Random random = new Random();

        // Génération d'un nombre aléatoire entre 0 (inclus) et 100 (exclus)
        int randomNumber = random.nextInt(100);
        System.out.println("Nombre aléatoire entre 0 et 100 : " + randomNumber);

        // Génération d'un nombre aléatoire entre 10 (inclus) et 20 (exclus)
        int min = 10;
        int max = 20;
        int randomNumberInRange = random.nextInt(max - min) + min;
        System.out.println("Nombre aléatoire entre 10 et 20 : " + randomNumberInRange);

        // Génération d'un nombre aléatoire en virgule flottante entre 0 (inclus) et 1 (exclus)
        double randomDouble = random.nextDouble();
        System.out.println("Nombre aléatoire en virgule flottante entre 0 et 1 : " + randomDouble);
    }
}

Exercices d’application

La démo

Pour mieux comprendre la manipulation des types flottants en Java, explorons des exemples pratiques impliquant des calculs flottants dans des contextes réels. Ces exemples peuvent inclure des scénarios financiers, scientifiques ou géométriques, où les nombres flottants sont couramment utilisés. En outre, nous examinerons également des applications pratiques de la manipulation des types flottants dans le développement logiciel. Voici quelques exemples d’exercices pratiques et d’applications :

Exemple 1 : Calculs Géométriques

Calcul de l’aire, du périmètre ou du volume de formes géométriques telles que des cercles, des triangles ou des cubes.

Correction

public class CircleAreaCalculator {
    public static void main(String[] args) {
        // Définition du rayon du cercle en mètres
        double radius = 5.0;

        // Calcul de l'aire du cercle
        double area = Math.PI * Math.pow(radius, 2);

        // Affichage du résultat
        System.out.println("L'aire du cercle est de : " + area + " mètres carrés");
    }
}

Exemple 2 : Calculs Financiers

Calcul du paiement mensuel d’un prêt hypothécaire en fonction du montant du prêt, du taux d’intérêt et de la durée du prêt.

Correction

public class MortgageCalculator {
    public static void main(String[] args) {
        // Définition des variables
        double loanAmount = 200000.0; // Montant du prêt en dollars
        double annualInterestRate = 5.0; // Taux d'intérêt annuel en pourcentage
        int loanTermInYears = 30; // Durée du prêt en années

        // Calcul du taux d'intérêt mensuel et du nombre total de paiements
        double monthlyInterestRate = annualInterestRate / 12 / 100;
        int numberOfPayments = loanTermInYears * 12;

        // Calcul du paiement mensuel du prêt hypothécaire
        double monthlyPayment = loanAmount * monthlyInterestRate /
                                (1 - Math.pow(1 + monthlyInterestRate, -numberOfPayments));

        // Affichage du résultat
        System.out.println("Le paiement mensuel du prêt hypothécaire est de : $" + monthlyPayment);
    }
}

Exemple 3 : Calculs Scientifiques

Simulation d’une expérience scientifique impliquant des mesures précises et des calculs de résultats basés sur des formules mathématiques complexes.

Correction

public class ScientificCalculation {
    public static void main(String[] args) {
        // Supposons que nous mesurons la vitesse de la lumière en m/s
        double speedOfLight = 299792458.0; // Vitesse de la lumière en m/s

        // Convertir la vitesse de la lumière en km/h
        double speedOfLightKmph = speedOfLight * 3.6; // Conversion de m/s en km/h

        // Affichage des résultats
        System.out.println("La vitesse de la lumière est de : " + speedOfLightKmph + " km/h");
    }
}

Exemple 4 : Applications Logicielles

Développement d’une application de suivi des dépenses personnelles qui effectue des calculs de budget basés sur des entrées utilisateur de montants flottants.

Correction

import java.util.Scanner;

public class BudgetCalculator {
    public static void main(String[] args) {
        // Création d'un objet Scanner pour obtenir les entrées utilisateur
        Scanner scanner = new Scanner(System.in);

        // Demander à l'utilisateur d'entrer les revenus mensuels
        System.out.print("Entrez vos revenus mensuels : ");
        double income = scanner.nextDouble();

        // Demander à l'utilisateur d'entrer les dépenses mensuelles
        System.out.print("Entrez vos dépenses mensuelles : ");
        double expenses = scanner.nextDouble();

        // Calcul du solde mensuel
        double balance = income - expenses;

        // Affichage du solde mensuel
        System.out.println("Votre solde mensuel est de : $" + balance);

        // Vérification du solde par rapport au budget
        if (balance < 0) {
            System.out.println("Attention : Vous avez dépassé votre budget !");
        } else if (balance == 0) {
            System.out.println("Attention : Vous avez atteint votre budget.");
        } else {
            System.out.println("Vous avez de l'argent en surplus ce mois-ci !");
        }

        // Fermeture du scanner
        scanner.close();
    }
}

Exemple 5 : Calcul de l’Indice de Masse Corporelle (IMC)

Enoncé de l’exercice : Écrivez un programme qui calcule l’indice de masse corporelle (IMC) d’une personne en fonction de sa taille en mètres et de son poids en kilogrammes. Utilisez des nombres flottants pour représenter la taille et le poids, et affichez l’IMC calculé ainsi que son interprétation selon les catégories d’IMC (sous-poids, poids normal, surpoids, obésité).

Correction

import java.util.Scanner;

public class BMICalculator {
    public static void main(String[] args) {
        // Création d'un objet Scanner pour obtenir les entrées utilisateur
        Scanner scanner = new Scanner(System.in);

        // Demander à l'utilisateur d'entrer sa taille en mètres
        System.out.print("Entrez votre taille en mètres : ");
        double height = scanner.nextDouble();

        // Demander à l'utilisateur d'entrer son poids en kilogrammes
        System.out.print("Entrez votre poids en kilogrammes : ");
        double weight = scanner.nextDouble();

        // Calcul de l'IMC
        double bmi = weight / (height * height);

        // Affichage de l'IMC
        System.out.println("Votre IMC est : " + bmi);

        // Interprétation de l'IMC
        if (bmi < 18.5) {
            System.out.println("Vous êtes en état de sous-poids.");
        } else if (bmi < 25) {
            System.out.println("Votre poids est normal.");
        } else if (bmi < 30) {
            System.out.println("Vous êtes en surpoids.");
        } else {
            System.out.println("Vous êtes obèse.");
        }

        // Fermeture du scanner
        scanner.close();
    }
}

Quiz de ce tuto

Vous pouvez tester que vous avez bien assimiler tous ce que nous avons appris ensemble via ce quiz 🙂 🙂 amusez vous bien.

/7

0 votes, 0 avg

18

Créé le février 09, 2024

Quiz JAVA SE : Manipulation des Types Flottants

Ce quiz vous aide à améliorer vos connaissances en Java SE 🙂 🙂 

1 / 7

1. Quelle est l'utilité des constantes flottantes spéciales telles que Double.POSITIVE_INFINITY en Java ?

a) Elles sont utilisées pour représenter des nombres infinis.

b) Elles sont utilisées pour représenter des valeurs nulles.

c) Elles sont utilisées pour représenter des nombres négatifs.

2 / 7

2. Quelle est la valeur par défaut d'une variable de type double non initialisée en Java ?

a) 0

b) 0.0

c) null

3 / 7

3. Quelle est la différence entre les types float et double en Java ?

a) float est utilisé pour les entiers, tandis que double est utilisé pour les décimaux.

b) float est de taille plus grande que double.

c) double a une plus grande précision que float.

4 / 7

4. Quels sont les deux principaux types flottants en Java ?

a) float et long

b) double et float

c) int et double

5 / 7

5. Quelle est la plage de valeurs pour le type float en Java ?

a) De -2^31 à 2^31 - 1

b) De -3.4x10^38 à 3.4x10^38

c) De -2^63 à 2^63 - 1

6 / 7

6. Comment déclarer une variable flottante en Java ?

a) float x = 5.0;

b) double x = 5.0;

c) float x = "5.0";

7 / 7

7. Comment déclarez-vous une variable double nommée pi avec la valeur 3.14159 en Java ?

a) double pi = 3.14159;

b) double pi = "3.14159";

c) double pi = new Double(3.14159);

Votre note est de

LinkedIn Facebook Twitter VKontakte

0%

Relancer le quiz

Veuillez évaluer ce quiz

Envoyer les commentaires