Question Convertir Double en entier en Java


N'importe quel moyen de lancer java.lang.Double à java.lang.Integer?

Il jette une exception

"java.lang.ClassCastException: java.lang.Double incompatible avec java.lang.Integer"


287
2018-02-01 19:53


origine


Réponses:


UNE Double n'est pas un Integer, donc la distribution ne fonctionnera pas. Notez la différence entre le Double  classe et le double  primitif. Notez également qu'un Double est un Number, donc il a la méthode  intValue, quand vous pouvez utiliser pour obtenir une primitive int.


394
2018-02-01 19:54



Vous devez explicitement obtenir la valeur int en utilisant la méthode intValue () comme ceci:

Double d = 5.25;
Integer i = d.intValue(); // i becomes 5

Ou

double d = 5.25;
int i = (int) d;

484
2018-02-01 19:56



Je vois trois possibilités. Les deux premiers coupent les chiffres, le dernier arrondit à l'entier le plus proche.

double d = 9.5;
int i = (int)d;
//i = 9

Double D = 9.5;
int i = Integer.valueOf(D.intValue());
//i = 9

double d = 9.5;
Long L = Math.round(d);
int i = Integer.valueOf(L.intValue());
//i = 10

36
2017-11-15 09:53



Je pense qu'il est impossible de comprendre les autres réponses sans couvrir le pièges et raisonnement derrière.

Vous ne pouvez pas directement lancer un Integer à un Double objet. Aussi Double et Integer sont des objets immuables, vous ne pouvez donc les modifier d'aucune façon. Cependant chaque numeric classe a un primitif alternative (Double contre double, Integer contre int, ...).

Notez que ces primitives commencent par un caractère en minuscule (par ex. int), qui nous dit qu’ils ne sont pas des classes / objets. Ce qui signifie également qu'ils n'ont pas de méthodes.

Stratégie:

Pour convertir un Double à un Integer vous auriez besoin de suivre cette stratégie:

  1. Convertir le Double objet à une primitive double. (= "unboxing")
  2. Convertir la primitive double à une primitive int. (= "casting")
  3. Convertir la primitive int retour à Integer objet. (= "boxe")

Dans du code:

// starting point
Double myDouble = Double.valueOf(10.0);

// step 1: unboxing
double dbl = myDouble.doubleValue();

// step 2: casting
int intgr = (int) dbl;

// step 3: boxing
Integer val = Integer.valueOf(intgr);

En fait, il y a un raccourci. Vous pouvez débloquer immédiatement d'un Double directement à un primitif int. De cette façon, vous pouvez ignorer entièrement l'étape 2.

Double myDouble = Double.valueOf(10.0);
Integer val = Integer.valueOf(myDouble.intValue()); // the simple way

Pièges:

Cependant, il y a beaucoup de choses qui ne sont pas couvertes dans le code ci-dessus. Le code ci-dessus est non null-safe.

Double myDouble = null;
Integer val = Integer.valueOf(myDouble.intValue()); // will throw a NullPointerException

// a null-safe solution:
Integer val = (myDouble == null)? null : Integer.valueOf(myDouble.intValue());

Maintenant, cela fonctionne bien pour la plupart des valeurs. Cependant les entiers ont une très petite plage (valeur min / max) par rapport à un Double. En plus de cela, les doubles peuvent aussi contenir des "valeurs spéciales", que les entiers ne peuvent pas:

  • 1/0 = + infini
  • -1/0 = -infinity
  • 0/0 = non défini (NaN)

Donc, en fonction de l'application, vous voudrez peut-être ajouter un peu de filtrage pour éviter de mauvaises exceptions.

La prochaine lacune est la stratégie d’arrondi. Par défaut, Java s'arrêtera toujours. Arrondir est parfaitement logique dans tous les langages de programmation. Fondamentalement, Java ne fait que jeter certains des octets. Dans les applications financières, vous voudrez certainement utiliser l'arrondi à la demi-hauteur (p. round(0.5) = 1 et round(0.4) = 0).

// null-safe and with better rounding
long rounded = (myDouble == null)? 0L: Math.round(myDouble.doubleValue());
Integer val = Integer.valueOf(rounded);

Auto- (dé) boxe

Vous pourriez être tenté d'utiliser auto- (dé) boxe en cela, mais je ne le ferais pas. Si vous êtes déjà coincé maintenant, alors les exemples suivants ne seront pas si évidents non plus. Si vous ne comprenez pas le fonctionnement interne de la boxe automatique, veuillez ne pas l'utiliser.

Integer val1 = 10; // works
Integer val2 = 10.0; // doesn't work

Double val3 = 10; // doesn't work
Double val4 = 10.0; // works

Double val5 = null; 
double val6 = val5; // doesn't work (throws a NullPointerException)

Je suppose que ce qui suit ne doit pas être une surprise. Mais si c'est le cas, alors vous pouvez lire un article sur le casting en Java.

double val7 = (double) 10; // works
Double val8 = (Double) Integer.valueOf(10); // doesn't work
Integer val9 = (Integer) 9; // pure nonsense

Préférer valueOf:

Aussi, ne soyez pas tenté d'utiliser new Integer() constructeur (comme d'autres réponses le proposent). le valueOf() les méthodes sont meilleures car elles utilisent la mise en cache. C'est une bonne habitude d'utiliser ces méthodes, car de temps en temps elles vous épargneront de la mémoire.

long rounded = (myDouble == null)? 0L: Math.round(myDouble.doubleValue());
Integer val = new Integer(rounded); // waste of memory

33
2017-10-27 14:15



Comme ça:

Double foo = 123.456;
Integer bar = foo.intValue();

20
2018-02-01 20:00



En effet, le moyen le plus simple est d'utiliser intValue(). Cependant, cela ne fait que renvoyer la partie entière; il n'y a pas d'arrondi. Si vous voulez l'entier la plus proche à la valeur double, vous devrez faire ceci:

Integer integer = Integer.valueOf((int) Math.round(myDouble)));

Et n'oublie pas le cas nul:

Integer integer = myDouble == null ? null : Integer.valueOf((int) Math.round(myDouble)));

Math.round() traite les cas de canard impair, comme l'infini et NaN, avec grâce relative.


19
2017-07-18 02:16



double a = 13.34;
int b = (int) a;

System.out.println(b); //prints 13

13
2018-03-11 12:39



Double d = 100.00;
Integer i = d.intValue();

Il faut aussi ajouter que cela fonctionne avec l'autoboxing.

Sinon, vous obtenez un int (primitif) et ensuite vous pouvez obtenir un entier à partir de là:

Integer i = new Integer(d.intValue());

6
2017-12-04 10:39