Qualquer forma de elenco java.lang.Doublepara java.lang.Integer?

Isso lança uma exceção

"java.lang.ClassCastException: java.lang.Double incompatível com java.lang.Integer"

A Doublenão é um Integer, então o elenco não funcionará. Observe a diferença entre a Double classe e o double primitivo . Observe também que a Doubleé a e Number, portanto, possui o método intValue , que você pode usar para obter o valor como primitivo int.

Você precisa obter explicitamente o valor int usando o método intValue () como este:

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

Ou

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

Eu acho que é impossível entender as outras respostas sem cobrir as armadilhas e o raciocínio por trás disso.

Você não pode converter diretamente um Integerem um Doubleobjeto. Também Doublee Integersão objetos imutáveis, então você não pode modificá-los de qualquer forma.

Cada classe numérica tem uma alternativa primitiva ( Doublevs double, Integervs int, ...). Observe que essas primitivas começam com um caractere minúsculo (por exemplo int). Isso nos diz que eles não são classes / objetos. O que também significa que eles não têm métodos. Por outro lado, as classes (por exemplo Integer) agem como caixas / invólucros em torno dessas primitivas, o que torna possível usá-las como objetos.

Estratégia:

Para converter um Doubleem um, Integervocê precisa seguir esta estratégia:

1. Converta o Doubleobjeto em um primitivo double. (= "unboxing")
2. Converta o primitivo doubleem um primitivo int. (= "transmissão")
3. Converta a primitiva de intvolta em um Integerobjeto. (= "boxe")

Em código:

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

Na verdade, há um atalho. Você pode desembalar imediatamente de um Doubledireto para um primitivo int. Dessa forma, você pode pular a etapa 2 completamente.

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

Armadilhas:

No entanto, existem muitas coisas que não são abordadas no código acima. O código acima não é seguro para nulos.

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

Agora funciona bem para a maioria dos valores. No entanto, números inteiros têm um intervalo muito pequeno (valor mínimo / máximo) em comparação com a Double. Além disso, duplos também podem conter "valores especiais", que números inteiros não podem:

• 1/0 = + infinito
• -1/0 = -in infinito
• 0/0 = indefinido (NaN)

Portanto, dependendo do aplicativo, você pode adicionar alguns filtros para evitar exceções desagradáveis.

Então, a próxima falha é a estratégia de arredondamento. Por padrão, o Java sempre será arredondado para baixo. O arredondamento faz todo o sentido em todas as linguagens de programação. Basicamente, o Java está apenas jogando fora alguns dos bytes. Em aplicações financeiras, você certamente desejará usar arredondamentos para metade (por exemplo: round(0.5) = 1e 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- (des) boxe

Você pode ficar tentado a usar o auto- (des) boxe nisto, mas eu não usaria. Se você já está preso agora, os próximos exemplos também não serão tão óbvios. Se você não entender o funcionamento interno do auto- (des) boxe, não o utilize.

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)

Eu acho que o seguinte não deve ser uma surpresa. Mas, se for, você pode ler um artigo sobre transmissão em Java.

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

Preferir valorDe:

Além disso, não fique tentado a usar o new Integer()construtor (como algumas outras respostas propõem). Os valueOf()métodos são melhores porque eles usam cache. É um bom hábito usar esses métodos, porque de tempos em tempos eles economizam um pouco de memória.

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

Eu vejo três possibilidades. Os dois primeiros cortam os dígitos, o último arredonda para o número inteiro mais próximo.

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

Como isso:

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

De fato, a maneira mais simples é usar intValue(). No entanto, isso apenas retorna a parte inteira; não faz nenhum arredondamento. Se você deseja que o número inteiro mais próximo do valor duplo, faça o seguinte:

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

E não esqueça o caso nulo:

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

Math.round() lida com casos estranhos de patos, como infinito e NaN, com relativa graça.

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

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

Simplesmente faça desta maneira ...

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

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

Também se deve acrescentar que funciona com autoboxing.

Caso contrário, você obtém um int (primitivo) e pode obter um número inteiro a partir daí:

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

Chame intValue()seu Doubleobjeto.

Você pode fazer isso usando "Conversão de tipo restrito ou explícito", duplo → longo → int. Espero que funcione.

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

PS: Dará 0, pois o dobro tem todos os valores decimais e nada no lado esquerdo. No caso de 0,58, o valor será reduzido a 0. Mas, para outros, ele fará a mágica.

Tente este

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

Double e Inteiro são classes de wrapper para primitivas Java para double e int, respectivamente. Você pode converter entre eles, mas perderá o ponto flutuante. Ou seja, 5.4 convertido para um int será 5. Se você convertê-lo de volta, será 5.0.

Basta usar o método intValue de Double

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

Use o doubleNumber.intValue();método

Memória eficiente, pois compartilhará a instância já criada do Double.

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

Funcionou para mim. Tente o seguinte:

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