java - जावा में संख्या से दशमलव स्थानों को कैसे गोल करें




decimal rounding (20)

@ मिल्हौस: गोल करने के लिए दशमलव प्रारूप उत्कृष्ट है:

आप भी इसका उपयोग कर सकते हैं

DecimalFormat df = new DecimalFormat("#.00000");
df.format(0.912385);

यह सुनिश्चित करने के लिए कि आपके पीछे पीछे 0 है।

मैं जोड़ूंगा कि यह विधि वास्तविक संख्यात्मक, गोल करने वाली तंत्र प्रदान करने में बहुत अच्छी है - न केवल दृष्टि से, बल्कि प्रसंस्करण के दौरान भी।

Hypothetical: आपको एक जीयूआई कार्यक्रम में एक गोलाकार तंत्र को लागू करना है। परिणाम आउटपुट की सटीकता / परिशुद्धता को बदलने के लिए बस कैरेट प्रारूप (यानी ब्रैकेट के भीतर) को बदलें। इसलिए कि:

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। ############") और आप दशमलव के लिए 3.1415 9 26 दर्ज करते हैं, तो दशमलव फोर्मेट किसी भी कचरे का उत्पादन नहीं करता है ( उदाहरण के लिए शून्य शून्य) और वापस आ जाएगा: 3.1415926 .. यदि आप इस तरह से इच्छुक हैं। माना जाता है कि यह कुछ देवों की पसंद के लिए एक छोटी सी वर्बोज़ है - लेकिन हे, प्रसंस्करण के दौरान इसे कम स्मृति पदचिह्न मिला है और इसे कार्यान्वित करना बहुत आसान है।]

तो अनिवार्य रूप से, DecimalFormat की सुंदरता यह है कि यह एक साथ स्ट्रिंग उपस्थिति को संभालने के साथ-साथ गोल परिशुद्धता सेट के स्तर को भी संभालती है। Ergo: आपको एक कोड कार्यान्वयन की कीमत के लिए दो लाभ मिलते हैं। ;)

मैं जो चाहूंगा वह एक डबल टू स्ट्रिंग को परिवर्तित करने का एक तरीका है जो अर्ध-अप विधि का उपयोग करके गोल करता है - यानी यदि दशमलव को गोलाकार किया जाना है, तो यह हमेशा पिछली संख्या तक चलता है। अधिकांश स्थितियों में अधिकांश लोगों की अपेक्षा रखने के लिए यह मानक तरीका है।

मैं भी केवल महत्वपूर्ण अंकों को प्रदर्शित करना चाहता हूं - यानी कोई पिछला शून्य नहीं होना चाहिए।

मुझे पता है कि ऐसा करने का एक तरीका 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

जावा में इसे हासिल करने का सबसे अच्छा तरीका क्या है?


DecimalFormat उत्पादन करने का सबसे अच्छा तरीका है, लेकिन मैं इसे पसंद नहीं करता। मैं हमेशा यह हर समय करता हूं, क्योंकि यह दोहरा मूल्य लौटाता है। तो मैं इसे सिर्फ आउटपुट से अधिक उपयोग कर सकता हूं।

Math.round(selfEvaluate*100000d.0)/100000d.0;

या

Math.round(selfEvaluate*100000d.0)*0.00000d1;

यदि आपको बड़े दशमलव स्थान मान की आवश्यकता है, तो आप इसके बजाय BigDecimal का उपयोग कर सकते हैं। वैसे भी .0 महत्वपूर्ण है। इसके बिना 0.33333d5 की 0.3733 की वापसी और केवल 9 अंकों की अनुमति है। .0 बिना दूसरे समारोह में 0.30000 रिटर्न 0.30000000000000004 के साथ समस्याएं हैं।


आप DecimalFormat कक्षा का उपयोग कर सकते हैं।

double d = 3.76628729;

DecimalFormat newFormat = new DecimalFormat("#.##");
double twoDecimal =  Double.valueOf(newFormat.format(d));

आप निम्नलिखित उपयोगिता विधि का उपयोग कर सकते हैं-

public static double round(double valueToRound, int numberOfDecimalPlaces)
{
    double multipicationFactor = Math.pow(10, numberOfDecimalPlaces);
    double interestedInZeroDPs = valueToRound * multipicationFactor;
    return Math.round(interestedInZeroDPs) / multipicationFactor;
}

इसे आज़माएं: org.apache.commons.math3.util.Precision.round (डबल एक्स, int पैमाने)

देखें: http://commons.apache.org/proper/commons-math/apidocs/org/apache/commons/math3/util/Precision.html

अपाचे कॉमन्स गणित पुस्तकालय मुखपृष्ठ है: 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;
        }
    }
}

चूंकि मुझे इस विषय पर कोई पूरा उत्तर नहीं मिला है, इसलिए मैंने एक कक्षा को एक साथ रखा है जिसे इसे सही ढंग से संभालना चाहिए, इसके लिए समर्थन के साथ:

  • स्वरूपण : दशमलव स्थानों की एक निश्चित संख्या के साथ स्ट्रिंग को डबल करने के लिए आसानी से प्रारूपित करें
  • पार्सिंग : स्वरूपित मान को दो बार वापस पार्स करें
  • लोकेल : डिफ़ॉल्ट लोकेल का उपयोग करके प्रारूप और पार्स
  • घातीय नोटेशन : एक निश्चित दहलीज के बाद घातीय नोटेशन का उपयोग शुरू करें

