Por que o Java não lança uma exceção ao dividir por 0,0?

Eu tenho código para calcular a diferença percentual entre 2 números – (oldNum - newNum) / oldNum * 100; – onde ambos os números são double . Eu esperava ter que adicionar algum tipo de verificação / exception handling no caso oldNum é 0. No entanto, quando eu fiz um teste com valores de 0.0 para oldNum e newNum, a execução continuou como se nada tivesse acontecido e nenhum erro foi lançado. Executar este código com int s causaria definitivamente uma exceção aritmética por divisão por zero. Por que Java ignora quando se trata de double s?

   

O resultado da divisão por zero é, matematicamente falando, indefinido , que pode ser expresso com um float / double (como NaN – não um número), mas não é errado em nenhum sentido fundamental.

Como um inteiro deve conter um valor numérico específico, um erro deve ser lançado na divisão por zero ao lidar com eles.

Os tipos float e double do Java, como praticamente qualquer outra linguagem lá fora (e praticamente qualquer unidade FP de hardware), implementam o padrão IEEE 754 para matemática de ponto flutuante, que exige divisão por zero para retornar um valor “infinito” especial. Lançar uma exceção violaria esse padrão.

A aritmética inteira (implementada como a representação de complemento de dois por Java e a maioria das outras linguagens e hardware) é diferente e não possui valores especiais de infinito ou NaN, portanto lançar exceções é um comportamento útil lá.

A forma como um duplo é armazenado é bem diferente de um int. Veja http://firstclassthoughts.co.uk/java/traps/java_double_traps.html para uma explicação mais detalhada sobre como o Java lida com cálculos duplos. Você também deve ler os números de ponto flutuante, em particular o conceito de não um número (NaN) .

Se você estiver interessado em aprender mais sobre representação de ponto flutuante, eu aconselharia a leitura deste documento (formato Word, desculpe). Ele mergulha na representação binária de números, o que pode ser útil para sua compreensão.

Embora os desenvolvedores Java saibam sobre o tipo double primitive e Double class, enquanto fazem aritmética de ponto flutuante, eles não prestam atenção suficiente a Double.INFINITY , NaN , -0.0 e outras regras que governam os cálculos aritméticos que os envolvem.

A resposta simples para essa pergunta é que ela não lançará a Double.INFINITY ArithmeticException e retornará Double.INFINITY . Além disso, observe que a comparação x == Double.NaN sempre é avaliada como false , mesmo que x seja um NaN .

Para testar se x é um NaN , deve-se usar o método chamada Double.isNaN(x) para verificar se o número dado é NaN ou não. Isso é muito próximo de NULL no SQL .

Pode ser útil para você.

Quando dividido por zero (0 ou 0,00)

  1. Se você dividir o dobro por 0, a JVM mostrará o Infinity .

    public static void main(String [] args){ double a=10.00; System.out.println(a/0); }

    Console: Infinity

  2. Se você dividir int por 0, a JVM lançará exceção aritmética .

    public static void main(String [] args){ int a=10; System.out.println(a/0); }

    Console: Exception in thread "main" java.lang.ArithmeticException: / by zero

  3. Mas se dividirmos int por 0.0, a JVM mostrará Infinity:

    public static void main(String [] args){ int a=10; System.out.println(a/0.0); }

    Console: Infinity

Isso ocorre porque a JVM automaticamente digitará cast int para double, portanto, obtemos o infinito em vez de ArithmeticException.