Médiaforma

Java – La classe Double

Print Friendly

Les constantes, variables et méthodes de cette classe sont immédiatement accessibles sans qu’il soit nécessaire d’utiliser une instruction import. La déclaration suivante est implicite :

import java.lang.*;

Les variables

MAX_VALUE représente la valeur maximale qui puisse être stockée dans une variable double : 1.79769313486231570e+308d.

MIN_VALUE représente la valeur minimale qui puisse être stockée dans une variable double : 4.94065645841246544e-324d.

NEGATIVE_INFINITY représente la valeur -infini.

POSITIVE_INFINITY représente la valeur +infini.

NaN représente une valeur indéterminée.

Le constructeur

Le constructeur Double permet de définir un objet Double à partir d’une variable double :

public Double(double value);

Exemple :

Voir méthodes IntValue, longValue, floatValue et hashCode.

Les méthodes

isInfinite()

Cette méthode retourne la valeur true si le double spécifié en argument a une valeur infinie. Elle retourne la valeur false dans le cas contraire :

public static boolean isInfinite(double v)

Exemple :

public class Test {
  public static void main (String args[]) {
    double x = 1/0.0;
    System.out.println(x);
    System.out.println(Double.isInfinite(x));
  }
}

Le premier println affiche la valeur infinity et le second la valeur true. Java considère donc que la valeur stockée dans la variable x est infinie.

Remarque

Vous pouvez également utiliser la méthode isInfinite() pour déterminer si un objet Double a une valeur infinie :

public boolean isInfinite();

toString()

Cette méthode renvoie une chaîne de caractères qui représente le double passé en argument :

public static native String toString(double d);
Exemple :
public class Test {
  public static void main (String args[])
  {
    double x = Math.PI;
    String S;
    S = Double.toString(x);
    System.out.println(S.length());
  }
}

Après conversion du double x en chaîne de caractères :

S = Double.toString(x);

il devient possible d’utiliser les méthodes de la classe String pour travailler sur la valeur convertie du double :

System.out.println(S.length());

intValue()

La méthode intValue() retourne la valeur entière de l’objet Double sur lequel elle est appliquée :

public int intValue()

Exemple :

public class Test {
  public static void main (String args[])
  {
    double x = Math.PI;
    Double drr = new Double(x);
    System.out.println(drr.intValue());
  }
}

La première instruction affecte la constante PI à la variable double x :

double x = Math.PI;

La deuxième instruction définit l’objet Double drr à partir de la variable double x :

Double drr = new Double(x);

Enfin, la troisième instruction affiche la valeur entière de l’objet drr :

System.out.println(drr.intValue());

Remarque

Si la valeur à convertir est stockée dans une variable double (et non dans un objet Double), il sera plus simple d’utiliser la syntaxe suivante :

double x = Math.PI;
System.out.println((int) x);

longValue()

La méthode longValue() retourne la valeur entière long de l’objet Double sur lequel elle est appliquée :

public long longValue()

Exemple :

public class Test {
  public static void main (String args[])
  {
    double x = 1486618620.65617;
    Double Dx = new Double(x);
    long Lx = Dx.longValue();
    System.out.println(Lx);
  }
}

La première instruction initialise la variable x :

double x = 1486618620.65617;

La deuxième instruction définit l’objet Double Dx à partir de la variable double x :

Double drr = new Double(x);

La troisième instruction définit la variable long Lx en appliquant la méthode longValue() sur l’objet Double Dx :

long Lx = Dx.longValue();

Remarque

Si la valeur à convertir est stockée dans une variable double (et non dans un objet Double), il sera plus simple d’utiliser la syntaxe suivante :

double x = 1486618620.65617;
long Lx = (long) x;

floatValue()

La méthode floatValue() retourne la valeur réelle float de l’objet Double sur lequel elle est appliquée :

public float floatValue()

Exemple :

public class Test {
  public static void main (String args[]) {
    double x = 1.234567890123456789e12d;
    Double Dx = new Double(x);
    float Fx = Dx.floatValue();
    System.out.println(Fx);
  }
}

La première instruction initialise la variable x :

double x = 1.234567890123456789e12d;

La deuxième instruction définit l’objet Double Dx à partir de la variable double x :

Double drr = new Double(x);

La troisième instruction définit la variable float Fx en appliquant la méthode floatValue() sur l’objet Double Dx :

