BigDecimal

Question

में से अधिक दो अनुगामी शून्य ट्रिम एक BigDecimal के लिए दो से अधिक अनुगामी शून्य ट्रिम करने के लिए साथ ही

तो 1.2200 प्रिंट 1.22 और 1.0000 मुद्रित होगा 1.00

संपादित हैं एक अच्छा तरीका हो सकता है क्या 1.222200 1.2222 और १.२२,००,००,००१ १.२२,००,००,००१ आदि के रूप में के रूप में वापस जाने के लिए तो पहले दो शून्य अनदेखी मैं किसी भी भेजे 0s ट्रिम करने के लिए और ट्रिम नहीं गैर शून्य चाहते महत्व देता

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

बदसूरत समाधान folows रूप

System.out.println(((new BigDecimal("1.230223000") 
           .multiply(new BigDecimal("100.0")) 
           .stripTrailingZeros()).divide(new BigDecimal("100.0")))); 

Answer 1

चेक इस,

import java.text.DecimalFormat; 
import java.text.NumberFormat; 

public class DecimalFormatExample 
{ 
    public static void main(String args[]) 
    { 
    double amount = 2192.015; 
    NumberFormat formatter = new DecimalFormat("#0.00"); 
    System.out.println("The Decimal Value is:"+formatter.format(amount)); 
    } 
} 

Answer 2

अद्यतन है: उन मिश्रित आवश्यकताओं के बाद (यानी दशमलव बिंदु के बाद कम से कम 2 अंक प्रदर्शित किया जाना चाहिए, लेकिन आवश्यक के रूप में कई) तुच्छता से लागू नहीं किया गया है, लेकिन आप ही कर सकती है:

DecimalFormat के साथ मिलाएं stripTrailingZeros() वांछित व्यवहार प्राप्त करने के लिए (या इसे बंद करने):

DecimalFormat df = new DecimalFormat("0.00########") 
String formatted = df.format(bigDecimal.stripTrailingZeros()) 

यह दशमलव बिंदु के बाद कम से कम 2 अंकों के साथ BigDecimal मान को दशमलव बिंदु के बाद और दशमलव बिंदु के बाद 10 अंकों तक प्रारूपित करेगा, यदि यह परिशुद्धता में सुधार करता है। अधिक दशमलव बिंदु के बाद 10 अंक की तुलना में साथ

BigDecimal मूल्यों अभी भी काट दिया जाएगा:

 
     input  | output 
-----------------+---------- 
1.20000   | 1.20 
1.23000   | 1.23 
1.2301   | 1.2301 
1.230001000  | 1.230001 
1.2300000000001 | 1.23 

---

मूल जवाब:

आप हमेशा ठीक 2 करना चाहते हैं अल्पविराम के बाद अंक और पता है कि आप इस तरह सटीकता खोना नहीं चाहते हैं, तो आप setScale(2, RoundingMode.UNNECESSARY) पर कॉल कर सकते हैं:

System.out.println(new BigDecimal("1.23000").setScale(2, RoundingMode.UNNECESSARY)); 

यह कोड 1.23 प्रिंट करेगा। ध्यान दें कि यह ArithmeticException फेंक देगा जब गोल करना जरूरी होगा (यानी पहले 2 अंकों के बाद शून्य नहीं है)।

अपने मूल्यों एक उच्च परिशुद्धता हो सकता है और आप कुछ राउंडिंग लागू करना चाहते हैं, तो बस the appropriate value साथ RoundingMode.UNNECESSARY बदल देते हैं:

System.out.println(new BigDecimal("1.2301").setScale(2, RoundingMode.CEILING)); 

यह 1.24 प्रिंट होगा।

आप अंकों की सही संख्या पता नहीं है, लेकिन चाहते हैं संभव के रूप में कुछ (यानी आप अपने BigDecimal के लिए छोटी संभव scale चाहते हैं) तो बुला stripTrailingZeros() आप क्या चाहते हैं वास्तव में क्या करेंगे:

System.out.println(new BigDecimal("1.230001000").stripTrailingZeros(); 

यह 1.230001 प्रिंट करेगा।

Answer 3

इस विधि आप परिणाम आप चाहते हैं (मौद्रिक दौर) दे देंगे: (स्ट्रिंग है क्या, क्योंकि यह बेहतर है के लिए BigDecimal दस्तावेज़ देखें)

public static float roundUp(String what, int howmuch) throws Exception{ 

    try { 
     return (new BigDecimal(what).setScale(howmuch, BigDecimal.ROUND_UP)).floatValue(); 
    } catch (NumberFormatException nfe) { 
     throw new Exception("BigDecimal cannot parse value : " + what, nfe); 
    } 
} 

Answer 4

तो यह है प्रदर्शित करने के लिए प्रयोजनों का उपयोग करें:

BigDecimal d = new BigDecimal("1.2200"); 
NumberFormat n = NumberFormat.getCurrencyInstance(Locale.US); 
String s = n.format(d.doubleValue()); 

Answer 5

BigDecimal d = new BigDecimal("59.0000"); 
String d1 = new DecimalFormat().format(d); 
System.out.println("d1 is " + d1); 

Answer 6

String के रूप में आउटपुट के लिए, DecimalFormat का उपयोग करें।

public static BigDecimal stripToMinimumScale(BigDecimal value, 
              final int minimumScale) { 
    if (value.scale() == minimumScale) // Already correct scale 
    return value; 
    else { 
    value = value.stripTrailingZeros(); 
    return (value.scale() < minimumScale) ? 
     value.setScale(minimumScale) : // Too few decimals, needs zero pad 
     value; // Do not round any significant digits 
    } 
}