You need to explicitly get the int value using method intValue() like this:

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

Or

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

I think it's impossible to understand the other answers without covering the pitfalls and reasoning behind it.

You cannot directly cast an Integer to a Double object. Also Double and Integer are immutable objects, so you cannot modify them in any way.

Each numeric class has a primitive alternative (Double vs double, Integer vs int, ...). Note that these primitives start with a lowercase character (e.g. int). That tells us that they aren't classes/objects. Which also means that they don't have methods. By contrast, the classes (e.g. Integer) act like boxes/wrappers around these primitives, which makes it possible to use them like objects.

Strategy:

To convert a Double to an Integer you would need to follow this strategy:

1. Convert the Double object to a primitive double. (= "unboxing")
2. Convert the primitive double to a primitive int. (= "casting")
3. Convert the primitive int back to an Integer object. (= "boxing")

In 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); 

Actually there is a shortcut. You can unbox immediately from a Double straight to a primitive int. That way, you can skip step 2 entirely.

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

Pitfalls:

However, there are a lot of things that are not covered in the code above. The code-above is not 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()); 

Now it works fine for most values. However integers have a very small range (min/max value) compared to a Double. On top of that, doubles can also hold "special values", that integers cannot:

• 1/0 = +infinity
• -1/0 = -infinity
• 0/0 = undefined (NaN)

So, depending on the application, you may want to add some filtering to avoid nasty Exceptions.

Then, the next shortcoming is the rounding strategy. By default Java will always round down. Rounding down makes perfect sense in all programming languages. Basically Java is just throwing away some of the bytes. In financial applications you will surely want to use half-up rounding (e.g.: round(0.5) = 1 and 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-(un)boxing

You could be tempted to use auto-(un)boxing in this, but I wouldn't. If you're already stuck now, then the next examples will not be that obvious neither. If you don't understand the inner workings of auto-(un)boxing then please don't use it.

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) 

I guess the following shouldn't be a surprise. But if it is, then you may want to read some article about casting in Java.

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

Prefer valueOf:

Also, don't be tempted to use new Integer() constructor (as some other answers propose). The valueOf() methods are better because they use caching. It's a good habit to use these methods, because from time to time they will save you some memory.

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

I see three possibilities. The first two cut off the digits, the last one rounds to the nearest Integer.

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 

Indeed, the simplest way is to use intValue(). However, this merely returns the integer part; it does not do any rounding. If you want the Integer nearest to the Double value, you'll need to do this:

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

And don't forget the null case:

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

Math.round() handles odd duck cases, like infinity and NaN, with relative grace.

Like this:

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

double a = 13.34; int b = (int) a; System.out.println(b); //prints 13 

Simply do it this way...

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

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

One should also add that it works with autoboxing.

Otherwise, you get an int (primitive) and then can get an Integer from there:

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

Call intValue() on your Double object.

You can do that by using "Narrowing or Explicit type conversion", double → long → int. I hope it will work.

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

PS: It will give 0 as double has all the decimal values and nothing on the left side. In case of 0.58, it will narrow it down to 0. But for others it will do the magic.

Try this:

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

Double and Integer are wrapper classes for Java primitives for double and int respectively. You can cast between those, but you will lose the floating point. That is, 5.4 casted to an int will be 5. If you cast it back, it will be 5.0.

Alternatively, one can first cast to primitive double, then cast to int, letting it be autoboxed to Integer.

Double d = 20.3; Integer i = (int) (double) d; //20 //To obtain primitive: int i2 = (int) (double) d; 

Simply use the intValue method of Double

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

Use the doubleNumber.intValue(); method.

First thing you should use Double not double.

Example

int intResult = newDoubleObj.intValue();

Memory efficient, as it will share the already created instance of Double.

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