दिलचस्प पोस्ट
हर फाइल में एक निर्देशिका में बदलना बिना सहेजे updates_attributes रेल? HTML नेस्टेड सूची बनाने का उचित तरीका है? एक DataTable में एन डेटाटैबल्स का संयोजन क्या इसकी विकल्प सूची दिखाने के लिए एक HTML चयन खोलने के लिए जेएस का उपयोग करना संभव है? टैग के बीच पाठ निकालने के लिए जावा रेगेक्स IOS क्रैश डंप में कस्टम डेटा शामिल करना GoogleSignatureVerifier हस्ताक्षर मान्य संदेश नहीं है (Google Play सेवाओं 9.0.0) पुश नोटिफिकेशन को प्रबंधित करना जब ऐप नहीं चल रहा है ऐरे सूची से डुप्लिकेट निकालें वसंत RestTemplate अनुरोध पर एक "स्वीकार करें" हेडर कैसे सेट करें? आप कभी भी अंतिम रूप से () को क्यों लागू करेंगे? वेबसाइट तक पहुंचने से डारोदर.डॉम जैसी स्पैम रेफरर को कैसे ब्लॉक करें? PHP में एक बहुआयामी सरणी छंटनी? डिस्क की क्षमता और दूरस्थ कंप्यूटर की रिक्त स्थान कैसे प्राप्त करें

मैं जावा में डबल से दो दशमलव स्थानों को कैसे गोल करूं?

यह है कि मैंने दो दशमलव स्थानों से दो बार गोल किया है:

amount = roundTwoDecimals(amount); public double roundTwoDecimals(double d) { DecimalFormat twoDForm = new DecimalFormat("#.##"); return Double.valueOf(twoDForm.format(d)); } 

यह बहुत अच्छा काम करता है यदि राशि = 25.3569 या ऐसा कुछ, लेकिन अगर राशि = 25.00 या राशि = 25.0, तो मुझे 25.0 मिलता है! मुझे क्या चाहिए दोनों गोलाई और साथ ही 2 दशमलव स्थानों पर स्वरूपण।

वेब के समाधान से एकत्रित समाधान "मैं जावा में डबल से दो दशमलव स्थानों को कैसे गोल करूं?"

क्या आप पैसे के साथ काम कर रहे हैं? एक String बनाना और फिर इसे वापस परिवर्तित करना बहुत लूट है

BigDecimal उपयोग करें इस पर काफी बड़े पैमाने पर चर्चा की गई है। आपके पास एक Money क्लास होना चाहिए और यह राशि एक BigDecimal होना चाहिए।

यहां तक ​​कि अगर आप पैसे के साथ काम नहीं कर रहे हैं, तो BigDecimal

बस का उपयोग करें: (पाई के रूप में आसान)

 double number = 651.5176515121351; number = Math.round(number * 100); number = number/100; 

उत्पादन 651.52 हो जाएगा

अंक स्थान धारक ( 0 ) का प्रयोग करें, जैसा कि ' # ' पीछे / अग्रणी शून्य के साथ अनुपस्थित के रूप में दिखाया गया है:

 DecimalFormat twoDForm = new DecimalFormat("#.00"); 

आप [किसी भी दशमलव दशमलव स्थानों के लिए] दो बार गोल नहीं कर सकते , क्योंकि डबल्स में दशमलव स्थान नहीं हैं आप एन-दशमलव स्थानों के साथ बेस -10 स्ट्रिंग में एक डबल को कनवर्ट कर सकते हैं, क्योंकि बेस -10 में दशमलव स्थान होते हैं, लेकिन जब आप इसे वापस बदलते हैं, तो आप द्वि-भूमि में दोबारा आंशिक स्थान के साथ वापस आ जाते हैं।

यह सबसे सरल है, मैं इसे बना सकता हूं, लेकिन यह नौकरी की सबसे अधिक उदाहरणों की तुलना में बहुत आसान हो गया।

  double total = 1.4563; total = Math.round(total * 100); System.out.println(total / 100); 

परिणाम 1.46 है।

आप org.apache.commons.math.util.MathUtils अपाचे सामान्य से उपयोग कर सकते हैं

double round = MathUtils.round(double1, 2, BigDecimal.ROUND_HALF_DOWN);

इसे इस्तेमाल करो

String.format ("% .2f", डबल वैल्यू) // परिवर्तन 2, अपनी आवश्यकता के अनुसार।

आप अपाचे कॉमन्स मठ का उपयोग कर सकते हैं:

 Precision.round(double x, int scale) 

स्रोत: http://commons.apache.org/proper/commons-math/apidocs/org/apache/commons/math3/util/Precision.html#round(double,% 20int)