float Fx = Dx.floatValue();

Remarque

Si la valeur à convertir est stockée dans une variable double (et non dans un objet Double), il sera plus simple d’utiliser la syntaxe suivante :

double x = 1.234567890123456789e12d;
float Fx = (float) x;

doubleValue()

La méthode doubleValue() retourne la valeur réelle double de l’objet Double sur lequel elle est appliquée :

public double doubleValue()

Exemple :

public class Test {
  public static void main (String args[]) throws java.io.IOException {
    double r1;
    char ch;
    String Interm;

    System.out.println("Entrez une valeur réelle double : ");
    Interm = Lit();
    r1=Double.valueOf(Interm).doubleValue();
  }

public static String Lit() throws java.io.IOException {
    String S = "";
    char C;
    while ((C=(char)System.in.read()) != '\r') {
      S = S + C;
    }
    C=(char)System.in.read();
    return S;
  }
}

La fonction Lit() acquiert les caractères tapés au clavier et les retourne sous forme d’une chaîne String lorsque la touche Entrée est pressée.

Dans la procédure main(), un message invite l’utilisateur à entrer une valeur réelle double :

System.out.println("Entrez une valeur réelle double : ");

Les caractères tapés sont ensuite mémorisés et stockés dans la variable String Interm :

Interm = Lit();

L’instruction suivante stocke dans la variable r1 la conversion réelle double de la chaîne Interm :

r1=Double.valueOf(Interm).doubleValue();

Cette instruction peut paraître complexe, voire inextricable ! Regardons-la de plus près. La méthode valueOf(Interm) convertit la chaîne Interm en un objet Double. Cette méthode fait partie de la classe Double. Elle est donc référencée par Double.valueOf(Interm). On applique ensuite la méthode doubleValue() à l’objet Double qui vient d’être défini pour le convertir en un réel double…

hashCode()

Cette méthode retourne le hashcode (chaque objet Java possède un hashcode qui lui est propre) de l’objet sur lequel elle est appliquée :

public int hashCode();

Exemple :

public class Test {
  public static void main (String args[]) {
    double x = 1.234567890123456789e12d;
    Double Dx = new Double(x);
    System.out.println(Dx.hashCode());
  }
}

La troisième instruction de la procédure main affiche le hashcode de l’objet Double précédemment défini :

Double Dx = new Double(x);
System.out.println(Dx.hashCode());

equals()

Cette méthode compare deux objets. Elle renvoie la valeur true si les objets sont identiques et la valeur false dans le cas contraire :

public boolean equals(Object obj)

valueOf()

Cette méthode retourne un objet Double initialisé à la valeur numérique placée dans l’argument String :

public static native Double valueOf(String s) throws NumberFormatException;

Exemple :

Voir la méthode doubleValue().

doubleToLongBits()

Cette méthode renvoie la représentation binaire d’une valeur double :

public static native long doubleToLongBits(double value);
Exemple :
public class Test {
  public static void main (String args[]) {
    double x = 123.456d;
    long binaire = Double.doubleToLongBits(x);
    System.out.println("Valeur initiale : " + x);
    System.out.println("Conversion binaire : " + binaire);
    System.out.println("Conversion binaire->double : " + Double.longBitsToDouble(binaire));
  }
}

Dans un premier temps, une valeur réelle double est stockée dans une variable double :

double x = 123.456d;

Cette variable est convertie en binaire avec la méthode doubleToLongBits() et stockée dans la variable long binaire :

long binaire = Double.doubleToLongBits(x);

La valeur initiale et la conversion binaire sont ensuite affichées :

System.out.println("Valeur initiale : " + x);
System.out.println("Conversion binaire : " + binaire);

Enfin, la valeur binaire est reconvertie en un réel double avec la méthode longBitsToDouble() et affichée :

System.out.println("Conversion binaire->double : " + Double.longBitsToDouble(binaire));

Voici le résultat :

 

 
longBitsToDouble()

Cette méthode renvoie la représentation double d’une valeur binaire :

public static double longBitsToDouble(long bits);

Exemple :

Voir la méthode doubleToLongBits().

parseDouble()

Cette méthode renvoie la représentation String d’un objet Double.

Vous avez aimé cet article ? Partagez-le avec vos réseaux...
 
Comments

No comments yet.

Leave a Reply