java কীভাবে জাভাতে দশমিক স্থানগুলিতে একটি সংখ্যা বৃত্তাকার করবেন





14 Answers

অনুমান value একটি double , আপনি করতে পারেন:

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

যে 5 ডিজিটাল স্পষ্টতা জন্য। জিরো সংখ্যা দশমিক সংখ্যা নির্দেশ করে।

java decimal rounding digits

আমি যা চাই তা হল ডাবল-স্ট্রিং-র একটি স্ট্রিং যা অর্ধেক পদ্ধতি ব্যবহার করে রাউন্ডগুলিকে রূপান্তর করার একটি পদ্ধতি - অর্থাৎ যদি দশমিক বৃত্তাকার করা হয় 5 হয় তবে এটি সর্বদা পূর্ববর্তী সংখ্যা পর্যন্ত ঘোরাবে। এটি বেশিরভাগ ক্ষেত্রেই বেশিরভাগ মানুষের প্রত্যাশা পূরণের আদর্শ পদ্ধতি।

আমি শুধুমাত্র উল্লেখযোগ্য সংখ্যক অক্ষর প্রদর্শন করতে চাই - অর্থাত্ কোন পূর্ববর্তী শূন্যতা নেই।

আমি 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 df = new DecimalFormat("#.00000");
df.format(0.912385);

আপনি পিছনে 0 এর আছে তা নিশ্চিত করার জন্য।




ধরুন আপনার আছে

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




রিয়েল এর জাভা কিভাবে এই posts , যা জাভা 1.6 এর আগে সংস্করণগুলির জন্য উপযুক্ত।

BigDecimal bd = new BigDecimal(Double.toString(d));
bd = bd.setScale(decimalPlace, BigDecimal.ROUND_HALF_UP);
return bd.doubleValue();



@ মিলহাউস: বৃত্তাকার জন্য দশমিক বিন্যাস চমৎকার:

আপনি ব্যবহার করতে পারেন

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

আপনি পিছনে 0 এর আছে তা নিশ্চিত করার জন্য।

আমি যোগ করব যে এই পদ্ধতিটি প্রকৃত সংখ্যাসূচক, বৃত্তাকার প্রক্রিয়া প্রদানের ক্ষেত্রে খুব ভাল - কেবলমাত্র দৃশ্যমান নয়, তবে প্রক্রিয়াকরণের সময়ও।

Hypothetical: আপনি একটি 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 ############") এবং আপনি দশমিক লিখুন, যেমন 3.1415926, আর্গুমেন্টের কারণে, ডেসিমালফরম্যাট কোনও আবর্জনা উত্পাদন করে না ( উদাহরণস্বরূপ পিছনে জিরো) এবং ফিরে আসবে: 3.1415926 .. যদি আপনি যে ভাবে প্রবণ। অনুমিত, এটি কিছু dev এর পছন্দ করার জন্য একটু শব্দের অর্থ - কিন্তু হেই, এটি প্রক্রিয়াকরণের সময় কম মেমরি পদাঙ্ক পেয়েছে এবং বাস্তবায়ন করা খুব সহজ।]

তাই মূলত, দশমিক ফরম্যাটের সৌন্দর্য হল যে এটি একই সাথে স্ট্রিং চেহারাটি পরিচালনা করে - পাশাপাশি গোলাকার নির্ভুলতা সেটের স্তর। Ergo: আপনি এক কোড বাস্তবায়ন মূল্য জন্য দুটি সুবিধা পাবেন। ;)




আপনি যদি স্ট্রিং হিসাবে ফলাফল চান তবে আপনি কী ব্যবহার করতে পারেন সেটির একটি সারসংক্ষেপ এখানে দেওয়া হয়েছে:

  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. Apache কমন্স ম্যাথ থেকে যথার্থতা

    double rounded = Precision.round(0.912385, 5, BigDecimal.ROUND_HALF_UP);
  2. কল্ট থেকে Functions

    double rounded = Functions.round(0.00001).apply(0.912385)
  3. ওয়েকা থেকে ব্যবহার করে

    double rounded = Utils.roundDouble(0.912385, 5)






যেহেতু আমি এই থিমটিতে কোনও সম্পূর্ণ উত্তর পাইনি তাই আমি একসাথে এক ক্লাস স্থাপন করেছি যা এই সঠিকভাবে পরিচালনা করতে হবে, এর জন্য সমর্থন সহ:

  • বিন্যাসকরণ : সহজেই দশমিক স্থানগুলির একটি নির্দিষ্ট সংখ্যার সাথে স্ট্রিং করতে দ্বিগুণ ফর্ম্যাট করুন
  • পার্সিং : ফরম্যাটযুক্ত মানটিকে ডবলে ফেরত দিন
  • লোকেল : ডিফল্ট লোকেল ব্যবহার করে ফরম্যাট এবং পার্স
  • সূচকীয় নোটেশন : একটি নির্দিষ্ট থ্রেশহোল্ডের পরে সূচকীয় নোট ব্যবহার শুরু করুন

