Döküm için herhangi bir şekilde java.lang.Doublekarşı java.lang.Integer?

Bir istisna atar

"java.lang.ClassCastException: java.lang.Double, java.lang.Integer ile uyumsuz"

A Doublebir değildir Integer, bu yüzden oyuncular çalışmaz. Double Sınıf ve double ilkel arasındaki farka dikkat edin . Ayrıca a'nın a Doubleolduğunu unutmayın Number, bu nedenle intValue değeri ilkel olarak almak için kullanabileceğiniz yönteme sahiptirint .

İntValue () yöntemini kullanarak int değerini açıkça almanız gerekir:

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

Veya

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

Tuzakları örtmeden ve arkasındaki akıl yürütmeden diğer cevapları anlamak imkansız .

Doğrudan Integerbir Doublenesneye yayınlayamazsınız. Ayrıca Doubleve Integerdeğişmez nesnelerdir, böylece onları hiçbir şekilde değiştiremezsiniz.

Her sayısal sınıfı bir sahiptir ilkel bir alternatif ( Doublevs double, Integervs int, ...). Bu ilkellerin küçük harfle (örn. int) Başladığını unutmayın . Bu bize onların sınıf / nesne olmadığını söyler. Bu da yöntemlerinin olmadığı anlamına gelir. Aksine, sınıflar (örn. Integer) Bu ilkellerin etrafında kutular / ambalajlar gibi davranırlar, bu da onları nesneler gibi kullanmayı mümkün kılar.

Strateji:

Bir dönüştürmek için Doublebir karşı Integerbu stratejiyi takip etmek gerekir:

1. DoubleNesneyi bir ilkeye dönüştürün double. (= "kutudan çıkarılıyor")
2. İlkel dönüştürme doublebir nesnenin üstüne int. (= "döküm")
3. İlkel intbir Integernesneyi geri dönüştürün . (= "boks")

Kodda:

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

Aslında bir kısayol var. Derhal Doublebir ilkelden bir ilkeye kutudan çıkabilirsiniz int. Bu şekilde, 2. adımı tamamen atlayabilirsiniz.

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

tuzaklar:

Ancak, yukarıdaki kodda yer almayan birçok şey var. Yukarıdaki kod null için güvenli değildir.

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

Şimdi çoğu değer için iyi çalışıyor. Ancak tamsayılar a ile karşılaştırıldığında çok küçük bir aralığa (min / maks değer) sahiptir Double. Bunun da ötesinde, çiftler "özel değerler" tutabilir, tamsayılar şunları yapamaz:

• 1/0 = + sonsuz
• -1/0 =-sonsuzluk
• 0/0 = tanımsız (NaN)

Yani, uygulamaya bağlı olarak, kötü İstisnalar önlemek için bazı filtreleme eklemek isteyebilirsiniz.

Sonra bir sonraki eksiklik yuvarlama stratejisidir. Varsayılan olarak Java her zaman aşağı yuvarlanır. Yuvarlama tüm programlama dillerinde mükemmel bir anlam ifade eder. Temelde Java sadece bazı baytları atıyor. Finansal uygulamalarda kesinlikle yarım yukarı yuvarlamayı kullanmak isteyeceksiniz (örneğin: round(0.5) = 1ve round(0.4) = 0).

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

Otomatik (me) boks

Bunda otomatik- (un) boks kullanmak cazip olabilir , ama yapmazdım. Şimdi takılmışsanız, sonraki örnekler de o kadar açık olmayacaktır. Otomatik (un) boksun iç işleyişini anlamıyorsanız, lütfen kullanmayın.

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)

Sanırım aşağıdakiler sürpriz olmamalı. Ancak öyleyse, Java'da döküm hakkında bazı makaleleri okumak isteyebilirsiniz.

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

Değeri tercih et:

Ayrıca, yapıcıyı kullanmak için cazip olmayın new Integer()(diğer bazı cevapların önerdiği gibi). valueOf()Onlar önbelleğe alma kullandıkları için yöntemler iyidir. Bu yöntemleri kullanmak iyi bir alışkanlıktır, çünkü zaman zaman size biraz hafıza kazandıracaklardır.

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

Üç olasılık görüyorum. İlk ikisi basamakları keser, sonuncusu en yakın Tamsayıya yuvarlar.

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

Bunun gibi:

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

Gerçekten de, en basit yol kullanmaktır intValue(). Ancak, bu yalnızca tamsayı kısmını döndürür; herhangi bir yuvarlama yapmaz. Tamsayının Çift değerine en yakın olmasını istiyorsanız , bunu yapmanız gerekir:

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

Ve boş durumu unutmayın:

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

Math.round() sonsuzluk ve NaN gibi garip ördek vakalarını göreceli zarafetle ele alır.

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

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

Sadece bu şekilde yapın ...

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

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

Ayrıca, otomatik boks ile çalıştığını da eklemelisiniz.

Aksi takdirde, bir int (ilkel) alırsınız ve oradan bir Tamsayı alabilirsiniz:

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

Çağrı intValue()senin üzerinde Doublenesne.

Bunu "Daralma veya Açık tür dönüştürme", çift → uzun → int kullanarak yapabilirsiniz. Umarım işe yarar.

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

Not: Çiftin tüm ondalık değerlere sahip olduğu ve sol tarafta hiçbir şey olmadığı için 0 verecektir. 0.58 olması durumunda, onu 0'a daraltacaktır. Ancak diğerleri için sihri yapacak.

Bunu dene

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

Double ve Integer, sırasıyla double ve int için Java ilkelleri için sarma sınıflarıdır. Bunlar arasında döküm yapabilirsiniz, ancak kayan noktayı kaybedeceksiniz. Yani, bir int için dökülen 5.4 5 olacaktır. Eğer geri atarsanız, 5.0 olacaktır.

Double'in intValue yöntemini kullanmanız yeterlidir

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

doubleNumber.intValue();Yöntemi kullanın .

Halihazırda oluşturulmuş olan Double örneğini paylaşacağı için bellek verimli.

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

Benim için çalıştı. Bunu dene:

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