उपयोग बहुत आसान है :

(इस उदाहरण के लिए मैं एक कस्टम लोकेल का उपयोग कर रहा हूं)

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 या BigDecimal का उपयोग करना है। फ़्लोटिंग-पॉइंट में दशमलव स्थान नहीं हैं, इसलिए आप संभवतः पहले स्थान पर उनमें से किसी विशिष्ट संख्या में गोल / छंटनी नहीं कर सकते हैं। आपको दशमलव रेडिक्स में काम करना है, और यही वह दो वर्ग है।

मैं निम्नलिखित थ्रेड को इस धागे के सभी उत्तरों के लिए काउंटर-उदाहरण के रूप में पोस्ट कर रहा हूं और वास्तव में सभी स्टैक ओवरफ्लो (और अन्यत्र) पर है जो गुणा के बाद गुणा के बाद गुणा की अनुशंसा करता है। यह इस तकनीक के समर्थकों पर यह बताने के लिए है कि निम्नलिखित कोड 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

संपादित करें: नीचे कुछ टिप्पणियों को संबोधित करने के लिए मैंने मॉड्यूलस ऑपरेशन के लिए new MathContext(16) और new MathContext(16) का उपयोग करके टेस्ट लूप के मॉड्यूलस भाग को 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

ध्यान रखें कि String.format () और DecimalFormat डिफ़ॉल्ट लोकेल का उपयोग कर स्ट्रिंग का उत्पादन करते हैं। इसलिए वे पूर्णांक और दशमलव भागों के बीच विभाजक के रूप में डॉट या कॉमा के साथ स्वरूपित संख्या लिख ​​सकते हैं। यह सुनिश्चित करने के लिए कि गोलाकार स्ट्रिंग प्रारूप में है, आप java.text.NumberFormat का उपयोग करना चाहते हैं:

  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));

Will print in English locale (no matter what your locale is): 0.99 123.57 123.00

The example is taken from Farenda - how to convert double to String correctly .


बस अगर किसी को अभी भी इसके साथ मदद की ज़रूरत है। यह समाधान मेरे लिए पूरी तरह से काम करता है।

private String withNoTrailingZeros(final double value, final int nrOfDecimals) {
return new BigDecimal(String.valueOf(value)).setScale(nrOfDecimals,  BigDecimal.ROUND_HALF_UP).stripTrailingZeros().toPlainString();

}

वांछित आउटपुट के साथ एक String देता है।


मान मानना ​​एक double , आप कर सकते हैं:

(double)Math.round(value * 100000d) / 100000d

यह 5 अंकों की सटीकता के लिए है। शून्य की संख्या decimals की संख्या इंगित करता है।


मैं DecimalFormat --- या वैकल्पिक रूप से BigDecimal का उपयोग करने के लिए चुने गए उत्तर से सहमत हूं।

कृपया पहले नीचे अपडेट पढ़ें!

हालांकि यदि आप डबल वैल्यू को गोल करना चाहते हैं और double वैल्यू परिणाम प्राप्त करना चाहते हैं, तो आप उपरोक्त वर्णित org.apache.commons.math3.util.Precision.round(..) उपयोग कर सकते हैं। कार्यान्वयन BigDecimal का उपयोग करता है, धीमा है और कचरा बनाता है।

दशमलव 4j लाइब्रेरी में DoubleRounder उपयोगिता द्वारा एक समान लेकिन तेज़ और कचरा मुक्त विधि प्रदान की जाती है:

 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);

उत्पादन होगा

 0.667
 0.666
 1000.0
 9.00800700601E10

https://github.com/tools4j/decimal4j/wiki/DoubleRounder-Utility देखें

अस्वीकरण: मैं दशमलव 4j प्रोजेक्ट में शामिल हूं।

अपडेट करें: जैसा कि @iaforek ने इंगित किया है कि डबलराउंडर कभी-कभी प्रतिद्वंद्वी परिणाम देता है। कारण यह है कि यह गणितीय सही दौर गोल करता है। उदाहरण के लिए DoubleRounder.round(256.025d, 2) को 256.02 तक गोल किया जाएगा क्योंकि 256.025d के रूप में प्रतिनिधित्व किया गया डबल मान तर्कसंगत मान 256.025 से थोड़ा छोटा है और इसलिए इसे गोल किया जाएगा।

टिप्पणियाँ:

  • यह व्यवहार BigDecimal(double) कन्स्ट्रक्टर के समान ही है (लेकिन स्ट्रिंग कन्स्ट्रक्टर का उपयोग करने वाले मूल्य valueOf(double) लिए नहीं है)।
  • पहली बार एक उच्च परिशुद्धता के लिए समस्या को डबल राउंडिंग चरण से घुमाया जा सकता है, लेकिन यह जटिल है और मैं यहां विवरण में नहीं जा रहा हूं

