vous devez obtenir explicitement 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;

je vois trois possibilités. Les deux premiers coupent les chiffres, le dernier tourne vers 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

je pense qu'il est impossible de comprendre les autres réponses sans couvrir les pièges et raisonnements derrière elle.

vous ne pouvez pas lancer directement un Integer sur un objet Double . Aussi Double et Integer sont des objets immuables, de sorte que vous ne pouvez pas les modifier. Cependant chaque classe numérique a un primitif alternative ( Double vs double , Integer vs int ,...).

notez que ces primitives commencent avec un caractère en minuscules (par exemple int ), qui nous dit en fait qu'elles ne sont pas des classes/objets. Ce qui signifie également qu'ils n'ont pas les méthodes.

stratégie:

pour convertir un Double en un Integer vous devez suivre cette stratégie:

1. convertir la Double objet à une primitive double . (="unboxing")
2. convertissez le primitif double en un primitif int . (="casting")
3. convertissez le primitif int de retour à un objet Integer . (= "la boxe")

dans le 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 passer immédiatement d'un Double directement à un int primitif . De cette façon, vous pouvez sauter l'étape 2 entièrement.

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, il fonctionne très bien pour la plupart des valeurs. Cependant, les entiers ont une très petite portée (valeur min/max) par rapport à un Double . En plus de cela, les doubles peuvent aussi tenir des "valeurs spéciales", que les entiers ne peut pas:

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

ainsi, selon l'application, vous pouvez vouloir ajouter un certain filtrage pour éviter de mauvaises Exceptions.

ensuite, la prochaine lacune est la stratégie d'arrondissement. Par défaut, Java va toujours arrondir vers le bas. Arrondir vers le bas est parfaitement logique dans tous les langages de programmation. Fondamentalement Java jette juste quelques octets. Dans les applications financières, vous voudrez sûrement utiliser l'arrondissement à moitié (par exemple: 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-(onu)de la boxe

vous pourriez être tenté d'utiliser auto - (un) boxe dans ceci, mais je ne le ferais pas. Si vous êtes déjà coincé maintenant, alors les prochains exemples ne seront pas si évident non plus. Si vous ne comprenez pas le fonctionnement interne de l'auto - (un)boxe alors s'il vous plaît 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 devrait pas être une surprise. Mais si c'est le cas, alors vous voudrez peut-être 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èrent valueOf:

aussi, ne soyez pas tenté d'utiliser le constructeur new Integer() (comme d'autres réponses le proposent). Les méthodes valueOf() sont meilleures parce qu'elles utilisent la mise en cache. C'est une bonne habitude d'utiliser ces méthodes, car de temps à le temps ils vous feront économiser un peu de mémoire.

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

en effet, la manière la plus simple est d'utiliser intValue() . Cependant, cela renvoie simplement la partie entière; il ne fait pas d'arrondissement. Si vous voulez L'entier le plus proche de la valeur Double, vous aurez besoin de faire ceci:

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

et n'oubliez pas le cas null:

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

Math.round() s'occupe de cas de canards impairs, comme l'infini et NaN, avec une relative grâce.

comme ceci:

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

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

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

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

, il faut ajouter qu'il fonctionne avec l'autoboxing.

sinon, vous obtenez un int (primitif) et puis vous pouvez obtenir un entier de là:

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

faites-le simplement de cette façon...

Double d = 13.5578;
int i = d.intValue();
System.out.println(i);

Appel intValue() sur votre Double objet.

vous pouvez faire cela en utilisant " rétrécissement ou Conversion de type explicite", double → long → int. J'espère que cela va fonctionner.

double d = 100.04;
long l = (long)d; // Explicit type casting required
int i = (int)l;    // Explicit type casting required

PS: il donnera 0 comme double a toutes les valeurs décimales et rien sur le côté gauche. Dans le cas de 0.58, il sera réduit à 0. Mais pour d'autres, il va faire de la magie.

Essayer celui-ci

double doubleValue = 6.5;Double doubleObj = new Double(doubleValue);int intResult = doubleObj.intValue();

Double et entier sont des classes d'enrubannage pour primitives Java pour double et int respectivement. Vous pouvez lancer entre ceux-ci, mais vous perdrez la pointe flottante. C'est, 5.4 coulé int sera de 5. Si vous le rejetez, il sera de 5.0.

il suffit D'utiliser la méthode intValue de Double

Double initialValue = 7.12;
int finalValue = initialValue.intValue();

utiliser la méthode doubleNumber.intValue(); .

efficace en mémoire, car il partagera l'instance déjà créée de Double.

Double.valueOf(Math.floor(54644546464/60*60*24*365)).intValue()

ça a marché pour moi. Essayez ceci:

double od = Double.parseDouble("1.15");
int oi = (int) od;