Jawaban:
A Double
bukan Integer
, jadi para pemain tidak akan bekerja. Perhatikan perbedaan antara Double
kelas dan double
primitif . Perhatikan juga bahwa a Double
adalah a Number
, sehingga memiliki metode intValue
, yang dapat Anda gunakan untuk mendapatkan nilai sebagai primitif int
.
intValue()
.
intValue()
, itu hanya melemparkan double
ke int
.
Anda perlu secara eksplisit mendapatkan nilai int menggunakan metode intValue () seperti ini:
Double d = 5.25;
Integer i = d.intValue(); // i becomes 5
Atau
double d = 5.25;
int i = (int) d;
2^31 - 1 (Integer.MAX_VALUE)
akan meluap.
1.6 -> 1
, 1.4 -> 1
, -1.6 -> -1
, -1.4 -> -1
,
Saya pikir tidak mungkin untuk memahami jawaban lain tanpa menutupi perangkap dan alasannya di baliknya.
Anda tidak dapat secara langsung melemparkan sebuah Integer
ke Double
objek. Juga Double
danInteger
merupakan objek yang tidak dapat diubah, sehingga Anda tidak dapat memodifikasinya dengan cara apa pun.
Setiap kelas numerik memiliki alternatif primitif ( Double
vs double
, Integer
vs int
, ...). Perhatikan bahwa primitif ini dimulai dengan karakter huruf kecil (mis int
.). Itu memberitahu kita bahwa mereka bukan kelas / objek. Yang juga berarti mereka tidak memiliki metode. Sebaliknya, kelas (misalnya Integer
) bertindak seperti kotak / pembungkus di sekitar primitif ini, yang memungkinkan untuk menggunakannya sebagai objek.
Untuk mengonversi a Double
menjadi Integer
Anda harus mengikuti strategi ini:
Double
objek menjadi primitif double
. (= "unboxing")double
menjadi primitif int
. (= "casting")int
kembali ke Integer
objek. (= "tinju")// 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);
Sebenarnya ada jalan pintas. Anda dapat segera menghapus kotak dari Double
langsung ke primitif int
. Dengan begitu, Anda dapat melewati langkah 2 seluruhnya.
Double myDouble = Double.valueOf(10.0);
Integer val = Integer.valueOf(myDouble.intValue()); // the simple way
Namun, ada banyak hal yang tidak tercakup dalam kode di atas. Kode di atas bukan nol-aman.
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());
Sekarang berfungsi dengan baik untuk sebagian besar nilai. Namun bilangan bulat memiliki rentang yang sangat kecil (nilai min / maks) dibandingkan dengan a Double
. Selain itu, ganda juga bisa menampung "nilai khusus", yang tidak bisa:
Jadi, tergantung pada aplikasinya, Anda mungkin ingin menambahkan beberapa pemfilteran untuk menghindari Pengecualian yang buruk.
Kemudian, kelemahan selanjutnya adalah strategi pembulatan. Secara default, Java akan selalu dibulatkan ke bawah. Membulatkan ke bawah masuk akal dalam semua bahasa pemrograman. Pada dasarnya Java hanya membuang beberapa byte. Dalam aplikasi keuangan Anda pasti ingin menggunakan pembulatan setengah-atas (misalnya: round(0.5) = 1
dan round(0.4) = 0
).
// null-safe and with better rounding
long rounded = (myDouble == null)? 0L: Math.round(myDouble.doubleValue());
Integer val = Integer.valueOf(rounded);
Anda bisa tergoda untuk menggunakan tinju otomatis (tidak) dalam hal ini, tapi saya tidak mau. Jika Anda sudah terjebak sekarang, maka contoh-contoh selanjutnya juga tidak akan terlalu jelas. Jika Anda tidak mengerti cara kerja dalam dari tinju otomatis maka jangan gunakan.
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)
Saya kira yang berikut ini seharusnya tidak mengejutkan. Tetapi jika ya, maka Anda mungkin ingin membaca beberapa artikel tentang casting di Jawa.
double val7 = (double) 10; // works
Double val8 = (Double) Integer.valueOf(10); // doesn't work
Integer val9 = (Integer) 9; // pure nonsense
Juga, jangan tergoda untuk menggunakan new Integer()
konstruktor (karena beberapa jawaban lain mengusulkan). The valueOf()
metode yang lebih baik karena mereka menggunakan caching. Merupakan kebiasaan yang baik untuk menggunakan metode ini, karena dari waktu ke waktu mereka akan menghemat sedikit memori.
long rounded = (myDouble == null)? 0L: Math.round(myDouble.doubleValue());
Integer val = new Integer(rounded); // waste of memory
Saya melihat tiga kemungkinan. Dua yang pertama memotong digit, yang terakhir putaran ke Integer terdekat.
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
Seperti ini:
Double foo = 123.456;
Integer bar = foo.intValue();
Memang, cara paling sederhana adalah menggunakan intValue()
. Namun, ini hanya mengembalikan bagian integer; tidak melakukan pembulatan. Jika Anda ingin Integer terdekat dengan nilai Double, Anda harus melakukan ini:
Integer integer = Integer.valueOf((int) Math.round(myDouble)));
Dan jangan lupa kasus nol:
Integer integer = myDouble == null ? null : Integer.valueOf((int) Math.round(myDouble)));
Math.round()
menangani kasus bebek aneh, seperti tak terbatas dan NaN, dengan rahmat yang relatif.
double a = 13.34;
int b = (int) a;
System.out.println(b); //prints 13
Lakukan saja dengan cara ini ...
Double d = 13.5578;
int i = d.intValue();
System.out.println(i);
Double d = 100.00;
Integer i = d.intValue();
Orang juga harus menambahkan bahwa ia bekerja dengan autoboxing.
Jika tidak, Anda mendapatkan int (primitif) dan kemudian bisa mendapatkan Integer dari sana:
Integer i = new Integer(d.intValue());
new Integer(int)
, sebaliknya gunakan Integer.valueOf(int)
, yang memiliki cache untuk bilangan bulat kecil, seperti ini.
Anda dapat melakukannya dengan menggunakan "Konversi tipe sempit atau Eksplisit", gandakan → panjang → int. Saya harap ini akan berhasil.
double d = 100.04;
long l = (long)d; // Explicit type casting required
int i = (int)l; // Explicit type casting required
PS: Ini akan memberikan 0 sebagai ganda memiliki semua nilai desimal dan tidak ada di sisi kiri. Dalam hal 0,58, itu akan mempersempitnya menjadi 0. Tetapi bagi orang lain itu akan melakukan keajaiban.
Coba yang ini
double doubleValue = 6.5;Double doubleObj = new Double(doubleValue);int intResult = doubleObj.intValue();
Cukup gunakan metode intValue dari Double
Double initialValue = 7.12;
int finalValue = initialValue.intValue();
Memori efisien, karena akan berbagi contoh Double yang sudah dibuat.
Double.valueOf(Math.floor(54644546464/60*60*24*365)).intValue()
Math.floor(...)
? intValue()
selalu lantai.
Ini berhasil untuk saya. Coba ini:
double od = Double.parseDouble("1.15");
int oi = (int) od;