Любой способ привести java.lang.Doubleк java.lang.Integer?

Это исключение

"java.lang.ClassCastException: java.lang. Double несовместим с java.lang.Integer"

А Doubleне является Integer, поэтому актерский состав не будет работать. Обратите внимание на разницу между Double классом и double примитивом . Также обратите внимание, что a Doubleявляется a Number, поэтому у него есть метод intValue , который можно использовать для получения значения в качестве примитива int.

Вам нужно явно получить значение int, используя метод intValue (), например:

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

Или

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

Я думаю, что невозможно понять другие ответы, не скрывая ошибок и рассуждений .

Вы не можете напрямую привести объект Integerк Doubleобъекту. Также DoubleиInteger являются неизменяемыми объектами, поэтому вы не можете их никоим образом изменять.

Каждый числовой класс имеет примитивную альтернативу ( Doublevs double, Integervs int, ...). Обратите внимание, что эти примитивы начинаются со строчной буквы (например, int). Это говорит нам о том, что они не являются классами / объектами. Что также означает, что у них нет методов. В отличие от классов (например,Integer ) действуют как коробки / оболочки вокруг этих примитивов, что позволяет использовать их как объекты.

Стратегия:

Чтобы преобразовать a Doubleв a Integerвам нужно следовать этой стратегии:

1. Преобразовать Doubleобъект в примитивdouble . (= "распаковка")
2. Преобразовать примитив doubleв примитивint . (= "кастинг")
3. Преобразуйте примитив intобратно в Integerобъект. (= "бокс")

В коде:

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

На самом деле есть ярлык. Вы можете распаковать сразу с Doubleпрямой на примитив int. Таким образом, вы можете полностью пропустить шаг 2.

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

Ловушки:

Тем не менее, есть много вещей, которые не охвачены в коде выше. Код выше не является нулевым.

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

Теперь он работает нормально для большинства значений. Однако целые числа имеют очень маленький диапазон (минимальное / максимальное значение) по сравнению с Double. Кроме того, double также может содержать «специальные значения», которые целые числа не могут:

• 1/0 = + бесконечность
• -1/0 = -infinity
• 0/0 = не определено (NaN)

Поэтому, в зависимости от приложения, вы можете захотеть добавить фильтрацию, чтобы избежать неприятных исключений.

Тогда следующим недостатком является стратегия округления. По умолчанию Java всегда будет округляться. Округление вниз имеет смысл во всех языках программирования. По сути, Java просто отбрасывает некоторые байты. В финансовых приложениях вы наверняка захотите использовать округление до половины (например: round(0.5) = 1и round(0.4) = 0).

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

Автомототехника (ип) бокс

Вы могли бы испытать желание использовать авто (не) бокс в этом, но я бы не стал. Если вы уже застряли сейчас, то и следующие примеры не будут такими очевидными. Если вы не понимаете внутреннюю работу авто (не) бокса, то, пожалуйста, не используйте его.

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)

Я думаю, что следующее не должно быть сюрпризом. Но если это так, то вы можете прочитать статью о приведении в Java.

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

Предпочитаю valueOf:

Кроме того, не поддавайтесь искушению использовать new Integer()конструктор (как предлагают некоторые другие ответы). Эти valueOf()методы лучше , потому что они используют кэширование. Это хорошая привычка использовать эти методы, потому что время от времени они будут экономить память.

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

Я вижу три возможности. Первые две обрезают цифры, последние округляют до ближайшего целого числа.

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

Как это:

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

Действительно, самый простой способ - это использовать intValue(). Однако это просто возвращает целочисленную часть; это не делает никакого округления. Если вы хотите, чтобы Integer ближайший к значению Double, вам нужно сделать это:

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

И не забывайте нулевой случай:

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

Math.round() обрабатывает странные случаи утки, как бесконечность и NaN, с относительной грацией.

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

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

Просто сделай это так ...

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

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

Следует также добавить, что он работает с автобоксом.

В противном случае вы получаете int (примитив), а затем можете получить Integer оттуда:

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

Звони intValue()на свой Doubleобъект.

Вы можете сделать это, используя «Сужение или явное преобразование типов», double → long → int. Я надеюсь, что это сработает.

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

PS: он даст 0, так как double имеет все десятичные значения и ничего в левой части. В случае 0,58 это сузит его до 0. Но для других это сделает магию.

Попробуй это

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

Double и Integer являются классами-обертками для примитивов Java для double и int соответственно. Вы можете разыгрывать между ними, но вы потеряете плавающую точку. То есть 5.4, приведенное к int, будет 5. Если вы приведете его обратно, это будет 5.0.

Просто используйте метод intValue Double

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

Используйте doubleNumber.intValue();метод.

Память эффективна, так как будет разделять уже созданный экземпляр Double.

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

Это сработало для меня. Попробуй это:

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