आपका धन वर्ग लंबे समय के उप-वर्ग के रूप में प्रतिनिधित्व किया जा सकता है या किसी सदस्य के रूप में धन मूल्य का प्रतिनिधित्व करने वाला एक मूल लंबे फिर जब आपके पैसे के तत्काल मूल्यों को निर्दिष्ट करते हैं, तो आप हमेशा ऐसे मूल्यों को संग्रहित करेंगे जो वास्तव में असली धन मूल्य हैं। आप केवल अपनी मुद्रा ऑब्जेक्ट (आपके पैसे की ओवरराइड टू स्ट्रिंग () विधि के माध्यम से) को उपयुक्त स्वरूपण के साथ आउटपुट कर सकते हैं। उदाहरण के तौर पर मनी ऑब्जेक्ट के आंतरिक प्रतिनिधित्व में 1.25 डॉलर है 125. आप सेंट, या पैंस के रूप में पैसे का प्रतिनिधित्व करते हैं या जो कुछ भी आप मुद्रा कर रहे हैं उसमें न्यूनतम संप्रदाय है … तो इसे आउटपुट पर प्रारूपित करें नहीं, आप कभी भी 'अवैध' धनराशि नहीं रख सकते हैं, जैसे कि $ 1.257 कहते हैं

दोहरी राशि = 25.00;

संख्याफ़ॉर्मेट फॉर्मेटर = नया दशमलवफल ("# 0.00");

Println (formatter.format (राशि));

 DecimalFormat df = new DecimalFormat("###.##"); double total = Double.valueOf(val); 

यदि आप दो दशमलव स्थानों का परिणाम चाहते हैं तो आप ऐसा कर सकते हैं

 // assuming you want to round to Infinity. double tip = (long) (amount * percent + 0.5) / 100.0; 

यह परिणाम सटीक नहीं है, लेकिन इसके लिए डबल। टू स्ट्रिंग (डबल) सही होगा और एक से दो दशमलव स्थानों को प्रिंट करेंगे। हालांकि जैसे ही आप एक और गणना करते हैं, आप एक परिणाम प्राप्त कर सकते हैं जो निहित रूप से गोल नहीं होगा। 😉

Math.round एक जवाब है,

 public class Util { public static Double formatDouble(Double valueToFormat) { long rounded = Math.round(valueToFormat*100); return rounded/100.0; } } 

स्पॉक, ग्रूवी में टेस्ट करें

 void "test double format"(){ given: Double performance = 0.6666666666666666 when: Double formattedPerformance = Util.formatDouble(performance) println "######################## formatted ######################### => ${formattedPerformance}" then: 0.67 == formattedPerformance } 

राशि को मानना ​​सकारात्मक और नकारात्मक हो सकता है, दो दशमलव स्थानों पर गोलाकार कोड स्निपेट के निम्नलिखित टुकड़े का उपयोग कर सकते हैं।

 amount = roundTwoDecimals(amount); public double roundTwoDecimals(double d) { if (d < 0) d -= 0.005; else if (d > 0) d += 0.005; return (double)((long)(d * 100.0))/100); } 

जावा 1.8 को शुरू करने से आप लैम्ब्डा भाव के साथ और शून्य के लिए चेक कर सकते हैं। इसके अलावा, नीचे एक फ्लोट या डबल और चर दशमलव अंकों की संख्या (2 🙂 सहित) को संभाल सकता है।

 public static Double round(Number src, int decimalPlaces) { return Optional.ofNullable(src) .map(Number::doubleValue) .map(BigDecimal::new) .map(dbl -> dbl.setScale(decimalPlaces, BigDecimal.ROUND_HALF_UP)) .map(BigDecimal::doubleValue) .orElse(null); } 

जहां संख्या डबल संख्या है

  • पूर्णांक 2 दशमलव स्थानों की संख्या को दर्शाता है जो हम प्रिंट करना चाहते हैं।
  • यहां हम 2 दशमलव पलस ले रहे हैं

    System.out.printf ( "।% 2f", संख्या);

आप यह कोशिश कर सकते हैं:

 public static String getRoundedValue(Double value, String format) { DecimalFormat df; if(format == null) df = new DecimalFormat("#.00"); else df = new DecimalFormat(format); return df.format(value); } 

या

 public static double roundDoubleValue(double value, int places) { if (places < 0) throw new IllegalArgumentException(); long factor = (long) Math.pow(10, places); value = value * factor; long tmp = Math.round(value); return (double) tmp / factor; } 

यहां एक आसान तरीका है कि मेरी फिक्स एनएम आउटपुट को दो दशमलव स्थानों पर गिरे जाने की गारंटी दी गई है:

 import java.text.DecimalFormat; public class TwoDecimalPlaces { static double myFixedNumber = 98765.4321; public static void main(String[] args) { System.out.println(new DecimalFormat("0.00").format(myFixedNumber)); } } 

नतीजा यह है: 98765.43

  int i = 180; int j = 1; double div= ((double)(j*100)/i); DecimalFormat df = new DecimalFormat("#.00"); // simple way to format till any deciaml points System.out.println(div); System.out.println(df.format(div)); 

पहले DecimalFormat क्लास का ऑब्जेक्ट घोषित करें। नोट दशमलव के अंदर तर्क #.00 जिसका मतलब है कि गोल के बंद होने के लगभग 2 दशमलव स्थान हैं।

 private static DecimalFormat df2 = new DecimalFormat("#.00"); 

अब, प्रारूप को अपने डबल मान में लागू करें:

 double input = 32.123456; System.out.println("double : " + df2.format(input)); // Output: 32.12 

double input = 32.1;

तब आउटपुट 32.10 और इसी तरह होगा।