ব্যবহার খুবই সহজ :

(এই উদাহরণের জন্য আমি একটি কাস্টম লোকেল ব্যবহার করছি)

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), "");
    }

}



শুধু যদি কেউ এখনও এই সাহায্য প্রয়োজন। এই সমাধান আমার জন্য পুরোপুরি কাজ করে।

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

}

পছন্দসই আউটপুট সঙ্গে একটি String করে।




আমি এখানে এসেছিলাম কিভাবে একটি সংখ্যা বৃত্তাকার একটি সহজ উত্তর চাই। এটি যে একটি সম্পূরক উত্তর প্রদান করা হয়।

কিভাবে জাভা একটি সংখ্যা বৃত্তাকার

সবচেয়ে সাধারণ ক্ষেত্রে Math.round() ব্যবহার করা হয়।

Math.round(3.7) // 4

সংখ্যা নিকটতম সম্পূর্ণ সংখ্যা গোলাকার হয়। একটি .5 মান বৃত্তাকার আপ হয়। যদি আপনি তার থেকে ভিন্ন বৃত্তাকার আচরণ প্রয়োজন, তবে আপনি অন্য Math ফাংশনগুলির একটি ব্যবহার করতে পারেন। নীচের তুলনা দেখুন।

round

উপরে বর্ণিত হিসাবে, এই রাউন্ড নিকটতম সম্পূর্ণ সংখ্যা। .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

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 ***



আমি DecimalFormat --- বা বিকল্পভাবে BigDecimal ব্যবহার করার জন্য নির্বাচিত উত্তর দিয়ে একমত।

প্রথমে নীচের আপডেট পড়ুন দয়া করে!

তবে যদি আপনি double মানটি org.apache.commons.math3.util.Precision.round(..) এবং double মান ফলাফল পেতে চান তবে আপনি উপরে বর্ণিত org.apache.commons.math3.util.Precision.round(..) ব্যবহার করতে পারেন। বাস্তবায়ন BigDecimal ব্যবহার BigDecimal , ধীর এবং আবর্জনা সৃষ্টি করে।

DoubleRounder জ লাইব্রেরিতে 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

Disclaimer: আমি decimal4j প্রকল্প জড়িত করছি।

হালনাগাদ: @ ইওরফেক নির্দেশ করেছেন যে ডাবলআউন্ডার কখনও কখনও প্রতিক্রিয়াশীল ফলাফল প্রদান করে। কারণ এটি গাণিতিকভাবে সঠিক গোলাকার সঞ্চালন করে। উদাহরণস্বরূপ DoubleRounder.round(256.025d, 2) 256.02 পর্যন্ত বৃত্তাকার করা হবে কারণ 256.025 ডি হিসাবে প্রতিনিধিত্বকৃত দ্বিগুণ মানটি যুক্তিসঙ্গত মান 256.025 এর চেয়ে কিছুটা ছোট এবং এটিকে বৃত্তাকার করা হবে।

নোট:

  • এই আচরণটি BigDecimal(double) কন্সট্রাকটরটির সমান অনুরূপ (তবে valueOf(double) জন্য নয় valueOf(double) স্ট্রিং কন্সট্রাকটর ব্যবহার করে)।
  • সমস্যাটিকে প্রথমে উচ্চতর স্পষ্টতাতে ডাবল বৃত্তাকার ধাপে সঙ্কুচিত করা যেতে পারে, তবে এটি জটিল এবং আমি এখানে বিশদে যাচ্ছি না

এই পোস্টে উল্লিখিত কারণগুলির জন্য এবং উপরের সবকিছুর জন্য আমি DoubleRounder ব্যবহার করার সুপারিশ করতে পারি না




এটি অর্জন করতে আমরা এই ফর্ম্যাটটি ব্যবহার করতে পারি:

 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

ডেমো অনলাইন।




যেখানে আপনি চান ডিপি = দশমিক জায়গা, এবং মান একটি ডবল।

    double p = Math.pow(10d, dp);

    double result = Math.round(value * p)/p;



আপনি যদি এমন একটি প্রযুক্তি ব্যবহার করেন যা ন্যূনতম JDK থাকে। এখানে কোনো জাভা libs ছাড়া একটি উপায়:

double scale = 100000;    
double myVal = 0.912385;
double rounded = (int)((myVal * scale) + 0.5d) / scale;



Related