Mengambang dan menggandakan datatype di Jawa

Tipe data float adalah floating point IEEE 754 32-bit presisi tunggal dan tipe data ganda adalah floating point IEEE 754 64-bit presisi ganda.

Apa artinya? Dan kapan saya harus menggunakan float bukan double atau sebaliknya?

The Wikipedia halaman pada itu adalah tempat yang baik untuk memulai.

Untuk menyimpulkan:

• floatdiwakili dalam 32 bit, dengan 1 bit tanda, 8 bit eksponen, dan 23 bit signifikan (atau yang mengikuti dari angka notasi ilmiah: 2.33728 * 10 ¹² ; 33728 adalah signifikan).

• double direpresentasikan dalam 64 bit, dengan 1 bit tanda, 11 bit eksponen, dan 52 bit signifikan.

Secara default, Java menggunakan doubleuntuk mewakili angka floating-point (jadi literal 3.14diketik double). Ini juga tipe data yang akan memberi Anda rentang angka yang jauh lebih besar, jadi saya akan sangat menyarankan penggunaannya berakhir float.

Mungkin ada perpustakaan tertentu yang benar-benar memaksa penggunaan Anda float, tetapi secara umum - kecuali jika Anda dapat menjamin bahwa hasil Anda akan cukup kecil untuk muat di float's kisaran yang ditentukan , maka yang terbaik untuk opt dengan double.

Jika Anda membutuhkan akurasi - misalnya, Anda tidak dapat memiliki nilai desimal yang tidak akurat (seperti 1/10 + 2/10), atau Anda melakukan apa pun dengan mata uang (misalnya, mewakili $ 10,33 dalam sistem), kemudian gunakan a BigDecimal, yang dapat mendukung jumlah presisi yang sewenang-wenang dan menangani situasi seperti itu dengan elegan.

Float memberi Anda kira-kira. 6-7 presisi angka desimal sementara ganda memberi Anda kira-kira. 15-16. Juga kisaran angka lebih besar untuk ganda.

Double membutuhkan ruang penyimpanan 8 byte sementara float hanya membutuhkan 4 byte.

Bilangan floating-point, juga dikenal sebagai bilangan real, digunakan ketika mengevaluasi ekspresi yang membutuhkan ketelitian fraksional. Misalnya, perhitungan seperti akar kuadrat, atau transendental seperti sinus dan kosinus, menghasilkan nilai yang ketelitiannya membutuhkan tipe titik-mengambang. Java mengimplementasikan set tipe dan operator floatingpoint (IEEE – 754) standar. Ada dua jenis tipe floating-point, float dan double, yang masing-masing mewakili angka presisi tunggal dan ganda. Lebar dan rentangnya ditampilkan di sini:

   Name     Width in Bits   Range 
    double  64              1 .7e–308 to 1.7e+308
    float   32              3 .4e–038 to 3.4e+038

mengapung

Tipe float menentukan nilai presisi tunggal yang menggunakan 32 bit penyimpanan. Presisi tunggal lebih cepat pada beberapa prosesor dan membutuhkan ruang setengah dari presisi ganda, tetapi akan menjadi tidak tepat ketika nilainya sangat besar atau sangat kecil. Variabel tipe float berguna ketika Anda membutuhkan komponen fraksional, tetapi tidak memerlukan tingkat presisi yang besar.

Berikut adalah beberapa contoh deklarasi variabel float:

mengapung hightemp, lowtemp;

dua kali lipat

Presisi ganda, sebagaimana dilambangkan dengan kata kunci ganda, menggunakan 64 bit untuk menyimpan nilai. Presisi ganda sebenarnya lebih cepat daripada presisi tunggal pada beberapa prosesor modern yang telah dioptimalkan untuk perhitungan matematika berkecepatan tinggi. Semua fungsi matematika transendental, seperti sin (), cos (), dan sqrt (), mengembalikan nilai ganda. Ketika Anda perlu menjaga akurasi dari banyak perhitungan berulang, atau memanipulasi angka bernilai besar, double adalah pilihan terbaik.

Meskipun demikian, Java tampaknya memiliki bias terhadap penggunaan ganda untuk perhitungan:

Contohnya program yang saya tulis sebelumnya hari ini, metode tidak bekerja ketika saya menggunakan float, tapi sekarang berfungsi dengan baik ketika saya mengganti float dengan double (dalam NetBeans IDE):

package palettedos;
import java.util.*;

class Palettedos{
    private static Scanner Z = new Scanner(System.in);
    public static final double pi = 3.142;

    public static void main(String[]args){
        Palettedos A = new Palettedos();
        System.out.println("Enter the base and height of the triangle respectively");
        int base = Z.nextInt();
        int height = Z.nextInt();
        System.out.println("Enter the radius of the circle");
        int radius = Z.nextInt();
        System.out.println("Enter the length of the square");
        long length = Z.nextInt();
        double tArea = A.calculateArea(base, height);
        double cArea = A.calculateArea(radius);
        long sqArea = A.calculateArea(length);
        System.out.println("The area of the triangle is\t" + tArea);
        System.out.println("The area of the circle is\t" + cArea);
        System.out.println("The area of the square is\t" + sqArea);
    }

