double != DoubleRésolu

Question

Bonjour à tous,
est ce que quelqu'un pourrait m'expliquer clairement la différence entre un double et un Double.
En fait j'ai un calcul : avec beam en double et W en Double
beam = (1.22 * 2.99E8)/ (nu.doubleValue() * 1E6 ) /30;
                        	beam = (beam / Math.PI) * 180 * 3600;
                        	System.out.println(beam);
                        	if(beam > 30)
                        	{
                        		facteur = (1 - Math.cos(beam)) / ( 1 - Math.cos(30));
                                         //cette ligne ne focntionne pas???
                        		W = W.doubleValue() * facteur ;
                        		
                        		
                        	} 

à savoir que je ne veux pas changer mon W en double car je vais le chercher dans un fichier avec cette méthode :  W = Double.valueOf(exploded[1]);
donc à moins qu'il y es une façon de faire en le mettant en double....

voilà je sais pas si je suis très claire mais j'aimerai en résumé savoir la différence entre un double et un Double

merci à tous bonne continuation
lafolle

Twinuts · Accepted Answer

Salut,

Double est simplement la classe wrapper associée au type primitif double (idem pour int->Integer, boolean->Boolean, etc..)

voici une liste des types et leurs wrapper :

Primitive, Wrapper, ----
boolean,   java.lang.Boolean, ----
byte,   java.lang.Byte, ----
char,   java.lang.Character, ----
double,   java.lang.Double, ----
float,   java.lang.Float, ----
int,   java.lang.Integer, ----
long,   java.lang.Long, ----
short,   java.lang.Short, ----
void
,   java.lang.Void

pour une explication sur le pourquoi du comment vas ICI

------------------------------------
"On n'est pas au resto : ici on ne fait pas dans les plats tout cuits ..."

WORA

Twinuts · Answer

Sinon petit complement

http://cui.unige.ch/java/JAVAF/type_wrappers.html

------------------------------------
"On n'est pas au resto : ici on ne fait pas dans les plats tout cuits ..."

WORA

lafolle24320 · Answer

nickel!!!

encore une fois un grand merci!!!

bonne journée
lafolle

verdy_p · Answer

Autre différence notable:
* les "double" ne sont pas des objets, on les passe donc par valeur uniquement dans les appels de méthodes, et il n'y a pas besoin de les allouer en mémoire avec "new", le problème est qu'il ne peut pas faire partie des Collections standard (qui veulent des références d'objets). Si on passe un variable "double" en paramètre d'une méthode, cette méthode ne peut pas modifier cette variable, car elle ne fera que modifier la variable locale copiée en paramètre sans aucun effet dans la variable de l'appelant.
* les "Double" sont des objets, on les passe donc uniquement par référence dans les appels de méthodes. Si on les passe en tant que variables dans un appel de méthode, la méthode pourrait théoriquement en modifier la valeur, cependant les "Double" sont immuables il n'y a pas de méthode setValue(double), cependant on pourrait éventuellement y arriver en utilisant Reflection pour lever la restriction d'accès à son champ privé interne "value", ce qui est vivement déconseillé car les objets immuables des classes de base du JRE ont souvent des instances partagées (par exemple "new Double(0.0)" pourrait retourner chaque fois la même instance qui peut être dans un cache, et modifier cette instance supposée immuable aura des effets de bord dans de nombreux endroits).

L'intérêt des Double (ou des autres "wrappers" de types natifs) est que ce sont des objets et donc des références valides utilisables dans les collections. Leur allocation avec "new Double()" n'est pas couteuse car la JVM les alloue dans des tas optimisés pour une allocation rapide (car leur taille est fixe, petite, et une puissance de 2, ce qui facilite énormément le travail du ramasse-miettes ("Garbage Collector" ) lors des opérations de compactage Mark&Sweep: le marquage est standard comme pour les autres objets, le "sweep" n'a aucune difficulté à déplacer ces petits objets dans des blocs libres de taille identique laissés par les autres wrappers libérés.

Pour pouvoir passer des références mutables à des doubles, le mieux reste d'écrire son propre wrapper, dont un des plus simples est :

public class MutableDouble {
  protected double value;
  public MutableDouble(double value) { this.value = value; }
  public MutableDouble() { this(0.0); }
  public double getValue() { return this.value; }
  public void setValue(double value) { this.value = value; }
}

On peut lui rajouter les quelques méthodes pour rendre ce wrapper Comparable, cependant les collections qui n'admettent pas de valeurs en doublons peuvent poser problème: en effet les collections par défaut se contentent seulement de repérer les doublons de références d'objets et non de leurs valeurs, et si la collection est supposée triée ou unique, modifier une instance peut changer le comportement attendu; c'est pour ça que les Double sont non mutables par défaut, leur champ "value" est privé, et il n'ont aucun setter comme ici. Pour ces raisons, les wrappers mutables comme ici n'ont pas besoin de protéger leur valeur, et l'utilisation des méthodes getter/setter est superflue, et on peut se contenter d'exposer publiquement le champ value dans MutableDouble. Cela satisfera aux besoins des méthodes qui doivent retourner plusieurs valeurs dans des variables références mutables passées en paramètres, cependantril est plus courant d'encapsuler toutes ces variables mutables ensemble dans un même objet mutable (ou un tableau si elles sont de même type).

Double != Double

4 réponses

Votre réponse

Discussions similaires