lenguaje - libro de programacion en java netbeans pdf

Tipo de datos flotante y doble en Java

Question

El tipo de datos flotantes es un punto flotante IEEE 754 de 32 bits de precisión simple y el tipo de datos doble es un punto flotante IEEE 754 de 64 bits de precisión doble.

Qué significa eso? ¿Y cuándo debo usar float en lugar de double o viceversa?

Answer 1

De acuerdo con los estándares IEEE, flotante es una representación de 32 bits de un número real, mientras que el doble es una representación de 64 bits.

En los programas Java, normalmente vemos principalmente el uso del tipo de datos doble. Es solo para evitar desbordamientos, ya que el rango de números que pueden acomodarse usando el tipo de datos doble es mayor que el rango cuando se usa flotante.

Además, cuando se requiere alta precisión, se recomienda el uso de doble. Pocos métodos de biblioteca que se implementaron hace mucho tiempo aún requieren el uso del tipo de datos flotante como un deber (eso es solo porque se implementó usando flotante, ¡nada más!).

Pero si está seguro de que su programa requiere números pequeños y no se producirá un desbordamiento con el uso de float, entonces el uso de float mejorará en gran medida la complejidad de su espacio, ya que los flotantes requieren la mitad de la memoria requerida por el doble.

Answer 2

Este ejemplo ilustra cómo extraer el signo (el bit más a la izquierda), el exponente (los 8 bits siguientes) y la mantisa (los 23 bits más a la derecha) de un flotante en Java.

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

Se puede usar el mismo enfoque para dobles (exponente de 11 bits y mantisa de 52 bits).

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

Crédito: http://s-j.github.io/java-float/

Answer 3

Java parece tener un sesgo hacia el uso de doble para los cálculos, no obstante:

Por ejemplo, el programa que escribí hoy, los métodos no funcionaron cuando usé float, pero ahora funcionan muy bien cuando sustituí float con double (en el IDE de NetBeans):

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;
    }
}

Answer 4

La en.wikipedia.org/wiki/IEEE_floating_point es un buen lugar para comenzar.

Para resumir:

• float se representa en 32 bits, con 1 bit de signo, 8 bits de exponente y 23 bits del significado (o lo que sigue de un número de notación científica: 2.33728 * 10 ¹² ; 33728 es el significado).

• double se representa en 64 bits, con 1 bit de signo, 11 bits de exponente y 52 bits de significado.

Por defecto, Java usa el double para representar sus números de coma flotante (por lo que un literal 3.14 se escribe double ). También es el tipo de datos que le dará un rango de números mucho mayor, por lo que recomendaría encarecidamente su uso sobre float .

Puede haber ciertas bibliotecas que realmente fuercen su uso de float , pero en general, a menos que pueda garantizar que su resultado sea lo suficientemente pequeño como para caber en el rango prescrito de float , entonces es mejor optar por double .

Si necesita precisión, por ejemplo, no puede tener un valor decimal que sea inexacto (como 1/10 + 2/10 ), o está haciendo algo con moneda (por ejemplo, que representa $ 10.33 en el sistema), entonces use un BigDecimal , que puede soportar una cantidad arbitraria de precisión y manejar situaciones como esa con elegancia.

Answer 5

Los números de punto flotante, también conocidos como números reales, se usan al evaluar expresiones que requieren precisión fraccional. Por ejemplo, los cálculos como la raíz cuadrada, o trascendentales como el seno y el coseno, dan como resultado un valor cuya precisión requiere un tipo de punto flotante. Java implementa el conjunto estándar (IEEE – 754) de tipos y operadores de punto flotante. Hay dos tipos de tipos de coma flotante, flotante y doble, que representan números de precisión simple y doble, respectivamente. Su ancho y rangos se muestran aquí:

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

flotador

El tipo flotante especifica un valor de precisión simple que utiliza 32 bits de almacenamiento. La precisión simple es más rápida en algunos procesadores y ocupa la mitad de espacio que la precisión doble, pero se volverá imprecisa cuando los valores sean muy grandes o muy pequeños. Las variables de tipo flotante son útiles cuando necesita un componente fraccional, pero no requieren un alto grado de precisión.

Aquí hay algunos ejemplos de declaraciones de variables flotantes:

flotador hightemp, lowtemp;

doble

La precisión doble, como se indica con la palabra clave doble, usa 64 bits para almacenar un valor. La precisión doble es en realidad más rápida que la precisión simple en algunos procesadores modernos que han sido optimizados para cálculos matemáticos de alta velocidad. Todas las funciones matemáticas trascendentales, como sin (), cos () y sqrt (), devuelven valores dobles. Cuando necesita mantener la precisión en muchos cálculos iterativos, o está manipulando números de gran valor, el doble es la mejor opción.

Answer 6

Un flotador te da aprox. Precisión de 6-7 dígitos decimales, mientras que un doble le da aprox. 15-16. También el rango de números es mayor para el doble.

Un doble necesita 8 bytes de espacio de almacenamiento, mientras que un flotante necesita solo 4 bytes.

Answer 7

Esto dará error:

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

/MyClass.java:3: error: tipos incompatibles: posible conversión con pérdida de doble a flotante flotante a = 0.5;

Esto funcionará perfectamente bien

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

Esto también funcionará perfectamente bien

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

Motivo : Java por defecto almacena números reales como el doble para garantizar una mayor precisión.

El doble ocupa más espacio pero es más preciso durante el cálculo y el flotador ocupa menos espacio pero es menos preciso.