|
|
Publicado em 07/04/2015 14:53:05
|
|
|
Classes de operação para grandes números são fornecidas em java, nomeadamente a classe java.math.BinInteger e a classe java.math.BigDecimal. Essas duas classes são usadas para computação de alta precisão, sendo a classe BigInteger a classe de processamento para inteiros grandes e a classe BigDecimal a classe de processamento para números grandes e pequenos. Abaixo, apresentamos a classe BigDecimal:
A implementação do BigDecimal aproveita o BigInteger, exceto que o BigDecimal adiciona o conceito de decimais. Dados gerais de tipo flutuante e duplo só podem ser usados para cálculos científicos ou de engenharia, porque na computação comercial, a precisão numérica necessária é relativamente alta, então a classe java.math.BigDecimal é utilizada, que suporta qualquer precisão de pontos fixos e pode ser usada para calcular valores de moeda com precisão. A seguir, apresentaremos brevemente seu uso com exemplos
java.math.BigDecimal
Hoje, escrevi um programa sobre conversão binária e decimal com referência ao livro didático, e o algoritmo do programa não é difícil, mas depois de escrever, descobri que, seja de 2 a 10 ou de 10 a 2, não é uma boa conversão para números maiores que 2,1 bilhões, ou seja, maiores que a faixa de inteiros. se tornará 0.
Livros de referência descobriram que usar o BigInteger resolve esse problema.
Então pesquisei o JDK, testei várias vezes e finalmente escrevi com sucesso!
A experiência de uso é a seguinte:
1. BigInteger pertence ao java.math.BigInteger, então importe essa classe antes de cada uso. Às vezes, esquecia de importar no começo, então o prompt não aparece no prompt constante.
2. Existem muitos métodos de construção, mas agora são ocasionalmente utilizados:
BigEnter(String val)
Converta a representação decimal da cadeia de BigInteger em BigInteger.
BigInteiro(String val, int radix)
Converte a representação da cadeia do BigInteger para a cardinalidade especificada para o BigInteger.
Para converter 2 do tipo int para o tipo BigInteir, escreva Inteiro Grande=novo GrandeInteiro("2"); Nota 2: aspas duplas não podem ser omitidas
3. A classe BigInteger simula todas as operações matemáticas do tipo int, como add()=="+", divide()=="-", etc., mas note que seu conteúdo não pode ser usado diretamente para operações matemáticas ao realizar operações matemáticas, e deve usar seus métodos internos. E seu operando também deve ser do tipo BigInteger.
Por exemplo: two.add(2) é uma operação incorreta porque 2 não se torna um tipo BigEnter.
4. Quando você quiser exportar os resultados do cálculo, deve usar o método .toString para convertê-los em uma cadeia decimal, conforme detalhado a seguir:
String toString()
Retorna a representação decimal da cadeia deste BigInteger.
Método de saída: System.out.print(two.toString());
5. Explique as três funções utilizadas.
BigInteger resto(BigInteger val)
Retorna um BigInteger com um valor de (esse % val).
Negação BigInteger ()
BigInteger retorna um valor de (-this).
int compareTo(BigInteger val)
Compare esse BigInteger com o BigInteger especificado.
O resto é usado para encontrar o resto.
Negação transforma o operando no oposto.
Compare é explicado em detalhes da seguinte forma:
compareTo
public int compareTo(BigInteger val)
Compare esse BigInteger com o BigInteger especificado. Esse método é preferido para cada um dos seis operadores de comparação booleanos (<, ==, >, >=, !=, <=). A instrução sugerida para realizar essas comparações é: (x.compareTo(y) <op> 0), onde é <op> um dos seis operadores de comparação.
Especificador:
interface<BigInteger> Comparável
Parâmetros:
val - O GrandeInteger que compara esse GrandeInteger a ele.
Voltar:
Título Implementando Cálculos Precisos de Números de Ponto Flutuante em Java Modificação Auxiliar (Original)
Palavras-chave Java cálculo preciso de números de ponto flutuante
Pergunta feita:
O que veríamos se compilassemos e executássemos o seguinte programa?
classe pública Test{
public static void main(String args[]){
System.out.println(0,05+0,01);
System.out.println(1.0-0.42);
System.out.println(4.015*100);
System.out.println(123,3/100);
}
};
Você leu certo! O resultado é, de fato
0.060000000000000005
0.5800000000000001
401.49999999999994
1.2329999999999999
Tipos simples float e double em Java não podem ser operados. Esse problema não é encontrado apenas em Java, mas também em muitas outras linguagens de programação. Na maioria dos casos, os cálculos são precisos, mas você pode tentar algumas vezes mais (pode fazer um loop) para tentar erros como o acima. Agora finalmente entendo por que existe um código BCD.
Esse problema é bastante sério: se você tiver 9,9999999999999999999 yuan, seu computador não vai achar que você pode comprar 10 yuans em mercadorias.
Algumas linguagens de programação fornecem tipos de moeda especializados para lidar com essa situação, mas o Java não o faz. Agora vamos ver como consertar isso.
Arredondamento
Nossa primeira reação é fazer arredondamento. O método de rodada na classe de Matemática não pode ser configurado para manter algumas casas decimais, só podemos fazer isso (manter duas posições):
Dupla rodada pública (valor duplo){
return Math.round(value*100)/100.0;
}
Infelizmente, o código acima não funciona; passar a 4.015 para esse método retornará a 4.01 em vez da 4.02, como vimos acima
4.015*100=401.499999999999994
Portanto, se quisermos fazer arredondamento preciso, não podemos usar tipos simples para realizar operações
java.text.DecimalFormat também não resolve esse problema:
System.out.println(novo java.text.DecimalFormat("0.00").format(4.025));
A saída é 4,02
BigDecimal
Esse princípio também é mencionado no livro "Java Eficaz"; float e double só podem ser usados para cálculos científicos ou de engenharia, e na computação empresarial precisamos usar java.math.BigDecimal. Existem 4 maneiras de construir o BigDecimal, não nos importamos com as duas que são feitas com o BigInteger, então há mais duas, que são:
BigDecimal (val duplo)
Traduz um duplo em um BigDecimal.
BigDecimal (val de string)
Traduz a representação de String de um BigDecimal para um BigDecimal.
A API é descrita brevemente e geralmente é mais fácil de usar. Podemos usá-lo sem nem pensar, qual será o problema? Quando algo deu errado, descobri que havia um parágrafo na descrição detalhada de qual dos métodos acima era suficiente:
Nota: os resultados desse construtor podem ser um tanto imprevisíveis. Pode-se supor que o novo BigDecimal(.1) é exatamente igual a 0,1, mas na verdade é igual a .1000000000000000055511151231257827021181583404541015625. Isso porque 0,1 não pode ser representado exatamente como um duplo (ou, aliás, como uma fração binária de qualquer comprimento finito). Assim, o valor longo que está sendo passado para o construtor não é exatamente igual a 0,1, aparências inacreditáveis.
O construtor (String), por outro lado, é perfeitamente previsível: o novo BigDecimal(".1") é exatamente igual a 0,1, como se esperaria. Portanto, geralmente é recomendado que o construtor (String) seja usado em vez desse construtor.
Acontece que, se precisarmos calcular com precisão, precisamos usar o String para criar o BigDecimal! O exemplo no livro Effective Java usa String para criar o BigDecimal, mas o livro não enfatiza isso, o que pode ser um pequeno erro.
Solução
Agora que resolvemos esse problema, o princípio é usar BigDecimal e garantir o uso de String.
Mas imagine que, se quisermos fazer uma operação de adição, precisamos primeiro converter dois números de ponto flutuante em String, depois criar um BigDecimal, chamar o método de soma em um deles, passar o outro como argumento e então converter o resultado da operação (BigDecimal) em um número de ponto flutuante. Você consegue suportar um processo tão tedioso? Abaixo, fornecemos uma classe de ferramenta Arith para simplificar a operação. Ele oferece os seguintes métodos estáticos, incluindo adição, subtração, multiplicação e divisão, e arredondamento:
Publicamente estático duplo de adição (duplo v1, duplo v2)
Public Static Double Sub(double v1, double v2)
Estática pública Double Mul(Double V1, Double V2)
Dupla div estática pública (dupla v1, dupla v2)
Dupla Div estática pública (dupla v1, dupla v2, escala INT)
Duplo Round estático público (Dupla V, Escala INT)
Apêndice
Arquivo fonte Arith.java:
importar java.math.BigDecimal;
/**
* Como os tipos simples do Java não conseguem executar operações de ponto flutuante com precisão, essa classe de ferramenta fornece multas
* Operações exatas de ponto flutuante, incluindo adição, subtração, multiplicação, divisão e arredondamento.
*/
classe pública Arith{
Precisão padrão da operação de divisão
Inteligência final estática privada DEF_DIV_SCALE = 10;
Essa classe não pode ser instanciada
soldado Arith(){
}
/**
* Fornece operações de adição precisas.
* @param v1 é adicionada
* @param adição v2
* @return A soma dos dois parâmetros
*/
Public Static Double Add(Double v1,Double V2){
BigDecimal b1 = novo BigDecimal(Double.toString(v1));
BigDecimal b2 = novo BigDecimal(Double.toString(v2));
return b1.add(b2).doubleValue();
}
/**
* Fornece operações de subtração precisas.
* @param v1 é subtraído
* @param v2 menos
* @return A diferença entre os dois parâmetros
*/
public static double sub(double v1,double v2){
BigDecimal b1 = novo BigDecimal(Double.toString(v1));
BigDecimal b2 = novo BigDecimal(Double.toString(v2));
return b1.subtrair(b2).doubleValue();
}
/**
* Fornece operações de multiplicação precisas.
* @param v1 é multiplicado
* multiplicador @param v2
* @return O produto dos dois parâmetros
*/
Estática pública Double Mul(Double V1,Double V2){
BigDecimal b1 = novo BigDecimal(Double.toString(v1));
BigDecimal b2 = novo BigDecimal(Double.toString(v2));
return b1.multiply(b2).doubleValue();
}
/**
* Fornece operações de divisão (relativamente) precisas, quando ocorre uma divisão inesgotável
* 10 casas decimais e os dígitos seguintes são arredondados.
* @param v1 é dividido
* @param divisor v2
* @return O quociente dos dois parâmetros
*/
public static double div(double v1,double v2){
return div(v1,v2,DEF_DIV_SCALE);
}
/**
* Fornece operações de divisão (relativamente) precisas. Quando ocorre uma situação inesgotável, ela é indicada pelo parâmetro de escala
* Determine a precisão, e os números após ela serão arredondados.
* @param v1 é dividido
* @param divisor v2
* @param escala indica que precisa ser precisa com precisão em alguns decentes.
* @return O quociente dos dois parâmetros
*/
Public Static Double Div(double v1,double v2,int scale){
se(escala<0){
Lançar um novo IlegalArgumentException(
"A escala deve ser um inteiro positivo ou zero");
}
BigDecimal b1 = novo BigDecimal(Double.toString(v1));
BigDecimal b2 = novo BigDecimal(Double.toString(v2));
return b1.divide(b2,scale,BigDecimal.ROUND_HALF_UP).doubleValue();
}
/**
* Fornece arredondamento decimal preciso.
* @param v exige arredondamento dos números
* @param escala é reservada após o ponto decimal
* @return Resultados arredondados
*/
Estática pública dupla rodada (dupla v,int escala){
se(escala<0){
Lançar um novo IlegalArgumentException(
"A escala deve ser um inteiro positivo ou zero");
}
BigDecimal b = novo BigDecimal(Double.toString(v));
BigDecimal um = novo BigDecimal("1");
return b.divide(um,scale,BigDecimal.ROUND_HALF_UP).doubleValue();
}
}; |
Anterior:É melhor não compor uma corda com significado como tonalidade primáriaPróximo:Diferenças e conexões entre JDK, JRE, JVM
|
