Ubah float menjadi double tanpa kehilangan presisi

Saya memiliki pelampung primitif dan saya perlu sebagai primitif ganda. Cukup melemparkan pelampung menjadi dua kali lipat memberi saya presisi ekstra yang aneh. Sebagai contoh:

float temp = 14009.35F;
System.out.println(Float.toString(temp)); // Prints 14009.35
System.out.println(Double.toString((double)temp)); // Prints 14009.349609375

Namun, jika alih-alih melakukan casting, saya mengeluarkan float sebagai string, dan mengurai string sebagai double, saya mendapatkan apa yang saya inginkan:

System.out.println(Double.toString(Double.parseDouble(Float.toString(temp))));
// Prints 14009.35

Apakah ada cara yang lebih baik daripada pergi ke String dan kembali?

Ini bukan karena Anda benar - benar mendapatkan presisi ekstra - pelampung tidak secara akurat mewakili angka yang Anda tuju pada awalnya. Ganda adalah mewakili mengapung asli akurat; toStringmenampilkan data "ekstra" yang sudah ada.

Misalnya (dan angka-angka ini tidak benar, saya hanya mengada-ada) seandainya Anda memiliki:

float f = 0.1F;
double d = f;

Maka nilai fmungkin persis 0,100000234523. dakan memiliki nilai yang persis sama, tetapi saat Anda mengonversinya menjadi string, ia akan "percaya" bahwa itu akurat ke presisi yang lebih tinggi, jadi tidak akan dibulatkan lebih awal, dan Anda akan melihat "digit ekstra" yang sudah di sana, tapi tersembunyi darimu.

Saat Anda mengonversi menjadi string dan kembali, Anda berakhir dengan nilai ganda yang lebih dekat ke nilai string daripada float asli - tetapi itu hanya bagus jika Anda benar-benar yakin bahwa nilai string adalah yang Anda inginkan.

Apakah Anda yakin bahwa float / double adalah tipe yang sesuai untuk digunakan di sini, bukan BigDecimal? Jika Anda mencoba menggunakan angka yang memiliki nilai desimal yang tepat (misalnya uang), maka BigDecimaljenis IMO yang lebih tepat.

Saya menemukan konversi ke representasi biner lebih mudah untuk memahami masalah ini.

float f = 0.27f;
double d2 = (double) f;
double d3 = 0.27d;

System.out.println(Integer.toBinaryString(Float.floatToRawIntBits(f)));
System.out.println(Long.toBinaryString(Double.doubleToRawLongBits(d2)));
System.out.println(Long.toBinaryString(Double.doubleToRawLongBits(d3)));

Anda dapat melihat float diperluas menjadi double dengan menambahkan 0s di akhir, tetapi representasi ganda 0.27 adalah 'lebih akurat', itulah masalahnya.

   111110100010100011110101110001
11111111010001010001111010111000100000000000000000000000000000
11111111010001010001111010111000010100011110101110000101001000

Ini karena kontrak Float.toString(float), yang sebagian menyatakan:

Berapa digit yang harus dicetak untuk bagian pecahan […]? Harus ada setidaknya satu digit untuk mewakili bagian pecahan, dan di luar itu sebanyak itu, tetapi hanya sebanyak, lebih banyak digit yang diperlukan untuk secara unik membedakan nilai argumen dari nilai yang berdekatan dari tipe float. Artinya, anggaplah x adalah nilai matematika yang tepat yang diwakili oleh representasi desimal yang dihasilkan oleh metode ini untuk argumen tak terbatas hingga f. Maka f harus menjadi nilai float yang paling dekat dengan x; atau, jika dua nilai float sama dekat dengan x, maka f harus salah satunya dan bit signifikansi terkecil dari f harus 0.

Saya mengalami masalah ini hari ini dan tidak dapat menggunakan refactor ke BigDecimal, karena proyeknya sangat besar. Namun saya menemukan solusi menggunakan

Float result = new Float(5623.23)
Double doubleResult = new FloatingDecimal(result.floatValue()).doubleValue()

Dan ini berhasil.

Perhatikan bahwa memanggil result.doubleValue () akan mengembalikan 5623.22998046875

Tapi memanggil doubleResult.doubleValue () akan mengembalikan 5623.23 dengan benar

Tetapi saya tidak sepenuhnya yakin apakah ini solusi yang tepat.

Saya menemukan solusi berikut:

public static Double getFloatAsDouble(Float fValue) {
    return Double.valueOf(fValue.toString());
}

Jika Anda menggunakan float dan double, bukan Float dan Double, gunakan yang berikut:

public static double getFloatAsDouble(float value) {
    return Double.valueOf(Float.valueOf(value).toString()).doubleValue();
}

Gunakan sebagai BigDecimalpengganti float/ double. Ada banyak angka yang tidak bisa direpresentasikan sebagai floating point biner (misalnya, 0.1). Jadi, Anda harus selalu membulatkan hasil ke presisi atau penggunaan yang diketahui BigDecimal.

Lihat http://en.wikipedia.org/wiki/Floating_point untuk informasi lebih lanjut.

Float, pada dasarnya, tidak tepat dan selalu memiliki "masalah" pembulatan yang rapi. Jika presisi penting, Anda dapat mempertimbangkan untuk memfaktorkan ulang aplikasi Anda untuk menggunakan Desimal atau BigDecimal.

Ya, float secara komputasi lebih cepat daripada desimal karena dukungan prosesor on. Namun, apakah Anda ingin cepat atau akurat?

Untuk informasi, ini ada di Item 48 - Hindari float dan double ketika nilai yang tepat diperlukan, dari Effective Java 2nd edition oleh Joshua Bloch. Buku ini dikemas dengan barang-barang bagus dan pasti menarik untuk dilihat.

Apakah ini berhasil?

float flt = 145.664454;

Double dbl = 0.0;
dbl += flt;

Solusi sederhana yang berfungsi dengan baik, adalah mengurai ganda dari representasi string float:

double val = Double.valueOf(String.valueOf(yourFloat));

Tidak super efisien, tapi berhasil!