Palavra-chave flutuante Java

Em algum momento do desenvolvimento da tecnologia computacional, ficou claro que as unidades centrais de processamento precisavam de dispositivos de hardware para processar números de ponto flutuante. Hoje, todas as arquiteturas de computadores podem funcionar de forma eficaz com esses números. É claro que em linguagens de programação você também não pode prescindir dos tipos de dados correspondentes. Existem dois tipos de dados de ponto flutuante em Java: float e double. A palavra-chave Java Float define um número real que ocupa 32 bits na memória. Falaremos sobre esses números neste artigo.

Números de ponto flutuante. Como os números reais são armazenados em um computador?

Para armazenar números reais na memória do computador, um certo número de bits é alocado. Um número real é armazenado como sinal (mais ou menos), louva-a-deus e expoente. O que é mantissa e expoente é melhor explicado com um exemplo. A massa aproximada da lua é 7*1022. Aqui 7 é o louva-a-deus, em 22 é o expoente. Ao exibir números grandes ou vice-versa, números muito pequenos na tela, você pode ver uma entrada como 7E22. Este é o número de ponto flutuante, e 7 aqui é o louva-a-deus, e 22 é o expoente ou potência de 10. Essa notação é chamada de notação exponencial.

Palavra-chave Java float e palavra-chave Java Double

Valores flutuantes (números de ponto flutuante ou números reais) em Java são representados pelos tipos float e double . São essas palavras-chave usadas para armazenar valores até um determinado sinal após a vírgula. double são números com dupla precisão, o mais próximo possível dos valores dados ou obtidos em cálculos. Java Double é usado para quaisquer cálculos matemáticos (raiz quadrada, seno, cosseno, ..), bem como para todos os cálculos onde uma certa precisão é importante. O tipo de dados float é usado para um tipo de ponto flutuante menos preciso. É usado muito raramente para economizar memória. Abaixo temos uma tabela com as principais informações sobre float e double, bem como suas diferenças. Portanto, a palavra-chave Float significa um número, um valor de precisão única que ocupa 32 bits ou 4 bytes na memória. Em alguns processadores, trabalhar com esses números é mais rápido e, como já mencionado, ocupam menos espaço quando comparados com números de dupla precisão. No entanto, é impossível dizer inequivocamente com velocidade. Digamos que alguns processadores modernos processem exatamente números de precisão dupla com mais rapidez.

Java Float e Declaração Dupla

Você pode declarar um número do tipo double da mesma forma que números de outros tipos:

double myDouble = 2.7;

Entretanto, se você representar um número de ponto flutuante dessa forma, o compilador exigirá que você altere o tipo do número para double. Aqui está um exemplo incorreto de variável float :

public class FloatExample {
   public static void main(String[] args) {
//double and float variables
       double myDouble = 2.7;
       float myFloat = 3.14;
   }
}

Aqui está o que acontece se você executar este programa:

Error:(4, 25) java: incompatible types: possible lossy conversion from double to float

O fato é que não é desejável usar números flutuantes, e isso deve ser feito apenas para economizar memória. Todos os números fracionários reais em Java são Double por padrão, e a sintaxe da linguagem também enfatiza isso. Se você realmente deseja trabalhar com o tipo float, você precisa especificá-lo explicitamente com um f encerrando o número.

public class FloatExample {
   public static void main(String[] args) {
//double and float variables
       double myDouble = 2.7;
       float myFloat = 3.14f;
   }
}

A propósito, números flutuantes e duplos podem ser escritos na forma exponencial.

float myFloat2 = 2E22f;
double myDouble2 = 3e10;

Se você usar números grandes o suficiente em sua representação "normal", o Java os exibirá imediatamente na forma exponencial. Vejamos um exemplo:

public class FloatExample {
   public static void main(String[] args) {
//float variables
               float myFloatNumber1=2182818284590.45f;
               float myFloatNumber2=19822612787260.141592181f;
               System.out.println("myFloatNumber1 = " + myFloatNumber1);
               System.out.println("myFloatNumber2 = " + myFloatNumber2);
       System.out.println("myFloatNumber1 + myFloatNumber2 = " + myFloatNumber1 + myFloatNumber2);
           }
       }

O resultado deste trabalho do programa está aqui:

Exemplo especial de números flutuantes e duplos

Existem três números de ponto flutuante especiais na linguagem Java, que são usados ​​para indicar overflows e erros. Aqui estão eles:

• O infinito positivo é o resultado da divisão de um número positivo por 0. Representado pelas constantes Double.POSITIVE_INFINITY e Float.POSITIVE_INFINITY .

• O infinito negativo é o resultado da divisão de um número negativo por 0. Representado pelas constantes Double.NEGATIVE_INFINITY e Float.NEGATIVE_INFINITY .

• NaN (não é um número) representa o cálculo de 0/0 ou a raiz quadrada de um número negativo. Representado pelas constantes Double.NaN e Float.NAN .

Aqui está um exemplo de uso desses números especiais de ponto flutuante:

public class FloatExample {
   public static void main(String[] args) {
       int myInt = 1;
       float zero = 0.0f;
       double negZero = -0.0;
       double negativeInfinity = Double.NEGATIVE_INFINITY;
       double positiveInfinity = Float.POSITIVE_INFINITY;

       System.out.println(myInt / zero);
       System.out.println(myInt / negZero);
       System.out.println(zero == negZero);
       System.out.println(negativeInfinity * 0);
       System.out.println(positiveInfinity+negativeInfinity);

   }
}

O resultado é:

A precisão dupla é suficiente?

Na verdade, apesar da dupla precisão do tipo Double , utilizar números de ponto flutuante, por exemplo, em cálculos financeiros, não é a melhor ideia porque erros de arredondamento são inaceitáveis. Portanto, tente exibir a saída do programa a seguir na tela.

public class FloatExample {
   public static void main(String[] args) {
       System.out. println( "2.0 - 1.1 = " + (2.0 - 1.1));
   }
}

Você obterá o seguinte resultado: Seria lógico supor que o resultado será 0,9. No entanto, tais erros são bastante comuns e estão associados à representação binária interna dos números. Não podemos, por exemplo, representar o valor exato de ⅓ como uma fração decimal; é claro que existem restrições semelhantes no sistema binário. Caso a tarefa exija a eliminação de erros de arredondamento, Java possui a classe BigDecimal para isso.