질문자 :Alex Spurling
내가 원하는 것은 double을 반올림 방법을 사용하여 반올림하는 문자열로 변환하는 방법입니다. 즉, 반올림할 소수점이 5이면 항상 다음 숫자로 반올림됩니다. 이것은 대부분의 사람들이 대부분의 상황에서 기대하는 표준 반올림 방법입니다.
또한 유효 숫자만 표시하고 싶습니다. 즉, 후행 0이 없어야 합니다.
이 작업을 수행하는 한 가지 방법은 String.format 메서드를 사용하는 것입니다.
String.format("%.5g%n", 0.912385);
보고:
0.91239
훌륭하지만 중요하지 않더라도 항상 소수점 이하 5자리의 숫자를 표시합니다.
String.format("%.5g%n", 0.912300);
보고:
0.91230
DecimalFormatter 를 사용하는 것입니다.
DecimalFormat df = new DecimalFormat("#.#####"); df.format(0.912385);
보고:
0.91238
그러나 보시다시피 이것은 반 짝수 반올림을 사용합니다. 즉, 이전 숫자가 짝수이면 반올림됩니다. 내가 원하는 것은 다음과 같습니다.
0.912385 -> 0.91239 0.912300 -> 0.9123
Java에서 이것을 달성하는 가장 좋은 방법은 무엇입니까?
setRoundingMode 를 사용하고 RoundingMode 명시적으로 설정하여 반올림 문제를 처리한 다음 필요한 출력에 형식 패턴을 사용합니다.
예시:
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)); }
출력을 제공합니다:
12 123.1235 0.23 0.1 2341234.2125
편집 : 원래 답변은 이중 값의 정확성을 다루지 않습니다. 반올림이든 내림이든 크게 신경 쓰지 않으면 괜찮습니다. 그러나 정확한 반올림을 원하면 값의 예상 정확도를 고려해야 합니다. 부동 소수점 값은 내부적으로 이진 표현을 갖습니다. 즉, 2.7735와 같은 값은 실제로 내부적으로 정확한 값을 갖지 않습니다. 약간 더 크거나 약간 작을 수 있습니다. 내부 값이 약간 작으면 2.7740으로 반올림되지 않습니다. 이러한 상황을 해결하려면 작업 중인 값의 정확성을 인식하고 반올림하기 전에 해당 값을 더하거나 빼야 합니다. 예를 들어, 값이 최대 6자리까지 정확하다는 것을 알고 있는 경우 값을 반올림하려면 해당 정확도를 값에 추가합니다.
Double d = n.doubleValue() + 1e-6;
반올림하려면 정확도를 뺍니다.
value 이 double 이라고 가정하면 다음을 수행할 수 있습니다.
(double)Math.round(value * 100000d) / 100000d
5자리 정밀도를 위한 것입니다. 0의 수는 소수를 나타냅니다.
new BigDecimal(String.valueOf(double)).setScale(yourScale, BigDecimal.ROUND_HALF_UP);
BigDecimal 을 얻을 것입니다. 문자열을 가져오려면 해당 BigDecimal 의 toString 메서드를 호출하거나 일반 형식 문자열의 경우 Java 5+의 toPlainString
샘플 프로그램:
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)); }
당신은 또한 사용할 수 있습니다
DecimalFormat df = new DecimalFormat("#.00000"); df.format(0.912385);
후행 0이 있는지 확인하십시오.
다른 사람들이 지적했듯이 정답은 DecimalFormat 또는 BigDecimal 을 사용하는 것입니다. 부동 소수점에는 소수 자릿수가 없으므로 처음부터 특정 수로 반올림/자를 수 없습니다. 십진법 기수로 작업해야 하며, 이것이 바로 이 두 클래스가 하는 일입니다.
저는 이 스레드의 모든 답변에 대한 반례로 다음 코드를 게시하고 실제로 StackOverflow(및 다른 곳에서) 전체에 걸쳐 곱셈, 잘림, 나눗셈을 권장합니다. 다음 코드가 92% 이상의 경우에서 잘못된 출력을 생성하는 이유를 설명하는 것은 이 기술의 옹호자들의 의무입니다.
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"); } }
이 프로그램의 출력:
10001 trials 9251 errors
편집: 아래 몇 가지 의견을 처리하기 위해 다음과 같이 모듈러스 작업에 BigDecimal 및 new MathContext(16) 를 사용하여 테스트 루프의 모듈러스 부분을 다시 수정했습니다.
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"); }
결과:
10001 trials 4401 errors
당신이 가지고 있다고 가정
double d = 9232.129394d;
BigDecimal 을 사용할 수 있습니다
BigDecimal bd = new BigDecimal(d).setScale(2, RoundingMode.HALF_EVEN); d = bd.doubleValue();
또는 BigDecimal 없이
d = Math.round(d*100)/100.0d;
두 솔루션 모두 d == 9232.13
DecimalFormat 클래스를 사용할 수 있습니다.
double d = 3.76628729; DecimalFormat newFormat = new DecimalFormat("#.##"); double twoDecimal = Double.valueOf(newFormat.format(d));
Real의 Java How-to는 Java 1.6 이전 버전과도 호환되는 이 솔루션 을 게시합니다.
BigDecimal bd = new BigDecimal(Double.toString(d)); bd = bd.setScale(decimalPlace, BigDecimal.ROUND_HALF_UP); return bd.doubleValue();
업데이트: BigDecimal.ROUND_HALF_UP은 더 이상 사용되지 않습니다 - RoundingMode 사용
BigDecimal bd = new BigDecimal(Double.toString(number)); bd = bd.setScale(decimalPlaces, RoundingMode.HALF_UP); return bd.doubleValue();
double myNum = .912385; int precision = 10000; //keep 4 digits myNum= Math.floor(myNum * precision +.5)/precision;
@Milhous: 반올림을 위한 10진수 형식은 훌륭합니다.
당신은 또한 사용할 수 있습니다
DecimalFormat df = new DecimalFormat("#.00000"); df.format(0.912385);
후행 0이 있는지 확인하십시오.
이 방법은 시각적으로 뿐만 아니라 처리할 때도 실제 숫자 반올림 메커니즘을 제공하는 데 매우 유용하다고 덧붙입니다.
가설: GUI 프로그램에 반올림 메커니즘을 구현해야 합니다. 결과 출력의 정확도/정밀도를 변경하려면 간단히 캐럿 형식(예: 대괄호 내)을 변경하십시오. 하도록하다:
DecimalFormat df = new DecimalFormat("#0.######"); df.format(0.912385);
출력으로 반환됩니다: 0.912385
DecimalFormat df = new DecimalFormat("#0.#####"); df.format(0.912385);
출력으로 반환됩니다: 0.91239
DecimalFormat df = new DecimalFormat("#0.####"); df.format(0.912385);
출력으로 반환됩니다: 0.9124
[편집: 또한 캐럿 형식이 이와 같으며("#0.###########") 인수를 위해 10진수(예: 3.1415926)를 입력하면 DecimalFormat은 가비지( 예: 후행 0) 및 반환: 3.1415926 .. 만약 당신이 그런 경향이 있다면. 물론 일부 개발자의 취향에는 다소 장황합니다. 하지만 처리하는 동안 메모리 사용량이 적고 구현하기가 매우 쉽습니다.]
따라서 본질적으로 DecimalFormat의 장점은 문자열 모양과 반올림 정밀도 집합을 동시에 처리한다는 것입니다. 즉, 하나의 코드 구현 비용으로 두 가지 이점을 얻을 수 있습니다. ;)
다음은 결과를 문자열로 원하는 경우 사용할 수 있는 요약입니다.
DecimalFormat#setRoundingMode() :
DecimalFormat df = new DecimalFormat("#.#####"); df.setRoundingMode(RoundingMode.HALF_UP); String str1 = df.format(0.912385)); // 0.91239
BigDecimal#setScale()
String str2 = new BigDecimal(0.912385) .setScale(5, BigDecimal.ROUND_HALF_UP) .toString();
결과적으로 double 를 원할 경우 사용할 수 있는 라이브러리에 대한 제안은 다음과 같습니다. 하지만 double 은 원하는 것을 정확하게 나타내지 못할 수 있으므로 문자열 변환에는 권장하지 않습니다(예: 여기 참조).
Apache Commons Math의 정밀도
double rounded = Precision.round(0.912385, 5, BigDecimal.ROUND_HALF_UP);
콜트의 기능
double rounded = Functions.round(0.00001).apply(0.912385)
Weka의 유틸리티
double rounded = Utils.roundDouble(0.912385, 5)
다음 유틸리티 방법을 사용할 수 있습니다.
public static double round(double valueToRound, int numberOfDecimalPlaces) { double multipicationFactor = Math.pow(10, numberOfDecimalPlaces); double interestedInZeroDPs = valueToRound * multipicationFactor; return Math.round(interestedInZeroDPs) / multipicationFactor; }
간결한 솔루션:
public static double round(double value, int precision) { int scale = (int) Math.pow(10, precision); return (double) Math.round(value * scale) / scale; }
https://stackoverflow.com/a/22186845/212950 도 참조하십시오. 이를 제공한 jpdymond 에게 감사드립니다.
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);
참조: http://www.javabeat.net/precise-rounding-of-decimals-using-rounding-mode-enumeration/
출력뿐만 아니라 계산을 위해 십진수를 정말로 원하면 double과 같은 이진 기반 부동 소수점 형식을 사용하지 마십시오.
Use BigDecimal or any other decimal-based format.
계산에 BigDecimal을 사용하지만 처리하는 숫자의 크기에 따라 다르다는 점을 명심하십시오. 대부분의 구현에서 double 또는 integer에서 Long으로의 구문 분석은 매우 큰 수 계산에 충분하다는 것을 알았습니다.
사실, 나는 최근에 ##################만큼 큰 숫자에 대한 GUI에서 정확한 표현(16진수 결과와 반대)을 얻기 위해 Long parsed를 사용했습니다. ############### 문자(예시).
이것을 시도하십시오: org.apache.commons.math3.util.Precision.round(double x, int scale)
참조: http://commons.apache.org/proper/commons-math/apidocs/org/apache/commons/math3/util/Precision.html
Apache Commons Mathematics Library 홈페이지: http://commons.apache.org/proper/commons-math/index.html
이 메서드의 내부 구현은 다음과 같습니다.
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; } } }
이 주제에 대한 완전한 답변을 찾지 못했기 때문에 다음을 지원하면서 이를 적절하게 처리해야 하는 클래스를 구성했습니다.
- 서식 지정 : 특정 소수점 이하 자릿수를 사용하여 double을 string형으로 쉽게 서식 지정
- 구문 분석 : 형식이 지정된 값을 다시 두 배로 구문 분석합니다.
- 로케일 : 기본 로케일을 사용하여 형식 지정 및 구문 분석
- 지수 표기법 : 특정 임계값 이후에 지수 표기법 사용 시작
사용법은 매우 간단합니다 .
(이 예에서는 사용자 지정 로캘을 사용하고 있습니다.)
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
클래스는 다음과 같습니다 .
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), ""); } }
이를 달성하기 위해 다음 포맷터를 사용할 수 있습니다.
DecimalFormat df = new DecimalFormat("#.00"); String resultado = df.format(valor)
또는:
DecimalFormat df = new DecimalFormat("0.00"); :
항상 두 개의 소수를 얻으려면 이 방법을 사용하십시오.
private static String getTwoDecimals(double value){ DecimalFormat df = new DecimalFormat("0.00"); return df.format(value); }
이 값 정의:
91.32 5.22 11.5 1.2 2.6
이 방법을 사용하면 다음과 같은 결과를 얻을 수 있습니다.
91.32 5.22 11.50 1.20 2.60
온라인 데모.
DecimalFormat --- 또는 BigDecimal 을 사용하기 위해 선택한 답변에 동의합니다.
먼저 아래 업데이트를 읽어주세요!
당신이 double 값을 반올림하고 싶지 않습니다 그러나 경우 double 값의 결과를, 당신은 사용할 수 있습니다 org.apache.commons.math3.util.Precision.round(..) 위에서 언급 한 바와 같이. 구현은 BigDecimal 사용하며 느리고 가비지를 생성합니다.
비슷한하지만 신속하고 쓰레기없는 방법에 의해 제공되는 DoubleRounder decimal4j 라이브러리의 유틸리티 :
누군가가 여전히 도움이 필요한 경우를 대비하여. 이 솔루션은 저에게 완벽하게 작동합니다.
private String withNoTrailingZeros(final double value, final int nrOfDecimals) { return new BigDecimal(String.valueOf(value)).setScale(nrOfDecimals, BigDecimal.ROUND_HALF_UP).stripTrailingZeros().toPlainString(); }
원하는 출력이 String 을 반환합니다.
나는 숫자를 반올림하는 방법에 대한 간단한 대답을 원해서 여기에 왔습니다. 이를 제공하기 위한 보충 답변입니다.
Java에서 숫자를 반올림하는 방법
가장 일반적인 경우는 Math.round() 를 사용하는 것입니다.
Math.round(3.7) // 4
숫자는 가장 가까운 정수로 반올림됩니다. .5 값은 반올림됩니다. 다른 반올림 동작이 필요한 경우 다른 Math 함수 중 하나를 사용할 수 있습니다. 아래 비교를 참조하십시오.
위에서 언급했듯이 이것은 가장 가까운 정수로 반올림됩니다. .5 소수점은 반올림합니다. 이 메서드는 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
모든 십진수 값은 다음 정수로 반올림됩니다. 천정 까지 갑니다. 이 메서드는 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
모든 십진수 값은 다음 정수로 내림됩니다. 이 메서드는 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
이것은 소수점 값이 가장 가까운 정수로 반올림된다는 점에서 반올림과 유사합니다. round 와 달리 .5 값은 짝수 정수로 반올림됩니다. 이 메서드는 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 ***
최소한의 JDK가 있는 기술을 사용하는 경우. Java 라이브러리가 없는 방법은 다음과 같습니다.
double scale = 100000; double myVal = 0.912385; double rounded = (int)((myVal * scale) + 0.5d) / scale;
1.005 와 같은 엣지 케이스를 올바르게 반올림하는 더 나은 기능입니다.
간단히 말해서, 우리는 반올림하기 전에 숫자에 가능한 가장 작은 부동 소수점 값(= 1 ulp; 마지막 위치의 단위)을 추가합니다. 이것은 0에서 멀리 떨어진 숫자 다음의 표현 가능한 값으로 이동합니다.
이것은 그것을 테스트하기 위한 작은 프로그램입니다: ideone.com
/** * Round half away from zero ('commercial' rounding) * Uses correction to offset floating-point inaccuracies. * Works symmetrically for positive and negative numbers. */ public static double round(double num, int digits) { // epsilon correction double n = Double.longBitsToDouble(Double.doubleToLongBits(num) + 1); double p = Math.pow(10, digits); return Math.round(n * p) / p; } // test rounding of half System.out.println(round(0.5, 0)); // 1 System.out.println(round(-0.5, 0)); // -1 // testing edge cases System.out.println(round(1.005, 2)); // 1.01 System.out.println(round(2.175, 2)); // 2.18 System.out.println(round(5.015, 2)); // 5.02 System.out.println(round(-1.005, 2)); // -1.01 System.out.println(round(-2.175, 2)); // -2.18 System.out.println(round(-5.015, 2)); // -5.02
아래 코드 스니펫은 n자리를 표시하는 방법을 보여줍니다. 트릭은 변수 pp를 1로 설정한 다음 n개의 0으로 설정하는 것입니다. 아래 예에서 변수 pp 값은 5개의 0을 가지므로 5자리가 표시됩니다.
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();
DecimalFormat 을 사용하여 double 을 String 으로 변환하는 경우 매우 간단합니다.
DecimalFormat formatter = new DecimalFormat("0.0##"); formatter.setRoundingMode(RoundingMode.HALF_UP); double num = 1.234567; return formatter.format(num);
필요한 동작에 따라 선택할 수 있는 여러 RoundingMode 열거형 값이 있습니다.
DecimalFormat은 출력하는 가장 좋은 방법이지만 선호하지 않습니다. 이중 값을 반환하기 때문에 항상 이 작업을 수행합니다. 그래서 출력 이상으로 사용할 수 있습니다.
Math.round(selfEvaluate*100000d.0)/100000d.0;
또는
Math.round(selfEvaluate*100000d.0)*0.00000d1;
큰 소수 자릿수 값이 필요한 경우 대신 BigDecimal을 사용할 수 있습니다. 어쨌든 .0 이 중요합니다. 그것 없이는 0.33333d5를 반올림하면 0.33333이 반환되고 9자리만 허용됩니다. .0 이 없는 두 번째 함수는 0.30000이 0.30000000000000004를 반환하는 데 문제가 있습니다.
여기 내 대답이 있습니다 :
double num = 4.898979485566356; DecimalFormat df = new DecimalFormat("#.##"); time = Double.valueOf(df.format(num)); System.out.println(num); // 4.89
나는 자바 8에서처럼 벨로우즈를 사용했다. 그것은 나를 위해 일하고있다.
double amount = 1000.431; NumberFormat formatter = new DecimalFormat("##.00"); String output = formatter.format(amount); System.out.println("output = " + output);
산출:
output = 1000.43
따라서 대부분의 답변을 읽은 후 대부분의 답변이 정확하지 않다는 것을 깨달았습니다. 실제로 BigDecimal 사용하는 것이 최선의 선택인 것처럼 보이지만 RoundingMode 작동 방식을 이해하지 못하면 불가피하게 정확도를 잃게 됩니다. 프로젝트에서 큰 숫자로 작업할 때 이것을 알아냈고 숫자를 반올림하는 데 문제가 있는 다른 사람들에게 도움이 될 수 있다고 생각했습니다. 예를 들어.
BigDecimal bd = new BigDecimal("1363.2749"); bd = bd.setScale(2, RoundingMode.HALF_UP); System.out.println(bd.doubleValue());
출력으로 1363.28 을 얻을 것으로 예상 RoundingMode 가 무엇을 하는지 모르는 경우 예상하지 못한 1363.27 따라서 Oracle Docs를 RoundingMode.HALF_UP 대한 다음 설명을 찾을 수 있습니다.
두 이웃이 같은 거리에 있지 않은 경우 "가장 가까운 이웃"을 향해 반올림하는 반올림 모드(이 경우 반올림).
그래서 이것을 알고 우리는 가장 가까운 이웃 쪽으로 반올림하지 않는 한 정확한 반올림을 얻지 못할 것이라는 것을 깨달았습니다. 따라서 적절한 반올림을 수행하려면 n-1 소수에서 원하는 소수 자릿수로 루프해야 합니다. 예를 들어.
private double round(double value, int places) throws IllegalArgumentException { if (places < 0) throw new IllegalArgumentException(); // Cast the number to a String and then separate the decimals. String stringValue = Double.toString(value); String decimals = stringValue.split("\\.")[1]; // Round all the way to the desired number. BigDecimal bd = new BigDecimal(stringValue); for (int i = decimals.length()-1; i >= places; i--) { bd = bd.setScale(i, RoundingMode.HALF_UP); } return bd.doubleValue(); }
1363.28 이 될 것으로 예상되는 출력을 줄 것입니다.
double 필요한 경우 다음 방법을 사용할 수 있습니다.
double getRandom(int decimalPoints) { double a = Math.random(); int multiplier = (int) Math.pow(10, decimalPoints); int b = (int) (a * multiplier); return b / (double) multiplier; }
예를 들어 getRandom(2)
출처 : http:www.stackoverflow.com/questions/153724/how-to-round-a-number-to-n-decimal-places-in-java