The Internet belongs to everyone. Let’s keep it that way.

Protect Net Neutrality
Loading presentation...

Present Remotely

Send the link below via email or IM

Copy

Present to your audience

Start remote presentation

  • Invited audience members will follow you as you navigate and present
  • People invited to a presentation do not need a Prezi account
  • This link expires 10 minutes after you close the presentation
  • A maximum of 30 users can follow your presentation
  • Learn more about this feature in our knowledge base article

Do you really want to delete this prezi?

Neither you, nor the coeditors you shared it with will be able to recover it again.

DeleteCancel

Aula 2 Java BigDecimal

No description

Comments (0)

Please log in to add your comment.

Report abuse

Transcript of Aula 2 Java BigDecimal

Double vs BigDecimal
Ao trabalhar com dinheiro precisamos de valores exatos, nem 1 centavo a menos nem 1 centavo a mais, afinal, há muita coisa envolvida neste tipo de processo. Quando trabalhamos com Double (seja o Double wrapper ou mesmo o double tipo primitivo) não há uma precisão de casas decimais que precisamos, podemos perceber isso em somas simples onde o resultado deveria ser simples, mas acaba sendo estranho e confuso.
Como obter o esperado 0.3?
BigDecimal
big1 =
new

BigDecimal
(0.1);
BigDecimal
big2 =
new

BigDecimal
(0.2);
BigDecimal
bigResult = big1.add(big2);

System.out.println(bigResult.toString());
Operações aritméticas com BigDecimal
Subtrai =
subtract
();

Soma =
add
();

Compara =
compareTo
();

Divide =
divide
();

Máximo =
max
();

Mínimo =
min
();

Multiplica =
multiply
();
Principais Arredondamentos
ROUND_UP = Arredonda para cima.
-0.001 => -0.01
0.001 => 0.01

ROUND_DOWN = Arredonda para o mais próximo de zero.
-0.009 => 0.00
0.009 => 0.00

ROUND_FLOOR = Arredonda para o menor valor
-0.001 => -0.01
0.001 => 0.00
Java BigDecimal
BigDecimal
A classe BigDecimal fornece operações aritmética, manipulação de escala, arredondamento e comparação.

Quando estamos trabalhando com valores monetários, os tipos float e double não são adequados devido aos problemas de precisão.

Nem todas as frações tem representação exata nestes dois tipos de dados.
Mais inf: https://docs.oracle.com/javase/7/docs/api/java/math/RoundingMode.html
ROUND_HALF_DOWN = Verifica o valor excedente: se for de 5 para baixo o valor será menor.
-0.006 => -0.01
-0.005 => 0.00
-0.004 => 0.00
0.004 => 0.00
0.005 => 0.00
0.006 => 0.01

ROUND_HALF_UP = Verifica o valor excedente: se for de 5 para cima o valor será maior.
-0.006 => -0.01
-0.005 => -0.01
-0.004 => 0.00
0.004 => 0.00
0.005 => 0.01
0.006 => 0.01

double
d1 = 0.1;
double
d2 = 0.2;
System.out.println
(d1 + d2);
Qual é o valor da soma?
Um estranho
0.30000000000000004
, que pode acarretar em problemas graves dependendo da utilização e arrendondamento aplicado depois nesse número. O problema é que um número com
0.1
não pode ser representado em binário de maneira finita: ele vira uma dízima (no binário ficaria algo como
0.110011001100
…) diferente do número
0.25
, que pode ser representado perfeitamente (no binário
0.01
).
Resultado é
A sugestão sempre é usar o
BigDecimal
.
BigDecimal
é uma classe que trabalha com números de ponto flutuante de precisão arbitrária:: você pode escolher quanto de precisão você quer usar. Por padrão ele vai utilizar o que for necessário, e, diferente do double, ele consegue guardar números como 0.1, pois guardará isto como sendo 1 x 10ˆ-1 (isto é, usando a base decimal em vez de binária, evitando a dízima).
Teste esse código:
Opss
BigDecimal
big1 =
new

BigDecimal
("0.1");
BigDecimal
big2 =
new

BigDecimal
("0.2");
BigDecimal
bigResult = big1.add(big2);

System.out.println(bigResult.toString());
O resultado é uma nova surpresa, um incrível
0.300000000000000016653345369377
.... O que fizemos de errado agora foi que tentar somar
0.1
e
0.2
sendo que esses dois números já estavam armazenados em memória como double, e, ao serem passados para o construtor do BigDecimal, foram transportados com imprecisão.
Como resolver?
Basta sempre usar o construtor que trabalha com
Strings
, assim o
BigDecimal
vai internamente fazer o
parsing
desses números sem que eles sejam armazenados em um
double
, evitando os problemas de precisão:
Full transcript