Rechercher
 

Manipulation des types flottants

Utilisation des opérateurs binaires Le type boolean (booléen)



Accès rapide :
   La vidéo
   Les deux types flottants
   Tester vos valeurs flottantes
   Les opérateurs arithmétiques
   Les opérateurs de comparaison
   Un petit piège

La vidéo

Cette vidéo vous montre comment utiliser les deux types flottants, float et double, du langage Java. Les différentes syntaxes supportées vous y sont présentées.


Manipulation des types flottants en Java

Les deux types flottants

Vous avez le choix entre deux types numériques flottants : float et double. Le type float permet la manipulation de flottants en simple précision : de tels flottants occuperons 4 octets en mémoire (soit 32 bits). Le type double permet, qu'en à lui, la manipulation de flottants en double précision : du coup,les variables basées sur ce type occuperont le double d'espace en mémoire, soit 8 octets (64 bits).

  float double
Taille (exprimée en bits) 32 64
Exemple de valeurs 3.25f - 3.1e-4f 3.25 - 3.1e-4

Tout comme pour les types entiers, certaines syntaxes vous sont permises pour spécifier vos valeurs : notation exponentielle (mantisse et exposant), utilisation du caractère de groupage, spécification d'une valeur de type float, ... Voici un petit exemple d'utilisation.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
 19 
 20 
 21 
 22 
 23 
 24 
 25 
 26 
 27 
 28 
public class Demo {

    public static void main( String [] args ) {

        // Notation traditionnelle
        float   floatValue = 3.4f;
        double doubleValue = 3.4;

        System.out.println( floatValue );
        System.out.println( doubleValue );

        // Formatage d'une donnée de type double
        double price = 1_000_000_000.99;
        NumberFormat formatter = NumberFormat.getCurrencyInstance();
        System.out.println( formatter.format( price ) );
        
        // Notation exponentielle
        double exponentialValue1 = 3.4e10;
        double exponentialValue2 = 3.4e-10;
        float  exponentialValue3 = -3.4e10f;
        
        System.out.println( exponentialValue1 );
        System.out.println( exponentialValue2 );
        System.out.println( exponentialValue3 );
        
    }

}
Utilisation des types flottants en Java
par défaut, une valeur flottante est considérée comme étant de type double. Il ne faudra donc pas oublier d'utiliser le caractère f en fin de valeur si vous désirez la typée en float.

Tester vos valeurs flottantes

Quand vous travaillez avec des flottants, il se peut que vous obteniez des valeurs particulières, et notamment NaN (Not a Number) ou l'infini (en positif ou en négatif). Des méthodes statiques vous sont proposées pour tester ces valeurs. Ces méthodes sont portées par deux classes nommées Float et Double. Notez bien que ces classes commencent par des majuscules contrairement aux types float et double.

pour faire simple, on peut dire que des méthodes statiques sont des fonctions (ce n'est pas complétement juste, mais ce n'est pas complétement faux non plus). Nous reviendrons ultérieurement sur le concept de méthodes statiques.
nous reviendrons aussi sur le concept de classes ultérieurement. Notez juste que les deux nouvelles classes proposées ne s'affichent pas en couleur dans l'exemple ci-dessous. Ce ne sont donc pas des mots clés réservés du langage. En vérité, les véritables noms de ces classes sont java.lang.Double et java.lang.Float, mais vous pouvez omettre la partie java.lang : il s'agit du nom du package comprenant ces deux classes et ce package est visible par défaut.
 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
 19 
 20 
 21 
 22 
 23 
 24 
 25 
 26 
 27 
 28 
 29 
 30 
 31 
public class Demo {

    public static void main( String [] args ) {

        // --- Valeurs flottantes particulières ---
        double essai1 = 3.1415;
        double essai2 = Double.POSITIVE_INFINITY;   // Par exemple :   3 / 0.0;
        double essai3 = Double.NaN;                 // Par exemple : 0.0 / 0.0;
        
        // Cette ligne affiche : 3.1415 - Infinity - NaN
        System.out.println( essai1 + " - " + essai2 + " - " + essai3 );
        
        float fl1 = 3.6f;
        float fl2 = Float.NaN;
        float fl3 = Float.NEGATIVE_INFINITY;
        
        // --- Quelques tests sur ces valeurs ---
        System.out.println( Float.isFinite( fl1 ) );    // true
        System.out.println( Float.isFinite( fl2 ) );    // false
        System.out.println( Float.isFinite( fl2 ) );    // false

        System.out.println( Float.isInfinite( fl1 ) );  // false
        System.out.println( Float.isInfinite( fl2 ) );  // false
        System.out.println( Float.isInfinite( fl3 ) );  // true
        
        System.out.println( Float.isNaN( fl1 ) );       // false
        System.out.println( Float.isNaN( fl2 ) );       // true
        System.out.println( Float.isNaN( fl3 ) );       // false
    }

}
Réaliser des tests sur vos valeurs flottantes

Les opérateurs arithmétiques

Bien entendu, vous avez le droit d'utiliser des opérateurs pour réaliser les opérations arithmétiques classiques : l'addition (opérateur +), la soustraction (opérateur -), la multiplication (opérateur *) et la division flottante (opérateur /). Voici un petit exemple d'utilisation de certains de ces opérateurs.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
public class Demo {

    public static void main( String [] args ) {
    
        double circleRadius = 1.5;
        double circleArea = Math.PI * circleRadius * circleRadius;
    
        double squareLength = 3;
        double squareArea = squareLength * squareLength;
        
        double totalArea = circleArea + squareArea;
        System.out.println( totalArea );
    
    }
    
}
Quelques calculs flottants
La constante Math.PI est bien entendu fixée à environ 3.141592654 (la valeur de PI).

Les opérateurs de comparaison

Vous pouvez aussi comparer vos flottants. Pour ce faire, six opérateurs vous sont proposés : l'égalité (opérateur ==), la différence (opérateur !=), l'infériorité (opérateur <=), l'infériorité stricte (opérateur <), la supériorité (opérateur >=), la supériorité stricte (opérateur >). Voici un exemple d'utilisation.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
 19 
 20 
 21 
public class Demo {

    public static void main( String [] args ) {
    
        double circleRadius = 1.5;
        double circleArea = Math.PI * circleRadius * circleRadius;
    
        double squareLength = 3;
        double squareArea = squareLength * squareLength;
        
        if ( circleArea == squareArea ) {
            System.out.println( "Le cercle et le carré ont la même superficie" );
        } else if ( circleArea < squareArea ) {
            System.out.println( "Le cercle est plus petit que le carré" );
        } else {
            System.out.println( "Le cercle est plus grand que le carré" );
        }
    
    }
    
}
Comparaison de valeurs flottantes
l'instruction if permet de réaliser un test. Dans l'exemple ci-dessous trois cas peuvent être considérés. Bien entendu, étant donné les valeurs des aires, l'affichage produit sera « Le cercle est plus petit que le carré ».

Un petit piège

En fait, nous avons déjà vu le petit piège auquel je pense (dans le chapitre relatif à la manipulation des entiers). Si vous divisez deux entiers entre eux, le résultat sera entier. Pour obtenir une division flottante, il faut qu'au moins que l'un des deux opérandes utilisés soit flottant.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
public class Demo {

    public static void main( String [] args ) {
    
        double res = 1 / 3;
        System.out.println( res );      // Affiche 0.0
        
        res = 1 / 3.0;
        System.out.println( res );      // Affiche 0.333333     
    
    }
    
}
Cas de la division entière


Utilisation des opérateurs binaires Le type boolean (booléen)