    double calculateArea(int base, int height){
        double triArea = 0.5*base*height;
        return triArea;
    }

    double calculateArea(int radius){
        double circArea = pi*radius*radius;
        return circArea;
    }

    long calculateArea(long length){
        long squaArea = length*length;
        return squaArea;
    }
}

Ini akan memberikan kesalahan:

public class MyClass {
    public static void main(String args[]) {
        float a = 0.5;
    }
}

/MyClass.java:3: error: tipe yang tidak kompatibel: kemungkinan konversi lossy dari float ganda menjadi float a = 0,5;

Ini akan bekerja dengan baik

public class MyClass {
    public static void main(String args[]) {
        double a = 0.5;
    }
}

Ini juga akan berfungsi dengan baik

public class MyClass {
    public static void main(String args[]) {
        float a = (float)0.5;
    }
}

Alasan : Java secara default menyimpan bilangan real sebagai ganda untuk memastikan presisi yang lebih tinggi.

Double membutuhkan lebih banyak ruang tetapi lebih presisi selama komputasi dan float membutuhkan lebih sedikit ruang tetapi kurang tepat.

Menurut standar IEEE, float adalah representasi 32 bit dari bilangan real sedangkan ganda adalah representasi 64 bit.

Dalam program Java biasanya kita sebagian besar melihat penggunaan tipe data ganda. Hanya untuk menghindari luapan karena rentang angka yang dapat ditampung menggunakan tipe data ganda lebih banyak daripada rentang ketika float digunakan.

Juga ketika presisi tinggi diperlukan, penggunaan ganda dianjurkan. Beberapa metode perpustakaan yang diimplementasikan sejak lama masih membutuhkan penggunaan tipe data float sebagai suatu keharusan (itu hanya karena diimplementasikan menggunakan float, tidak ada yang lain!).

Tetapi jika Anda yakin bahwa program Anda membutuhkan jumlah kecil dan meluap tidak akan terjadi dengan penggunaan float Anda, maka penggunaan float sebagian besar akan meningkatkan kompleksitas ruang Anda karena float membutuhkan setengah memori seperti yang diperlukan oleh ganda.

Contoh ini menggambarkan cara mengekstrak tanda (bit paling kiri), eksponen (8 bit berikut) dan mantissa (23 bit paling kanan) dari float di Jawa.

int bits = Float.floatToIntBits(-0.005f);
int sign = bits >>> 31;
int exp = (bits >>> 23 & ((1 << 8) - 1)) - ((1 << 7) - 1);
int mantissa = bits & ((1 << 23) - 1);
System.out.println(sign + " " + exp + " " + mantissa + " " +
  Float.intBitsToFloat((sign << 31) | (exp + ((1 << 7) - 1)) << 23 | mantissa));

Pendekatan yang sama dapat digunakan untuk mantissa ganda (eksponen 11 bit dan 52 bit).

long bits = Double.doubleToLongBits(-0.005);
long sign = bits >>> 63;
long exp = (bits >>> 52 & ((1 << 11) - 1)) - ((1 << 10) - 1);
long mantissa = bits & ((1L << 52) - 1);
System.out.println(sign + " " + exp + " " + mantissa + " " +
  Double.longBitsToDouble((sign << 63) | (exp + ((1 << 10) - 1)) << 52 | mantissa));

Kredit: http://sj.github.io/java-float/

Anda harus menggunakan double bukannya float untuk perhitungan yang tepat, dan float bukannya double ketika menggunakan perhitungan yang kurang akurat. Float hanya berisi angka desimal, tetapi ganda mengandung nomor floating point presisi IEEE754, membuatnya lebih mudah untuk memuat dan menghitung angka lebih akurat. Semoga ini membantu.

Dalam perhitungan pemrograman reguler, kami tidak menggunakan float. Jika kami memastikan bahwa kisaran hasil berada dalam kisaran tipe data float, maka kami dapat memilih tipe data float untuk menghemat memori. Secara umum, kami menggunakan ganda karena dua alasan: -

• Jika kita ingin menggunakan angka floating-point sebagai tipe data float maka pemanggil metode harus secara eksplisit memberikan akhiran F atau f, karena secara default setiap angka floating-point diperlakukan sebagai dobel. Ini menambah beban bagi programmer. Jika kita menggunakan angka floating-point sebagai tipe data ganda maka kita tidak perlu menambahkan akhiran apa pun.
• Float adalah tipe data presisi tunggal yang berarti ia menempati 4 byte. Karenanya dalam perhitungan besar, kami tidak akan mendapatkan hasil yang lengkap. Jika kita memilih tipe data ganda, ini menempati 8 byte dan kita akan mendapatkan hasil yang lengkap.

Tipe float dan double data dirancang khusus untuk perhitungan ilmiah, di mana kesalahan aproksimasi dapat diterima. Jika keakuratan menjadi perhatian utama, maka disarankan untuk menggunakan kelas BigDecimal daripada tipe data float atau double. Sumber: - Mengambang dan menggandakan tipe data di Jawa