इस पोस्ट में उपरोक्त वर्णित उन कारणों और सब कुछ के लिए मैं DoubleRounder का उपयोग करने की अनुशंसा नहीं कर सकता


मैं यहां बस एक संख्या को गोल करने के बारे में एक सरल जवाब देना चाहता था। यह प्रदान करने के लिए एक पूरक जवाब है।

जावा में एक संख्या कैसे गोल करें

सबसे आम मामला Math.round() का उपयोग करना है।

Math.round(3.7) // 4

संख्या निकटतम पूर्ण संख्या में गोल हैं। ए .5 मान गोलाकार है। यदि आपको उससे अलग गोल करने की आवश्यकता है, तो आप अन्य Math कार्यों में से एक का उपयोग कर सकते हैं। नीचे तुलना देखें।

round

जैसा कि ऊपर बताया गया है, यह राउंड निकटतम पूर्ण संख्या में है। .5 decimals दौर ऊपर। यह विधि एक 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

कोई दशमलव मान अगले पूर्णांक तक गोल किया जाता है। यह छत आईएनजी में जाता है। यह विधि एक 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

floor

कोई दशमलव मान अगले पूर्णांक तक गोल किया जाता है। यह विधि एक 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

rint

यह निकटतम पूर्णांक के लिए उस दशमलव मानों के दौर के समान है। हालांकि, 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 ***

यदि आप वास्तव में गणना के लिए दशमलव संख्या चाहते हैं (और न केवल आउटपुट के लिए), द्विआधारी-आधारित फ़्लोटिंग पॉइंट प्रारूप का उपयोग डबल की तरह न करें। BigDecimal या किसी अन्य दशमलव-आधारित प्रारूप का प्रयोग करें। - पालो एबरमान

मैं गणना के लिए BigDecimal का उपयोग करता हूं, लेकिन ध्यान रखें कि यह उन संख्याओं के आकार पर निर्भर है जिनके साथ आप काम कर रहे हैं। मेरे अधिकांश कार्यान्वयन में, मुझे डबल या पूर्णांक से पार्सिंग मिलती है, बहुत बड़ी संख्या गणना के लिए पर्याप्त पर्याप्त है। असल में, मैंने हाल ही में ######################################################################################################## ############### वर्ण (उदाहरण के रूप में)।


यदि आप स्ट्रिंग के रूप में परिणाम चाहते हैं तो आप इसका क्या उपयोग कर सकते हैं इसका सारांश यहां दिया गया है:

  1. DecimalFormat#setRoundingMode() :

    DecimalFormat df = new DecimalFormat("#.#####");
    df.setRoundingMode(RoundingMode.HALF_UP);
    String str1 = df.format(0.912385)); // 0.91239
    
  2. BigDecimal#setScale()

    String str2 = new BigDecimal(0.912385)
        .setScale(5, BigDecimal.ROUND_HALF_UP)
        .toString();
    

यदि आप परिणामस्वरूप double चाहते हैं तो आप किस लाइब्रेरी का उपयोग कर सकते हैं इसका एक सुझाव यहां दिया गया है। मैं स्ट्रिंग रूपांतरण के लिए इसकी अनुशंसा नहीं करता, हालांकि, डबल जो आप वास्तव में चाहते हैं उसका प्रतिनिधित्व करने में सक्षम नहीं हो सकते हैं (उदाहरण के लिए here देखें):

  1. अपाचे कॉमन्स मैथ से Precision

    double rounded = Precision.round(0.912385, 5, BigDecimal.ROUND_HALF_UP);
    
  2. कोल्ट से Functions

    double rounded = Functions.round(0.00001).apply(0.912385)
    
  3. Utils से उपयोग करता है

    double rounded = Utils.roundDouble(0.912385, 5)
    

setRoundingMode उपयोग करें, setRoundingMode को आधे-राउंड के साथ अपनी समस्या को संभालने के लिए स्पष्ट रूप से सेट करें, फिर अपने आवश्यक आउटपुट के लिए प्रारूप पैटर्न का उपयोग करें।

उदाहरण:

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

If you Consider 5 or n number of decimal. May be this answer solve your prob.

    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);

Output will be: 123.0 1
this can be solve with loop and recursive function.


In general, rounding is done by scaling: 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


To achieve this we can use this formatter:

 DecimalFormat df = new DecimalFormat("#.00");
 String resultado = df.format(valor)

या:

DecimalFormat df = new DecimalFormat("0.00"); :

Use this method to get always two decimals:

   private static String getTwoDecimals(double value){
      DecimalFormat df = new DecimalFormat("0.00"); 
      return df.format(value);
    }

Defining this values:

91.32
5.22
11.5
1.2
2.6

Using the method we can get this results:

91.32
5.22
11.50
1.20
2.60

demo online.


DecimalFormat myFormatter = new DecimalFormat("0.000");
String output = myFormatter.format(2.34d);

double myNum = .912385;
int precision = 10000; //keep 4 digits
myNum= Math.floor(myNum * precision +.5)/precision;






digits