Como arredondar um número para n lugares decimais em java
https://stackoverflow.com/questions/153724
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
O que eu gostaria é um método para converter uma dupla em uma corda que rodadas usando o método de meia -up - ou seja, se o decimal a ser arredondado for 5, ele sempre reúne para o número anterior. Este é o método padrão de arredondar a maioria das pessoas que espera na maioria das situações.
Eu também gostaria que apenas dígitos significativos fossem exibidos - ou seja, não deve haver zeros à direita.
Eu sei que um método de fazer isso é usar o String.format método:
String.format("%.5g%n", 0.912385);
Retornos:
0.91239
O que é ótimo, no entanto, sempre exibe números com 5 lugares decimais, mesmo que não sejam significativos:
String.format("%.5g%n", 0.912300);
Retornos:
0.91230
Outro método é usar o DecimalFormatter:
DecimalFormat df = new DecimalFormat("#.#####");
df.format(0.912385);
Retornos:
0.91238
No entanto, como você pode ver, isso usa meio e mesmo arredondamento. Isto é, será redondo se o dígito anterior for uniforme. O que eu gostaria é disso:
0.912385 -> 0.91239
0.912300 -> 0.9123
Qual é a melhor maneira de conseguir isso em Java?
Solução
Usar setRoundingMode, colocou o RoundingMode Explicitamente para lidar com o seu problema com a meia-unidade e use o padrão de formato para a saída necessária.
Exemplo:
DecimalFormat df = new DecimalFormat("#.####");
df.setRoundingMode(RoundingMode.CEILING);
for (Number n : Arrays.asList(12, 123.12345, 0.23, 0.1, 2341234.212431324)) {
Double d = n.doubleValue();
System.out.println(df.format(d));
}
fornece a saída:
12
123.1235
0.23
0.1
2341234.2125
Outras dicas
Assumindo value é um double, você pode fazer:
(double)Math.round(value * 100000d) / 100000d
Isso é para 5 dígitos de precisão. O número de zeros indica o número de decimais.
new BigDecimal(String.valueOf(double)).setScale(yourScale, BigDecimal.ROUND_HALF_UP);
vai te dar um BigDecimal. Para tirar a corda, basta chamar isso BigDecimal's toString método, ou o toPlainString Método para Java 5+ para uma string de formato simples.
Programa de amostra:
package trials;
import java.math.BigDecimal;
public class Trials {
public static void main(String[] args) {
int yourScale = 10;
System.out.println(BigDecimal.valueOf(0.42344534534553453453-0.42324534524553453453).setScale(yourScale, BigDecimal.ROUND_HALF_UP));
}
Você também pode usar o
DecimalFormat df = new DecimalFormat("#.00000");
df.format(0.912385);
para garantir que você tenha os 0 à direita.
Como alguns outros observaram, a resposta correta é usar também DecimalFormat ou BigDecimal. Ponto flutuante não tenho Lugares decimais para que você não possa arredondar/truncar para um número específico deles em primeiro lugar. Você tem que trabalhar em um Radix decimal, e é isso que essas duas classes fazem.
Estou postando o código a seguir como um contra-exemplo a todas as respostas neste thread e, de fato, em todo o StackOverflow (e em outros lugares) que recomendam a multiplicação seguida de truncamento seguido pela divisão. Cabe aos advogados dessa técnica explicar por que o código a seguir produz a saída errada em mais de 92% dos casos.
public class RoundingCounterExample
{
static float roundOff(float x, int position)
{
float a = x;
double temp = Math.pow(10.0, position);
a *= temp;
a = Math.round(a);
return (a / (float)temp);
}
public static void main(String[] args)
{
float a = roundOff(0.0009434f,3);
System.out.println("a="+a+" (a % .001)="+(a % 0.001));
int count = 0, errors = 0;
for (double x = 0.0; x < 1; x += 0.0001)
{
count++;
double d = x;
int scale = 2;
double factor = Math.pow(10, scale);
d = Math.round(d * factor) / factor;
if ((d % 0.01) != 0.0)
{
System.out.println(d + " " + (d % 0.01));
errors++;
}
}
System.out.println(count + " trials " + errors + " errors");
}
}
Saída deste programa:
10001 trials 9251 errors
EDITAR: Para abordar alguns comentários abaixo, refiz a parte do módulo do loop de teste usando BigDecimal e new MathContext(16) Para a operação do módulo da seguinte forma:
public static void main(String[] args)
{
int count = 0, errors = 0;
int scale = 2;
double factor = Math.pow(10, scale);
MathContext mc = new MathContext(16, RoundingMode.DOWN);
for (double x = 0.0; x < 1; x += 0.0001)
{
count++;
double d = x;
d = Math.round(d * factor) / factor;
BigDecimal bd = new BigDecimal(d, mc);
bd = bd.remainder(new BigDecimal("0.01"), mc);
if (bd.multiply(BigDecimal.valueOf(100)).remainder(BigDecimal.ONE, mc).compareTo(BigDecimal.ZERO) != 0)
{
System.out.println(d + " " + bd);
errors++;
}
}
System.out.println(count + " trials " + errors + " errors");
}
Resultado:
10001 trials 4401 errors
Suponha que você tenha
double d = 9232.129394d;
você pode usar BigDecimal
BigDecimal bd = new BigDecimal(d).setScale(2, RoundingMode.HALF_EVEN);
d = bd.doubleValue();
ou sem bigdecimal
d = Math.round(d*100)/100.0d;
com ambas as soluções d == 9232.13
Você pode usar a classe Decimalformat.
double d = 3.76628729;
DecimalFormat newFormat = new DecimalFormat("#.##");
double twoDecimal = Double.valueOf(newFormat.format(d));
Java do real como fazer Postagens Esta solução, que também é compatível para versões antes do Java 1.6.
BigDecimal bd = new BigDecimal(Double.toString(d));
bd = bd.setScale(decimalPlace, BigDecimal.ROUND_HALF_UP);
return bd.doubleValue();
double myNum = .912385;
int precision = 10000; //keep 4 digits
myNum= Math.floor(myNum * precision +.5)/precision;
@Milhous:o formato decimal para o arredondamento é excelente:
Você também pode usar o
DecimalFormat df = new DecimalFormat("#.00000"); df.format(0.912385);para certificar-se de que você tem 0 à direita do.
Eu gostaria de acrescentar que este método é muito bom para fornecer um real numérico, arredondando-mecanismo - não apenas visualmente, mas também quando o processamento.
Hipotética:você terá de implementar um mecanismo de arredondamento em uma GUI o programa.Para alterar o rigor / precisão de um resultado de saída simplesmente alterar o formato de acento circunflexo (i.e.dentro dos parênteses).De modo que:
DecimalFormat df = new DecimalFormat("#0.######");
df.format(0.912385);
gostaria de retornar como saída: 0.912385
DecimalFormat df = new DecimalFormat("#0.#####");
df.format(0.912385);
gostaria de retornar como saída: 0.91239
DecimalFormat df = new DecimalFormat("#0.####");
df.format(0.912385);
gostaria de retornar como saída: 0.9124
[EDITAR:também se o acento circunflexo formato é assim ("#0.############") e você
introduza uma vírgula, exemplo:3.1415926, para o argumento da causa, DecimalFormat
não produz qualquer tipo de lixo (e.g.zeros à direita) e irá retornar:3.1415926 ..se você está dessa forma inclinada.Concedido, é um pouco verboso
para o gosto de alguns dev - mas ei, tem um baixo consumo de memória
durante o processamento, e é muito fácil de implementar.]
Então, basicamente, a beleza de DecimalFormat é que é, simultaneamente, lida com a seqüência de caracteres aparência - bem como o nível de arredondamento precisão definida.Ergo:você obter dois benefícios para o preço de um código de implementação.;)
Você pode usar o seguinte método utilitário-
public static double round(double valueToRound, int numberOfDecimalPlaces)
{
double multipicationFactor = Math.pow(10, numberOfDecimalPlaces);
double interestedInZeroDPs = valueToRound * multipicationFactor;
return Math.round(interestedInZeroDPs) / multipicationFactor;
}
Aqui está um resumo do que você pode usar se você quer o resultado como uma String:
DecimalFormat#setRoundingMode():
DecimalFormat df = new DecimalFormat("#.#####"); df.setRoundingMode(RoundingMode.HALF_UP); String str1 = df.format(0.912385)); // 0.91239-
String str2 = new BigDecimal(0.912385) .setScale(5, BigDecimal.ROUND_HALF_UP) .toString();
Aqui está uma sugestão de quais bibliotecas você pode usar se você quiser double como um resultado.Eu não o recomendaria para a cadeia de conversão, porém, como o casal pode não ser capaz de representar o que você quer exatamente (veja o exemplo: aqui):
Uma sucinta solução:
public static double round(double value, int precision) {
int scale = (int) Math.pow(10, precision);
return (double) Math.round(value * scale) / scale;
}
Ver também, https://stackoverflow.com/a/22186845/212950 Graças a jpdymond para oferecer este.
Você pode utilizar BigDecimal
BigDecimal value = new BigDecimal("2.3");
value = value.setScale(0, RoundingMode.UP);
BigDecimal value1 = new BigDecimal("-2.3");
value1 = value1.setScale(0, RoundingMode.UP);
System.out.println(value + "n" + value1);
Consulte: http://www.javabeat.net/precise-rounding-of-decimals-using-rounding-mode-enumeration/
Tente isso:org.apache.o commons.math3.util.Precisão.round(double x, int escala)
Veja: http://commons.apache.org/proper/commons-math/apidocs/org/apache/commons/math3/util/Precision.html
Apache Commons Biblioteca Matemática página é: http://commons.apache.org/proper/commons-math/index.html
O interno implemetation deste método é:
public static double round(double x, int scale) {
return round(x, scale, BigDecimal.ROUND_HALF_UP);
}
public static double round(double x, int scale, int roundingMethod) {
try {
return (new BigDecimal
(Double.toString(x))
.setScale(scale, roundingMethod))
.doubleValue();
} catch (NumberFormatException ex) {
if (Double.isInfinite(x)) {
return x;
} else {
return Double.NaN;
}
}
}
Se você realmente deseja números decimais para o cálculo (e não apenas para a saída), não utilize um binário baseado no formato de ponto flutuante, como dupla.
Use BigDecimal or any other decimal-based format.
Eu uso BigDecimal para cálculos, mas tenha em mente que é dependente do tamanho da números que você está lidando com.A maior parte das minhas implementações, acho análise de casal ou número inteiro Longo é suficiente para a grande número de cálculos.
Na verdade, eu usado recentemente analisado-a-Long para obter representações precisas (como oposição a hex resultados) em uma GUI para números tão grande como ################################# caracteres (como um exemplo).
Desde que eu encontrei nenhuma resposta completa sobre este tema que eu criei uma classe que deve lidar com isso corretamente, com o apoio de:
- Formatação:Formatar facilmente a um casal de seqüência de caracteres com um certo número de casas decimais
- Análise:Analisar o valor formatado de volta para casal
- Localidade:Formato e analisar utilizando a localidade padrão
- Notação exponencial:Iniciar usando a notação exponencial depois de um certo limiar
O uso é muito simples:
(Por causa do exemplo que estou usando uma localidade personalizada)
public static final int DECIMAL_PLACES = 2;
NumberFormatter formatter = new NumberFormatter(DECIMAL_PLACES);
String value = formatter.format(9.319); // "9,32"
String value2 = formatter.format(0.0000005); // "5,00E-7"
String value3 = formatter.format(1324134123); // "1,32E9"
double parsedValue1 = formatter.parse("0,4E-2", 0); // 0.004
double parsedValue2 = formatter.parse("0,002", 0); // 0.002
double parsedValue3 = formatter.parse("3423,12345", 0); // 3423.12345
Aqui é a classe:
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.text.ParseException;
import java.util.Locale;
public class NumberFormatter {
private static final String SYMBOL_INFINITE = "\u221e";
private static final char SYMBOL_MINUS = '-';
private static final char SYMBOL_ZERO = '0';
private static final int DECIMAL_LEADING_GROUPS = 10;
private static final int EXPONENTIAL_INT_THRESHOLD = 1000000000; // After this value switch to exponential notation
private static final double EXPONENTIAL_DEC_THRESHOLD = 0.0001; // Below this value switch to exponential notation
private DecimalFormat decimalFormat;
private DecimalFormat decimalFormatLong;
private DecimalFormat exponentialFormat;
private char groupSeparator;
public NumberFormatter(int decimalPlaces) {
configureDecimalPlaces(decimalPlaces);
}
public void configureDecimalPlaces(int decimalPlaces) {
if (decimalPlaces <= 0) {
throw new IllegalArgumentException("Invalid decimal places");
}
DecimalFormatSymbols separators = new DecimalFormatSymbols(Locale.getDefault());
separators.setMinusSign(SYMBOL_MINUS);
separators.setZeroDigit(SYMBOL_ZERO);
groupSeparator = separators.getGroupingSeparator();
StringBuilder decimal = new StringBuilder();
StringBuilder exponential = new StringBuilder("0.");
for (int i = 0; i < DECIMAL_LEADING_GROUPS; i++) {
decimal.append("###").append(i == DECIMAL_LEADING_GROUPS - 1 ? "." : ",");
}
for (int i = 0; i < decimalPlaces; i++) {
decimal.append("#");
exponential.append("0");
}
exponential.append("E0");
decimalFormat = new DecimalFormat(decimal.toString(), separators);
decimalFormatLong = new DecimalFormat(decimal.append("####").toString(), separators);
exponentialFormat = new DecimalFormat(exponential.toString(), separators);
decimalFormat.setRoundingMode(RoundingMode.HALF_UP);
decimalFormatLong.setRoundingMode(RoundingMode.HALF_UP);
exponentialFormat.setRoundingMode(RoundingMode.HALF_UP);
}
public String format(double value) {
String result;
if (Double.isNaN(value)) {
result = "";
} else if (Double.isInfinite(value)) {
result = String.valueOf(SYMBOL_INFINITE);
} else {
double absValue = Math.abs(value);
if (absValue >= 1) {
if (absValue >= EXPONENTIAL_INT_THRESHOLD) {
value = Math.floor(value);
result = exponentialFormat.format(value);
} else {
result = decimalFormat.format(value);
}
} else if (absValue < 1 && absValue > 0) {
if (absValue >= EXPONENTIAL_DEC_THRESHOLD) {
result = decimalFormat.format(value);
if (result.equalsIgnoreCase("0")) {
result = decimalFormatLong.format(value);
}
} else {
result = exponentialFormat.format(value);
}
} else {
result = "0";
}
}
return result;
}
public String formatWithoutGroupSeparators(double value) {
return removeGroupSeparators(format(value));
}
public double parse(String value, double defValue) {
try {
return decimalFormat.parse(value).doubleValue();
} catch (ParseException e) {
e.printStackTrace();
}
return defValue;
}
private String removeGroupSeparators(String number) {
return number.replace(String.valueOf(groupSeparator), "");
}
}
Apenas no caso de alguém ainda precisa de ajuda com isso.Esta solução funciona perfeitamente para mim.
private String withNoTrailingZeros(final double value, final int nrOfDecimals) {
return new BigDecimal(String.valueOf(value)).setScale(nrOfDecimals, BigDecimal.ROUND_HALF_UP).stripTrailingZeros().toPlainString();
}
retorna um String com a saída desejada.
O trecho de código abaixo mostra como exibir n dígitos.O truque é definir a variável pp 1 seguido de n zeros.No exemplo abaixo, a variável pp valor tem 5 zeros, então, 5 dígitos será exibida.
double pp = 10000;
double myVal = 22.268699999999967;
String needVal = "22.2687";
double i = (5.0/pp);
String format = "%10.4f";
String getVal = String.format(format,(Math.round((myVal +i)*pp)/pp)-i).trim();
Se você estiver usando DecimalFormat para converter double para String, é muito simples:
DecimalFormat formatter = new DecimalFormat("0.0##");
formatter.setRoundingMode(RoundingMode.HALF_UP);
double num = 1.234567;
return formatter.format(num);
Existem várias RoundingMode os valores enum para escolher, dependendo do comportamento que você necessita.
Eu vim aqui apenas querendo uma resposta simples sobre como arredondar um número.Este é um suplementar de resposta para fornecer isso.
Como arredondar um número em Java
O caso mais comum é usar Math.round().
Math.round(3.7) // 4
Os números são arredondados para o número inteiro mais próximo.Um .5 o valor é arredondado para cima.Se você precisa de arredondamento diferentes de comportamento do que isso, você pode usar um dos outros Matemática funções.Veja a comparação em baixo.
rodada
Como dito acima, este será arredondado para o número inteiro mais próximo. .5 casas decimais, arredondamento.Este método retorna um int.
Math.round(3.0); // 3
Math.round(3.1); // 3
Math.round(3.5); // 4
Math.round(3.9); // 4
Math.round(-3.0); // -3
Math.round(-3.1); // -3
Math.round(-3.5); // -3 *** careful here ***
Math.round(-3.9); // -4
ceil
Qualquer valor decimal é arredondado para o próximo número inteiro.Ele vai para o ceiling.Este método retorna um double.
Math.ceil(3.0); // 3.0
Math.ceil(3.1); // 4.0
Math.ceil(3.5); // 4.0
Math.ceil(3.9); // 4.0
Math.ceil(-3.0); // -3.0
Math.ceil(-3.1); // -3.0
Math.ceil(-3.5); // -3.0
Math.ceil(-3.9); // -3.0
chão
Qualquer valor decimal é arredondado para o próximo número inteiro.Este método retorna um double.
Math.floor(3.0); // 3.0
Math.floor(3.1); // 3.0
Math.floor(3.5); // 3.0
Math.floor(3.9); // 3.0
Math.floor(-3.0); // -3.0
Math.floor(-3.1); // -4.0
Math.floor(-3.5); // -4.0
Math.floor(-3.9); // -4.0
aps.htm
Isso é semelhante a rodada em que valores decimais arredondadas para o número inteiro mais próximo.No entanto, ao contrário de round, .5 valores arredondar para o número inteiro par.Este método retorna um double.
Math.rint(3.0); // 3.0
Math.rint(3.1); // 3.0
Math.rint(3.5); // 4.0 ***
Math.rint(3.9); // 4.0
Math.rint(4.5); // 4.0 ***
Math.rint(5.5); // 6.0 ***
Math.rint(-3.0); // -3.0
Math.rint(-3.1); // -3.0
Math.rint(-3.5); // -4.0 ***
Math.rint(-3.9); // -4.0
Math.rint(-4.5); // -4.0 ***
Math.rint(-5.5); // -6.0 ***
Para conseguir isso, podemos usar este formatador:
DecimalFormat df = new DecimalFormat("#.00");
String resultado = df.format(valor)
ou:
DecimalFormat df = new DecimalFormat("0.00"); :
Use este método para obter sempre duas casas decimais:
private static String getTwoDecimals(double value){
DecimalFormat df = new DecimalFormat("0.00");
return df.format(value);
}
A definição desta valores:
91.32
5.22
11.5
1.2
2.6
Usando o método podemos obter resultados:
91.32
5.22
11.50
1.20
2.60
Concordo com os escolhidos de resposta para usar DecimalFormat --- ou, alternativamente, BigDecimal.
Por favor leia Atualização abaixo o primeiro!
No entanto, se você fazer deseja arredondar o valor duplo e obter um double valor do resultado, você pode usar org.apache.commons.math3.util.Precision.round(..) como mencionado acima.A implementação usa BigDecimal, é lento e cria lixo.
Um semelhante, mas rápido e lixo-livre método é fornecido pelo DoubleRounder utilitário no decimal4j biblioteca:
double a = DoubleRounder.round(2.0/3.0, 3);
double b = DoubleRounder.round(2.0/3.0, 3, RoundingMode.DOWN);
double c = DoubleRounder.round(1000.0d, 17);
double d = DoubleRounder.round(90080070060.1d, 9);
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
Saída
0.667
0.666
1000.0
9.00800700601E10
Ver https://github.com/tools4j/decimal4j/wiki/DoubleRounder-Utility
Isenção de responsabilidade: Estou envolvido na decimal4j projeto.
Atualização:
Como o @iaforek apontou DoubleRounder retorna às vezes contraditório resultados.A razão é que ele executa matematicamente correta de arredondamento.Por exemplo, DoubleRounder.round(256.025d, 2) será arredondado para baixo, para 256.02 porque o duplo valor representado como 256.025 d é um pouco menor do que o racional valor 256.025 e, portanto, serão arredondados para baixo.
Notas:
- Este comportamento é muito semelhante ao que o
BigDecimal(double)construtor (mas não paravalueOf(double)que usa o construtor string). - O problema pode ser contornado com um duplo arredondamento passo para uma maior precisão, mas é complicado e eu não estou indo para os detalhes aqui
Por essas razões, e tudo mencionado acima, neste post eu não recomendamos o uso DoubleRounder.
Se você estiver usando uma tecnologia que tem um mínimo de JDK.Aqui está uma forma sem qualquer Java libs:
double scale = 100000;
double myVal = 0.912385;
double rounded = (int)((myVal * scale) + 0.5d) / scale;
DecimalFormat é a melhor forma para a saída, mas eu não prefiro.Eu sempre faço isso o tempo todo, porque ele devolver o dobro do valor.Para que eu possa usá-lo mais do que apenas de saída.
Math.round(selfEvaluate*100000d.0)/100000d.0;
OU
Math.round(selfEvaluate*100000d.0)*0.00000d1;
Se você precisa de grande valor de casas decimais, você pode utilizar BigDecimal em vez disso.De qualquer maneira .0 é importante.Sem ele, o arredondamento de 0.33333d5 retorno 0.33333 e apenas 9 dígitos são o permite.A segunda função, sem .0 tem problemas com 0.30000 retorno 0.30000000000000004.
Onde dp = casas decimais que você deseja, e valor é um duplo.
double p = Math.pow(10d, dp);
double result = Math.round(value * p)/p;
Tenha em mente que a Seqüência de caracteres.format() e DecimalFormat produzir cadeia de caracteres usando o padrão da Localidade.Portanto, eles podem escrever o número formatado com o ponto ou a vírgula como um separador entre o inteiro e partes decimais.Para certificar-se de que arredondado de Seqüência de caracteres com o formato que você deseja usar java.texto.NumberFormat assim:
Locale locale = Locale.ENGLISH;
NumberFormat nf = NumberFormat.getNumberInstance(locale);
// for trailing zeros:
nf.setMinimumFractionDigits(2);
// round to 2 digits:
nf.setMaximumFractionDigits(2);
System.out.println(nf.format(.99));
System.out.println(nf.format(123.567));
System.out.println(nf.format(123.0));
Serão impressos em idioma inglês (não importa o que sua localidade):0.99 123.57 123.00
O exemplo é retirado de Farenda - como converter duplo a Seqüência corretamente.
Se você Considere 5 ou n número de casas decimais.Pode ser esta resposta resolver o seu problema.
double a = 123.00449;
double roundOff1 = Math.round(a*10000)/10000.00;
double roundOff2 = Math.round(roundOff1*1000)/1000.00;
double roundOff = Math.round(roundOff2*100)/100.00;
System.out.println("result:"+roundOff);
A saída será: 123.01
isso pode ser resolvido com loop e função recursiva.
Em geral, o arredondamento é feito por escalar: round(num / p) * p
/**
* MidpointRounding away from zero ('arithmetic' rounding)
* Uses a half-epsilon for correction. (This offsets IEEE-754
* half-to-even rounding that was applied at the edge cases).
*/
double RoundCorrect(double num, int precision) {
double c = 0.5 * EPSILON * num;
// double p = Math.pow(10, precision); //slow
double p = 1; while (precision--> 0) p *= 10;
if (num < 0)
p *= -1;
return Math.round((num + c) * p) / p;
}
// testing edge cases
RoundCorrect(1.005, 2); // 1.01 correct
RoundCorrect(2.175, 2); // 2.18 correct
RoundCorrect(5.015, 2); // 5.02 correct
RoundCorrect(-1.005, 2); // -1.01 correct
RoundCorrect(-2.175, 2); // -2.18 correct
RoundCorrect(-5.015, 2); // -5.02 correct
