जावा में 1200 से 1.2 k के प्रारूपण के बारे में कैसे जाना जाता है

Question

मैं जावा के साथ उनके आगे के नंबरों में निम्नलिखित नंबरों को प्रारूपित करना चाहता हूं:

1000 to 1k
5821 to 5.8k
10500 to 10k
101800 to 101k
2000000 to 2m
7800000 to 7.8m
92150000 to 92m
123200000 to 123m

दाईं ओर की संख्या लंबी होगी या बाईं ओर की संख्या पूर्णांक स्ट्रिंग होगी। मुझे इससे कैसे संपर्क करना चाहिए। मैंने पहले से ही इसके लिए बहुत कम एल्गोरिदम किया था, लेकिन मुझे लगा कि वहां पहले से ही कुछ ऐसा हो सकता है, जो उस पर अच्छा काम करे और मुझे अरबों-खरबों से निपटने के लिए अतिरिक्त परीक्षण की आवश्यकता न पड़े :)

अतिरिक्त आवश्यकताएं:

• प्रारूप में अधिकतम 4 वर्ण होने चाहिए
• उपर्युक्त का अर्थ है 1.1k ठीक है 11.2k नहीं है। 7.8 मी के लिए भी यही ठीक है। 19.1 मी। दशमलव बिंदु से पहले केवल एक अंक को दशमलव बिंदु रखने की अनुमति है। दशमलव बिंदु से पहले दो अंक का मतलब दशमलव बिंदु के बाद अंक नहीं है।
• कोई गोलाई आवश्यक नहीं है। (संख्याओं को k और m के साथ प्रदर्शित किया जा रहा है, एनालॉग गेज के अधिक हैं जो अनुमान लगाते हैं कि तर्क का सटीक लेख नहीं है। इसलिए मुख्य रूप से चर की प्रकृति के कारण गोलाई अप्रासंगिक है और कैश्ड परिणाम को देखते हुए भी कई अंकों को घटा या बढ़ा सकता है।)

Comments

यदि किसी के पास पुस्तकालय नहीं है तो क्या आप अपना कोड पोस्ट करने का मन करेंगे?

— ग्राम 15

यह मदद कर सकता है, हालांकि यह एक डुबकी नहीं है। stackoverflow.com/questions/529432

— rfeak

@ मैं इससे पहले कि आप क्या समाधान का उपयोग कर रहे थे के रूप में उत्सुक था। यदि आपको कोई आपत्ति नहीं है तो आप इसे उत्तर के रूप में भी पोस्ट करेंगे।

— १

इसके पीछे क्या विचार है No rounding is necessaryयह मुझे बेतुका लगता है। क्या यह केवल चीजों को जटिल करना है? क्या यह बेहतर नहीं होगा कि इसे फिर से परिभाषित किया जाए Rounding is not necessary, but welcome?

— वुल्फ

मामले में आपने ध्यान नहीं दिया कि संख्याएँ k और m के साथ प्रदर्शित की जा रही हैं, एनालॉग गेज के अधिक हैं जो अनुमान लगाते हैं कि तर्क का सटीक लेख नहीं। इसलिए गोलाई मुख्य रूप से अप्रासंगिक है क्योंकि परिवर्तनीय की प्रकृति की वजह से नकदी अंकों के परिणाम को देखते हुए कई अंकों को बढ़ा या घटाया जा सकता है।

— Mat B.

Answer 1

यहां एक समाधान है जो किसी भी लंबे मूल्य के लिए काम करता है और मुझे काफी पठनीय लगता है (मूल तर्क formatविधि के निचले तीन हिस्सों में किया जाता है)।

यह TreeMapउपयुक्त प्रत्यय खोजने का लाभ उठाता है। यह आश्चर्यजनक रूप से पिछले समाधान की तुलना में अधिक कुशल है जो मैंने लिखा था कि सरणियों का उपयोग कर रहा था और पढ़ने में अधिक कठिन था।

private static final NavigableMap<Long, String> suffixes = new TreeMap<> ();
static {
  suffixes.put(1_000L, "k");
  suffixes.put(1_000_000L, "M");
  suffixes.put(1_000_000_000L, "G");
  suffixes.put(1_000_000_000_000L, "T");
  suffixes.put(1_000_000_000_000_000L, "P");
  suffixes.put(1_000_000_000_000_000_000L, "E");
}

public static String format(long value) {
  //Long.MIN_VALUE == -Long.MIN_VALUE so we need an adjustment here
  if (value == Long.MIN_VALUE) return format(Long.MIN_VALUE + 1);
  if (value < 0) return "-" + format(-value);
  if (value < 1000) return Long.toString(value); //deal with easy case

  Entry<Long, String> e = suffixes.floorEntry(value);
  Long divideBy = e.getKey();
  String suffix = e.getValue();

  long truncated = value / (divideBy / 10); //the number part of the output times 10
  boolean hasDecimal = truncated < 100 && (truncated / 10d) != (truncated / 10);
  return hasDecimal ? (truncated / 10d) + suffix : (truncated / 10) + suffix;
}

---

टेस्ट कोड

public static void main(String args[]) {
  long[] numbers = {0, 5, 999, 1_000, -5_821, 10_500, -101_800, 2_000_000, -7_800_000, 92_150_000, 123_200_000, 9_999_999, 999_999_999_999_999_999L, 1_230_000_000_000_000L, Long.MIN_VALUE, Long.MAX_VALUE};
  String[] expected = {"0", "5", "999", "1k", "-5.8k", "10k", "-101k", "2M", "-7.8M", "92M", "123M", "9.9M", "999P", "1.2P", "-9.2E", "9.2E"};
  for (int i = 0; i < numbers.length; i++) {
    long n = numbers[i];
    String formatted = format(n);
    System.out.println(n + " => " + formatted);
    if (!formatted.equals(expected[i])) throw new AssertionError("Expected: " + expected[i] + " but found: " + formatted);
  }
}

Comments

अच्छा समाधान। ऐसा लगता है कि आप वास्तव में बड़ी संख्या (क्वाड्रिलियन, क्विंटिलियन, आदि) के लिए अधिक प्रत्यय जोड़ सकते हैं, और आउटपुट पैमाने पर जारी है।

— साइरफ

आपका कोड नकारात्मक संख्याओं के साथ बिल्कुल सही नहीं है: -5821इसे स्वरूपित किया जाना चाहिए -5k, जैसा कि नहीं -5.8k।

— std.denis

@ std.denis ओपी ने संकेत नहीं दिया कि नकारात्मक संख्याओं को कैसे प्रारूपित किया जाए। मैंने उन्हें सकारात्मक संख्याओं की तरह प्रारूपित करने का निर्णय लिया लेकिन -समान अंकों के महत्वपूर्ण अंक रखने के लिए उपसर्ग किया । अन्य विकल्प हैं ...

— assylias

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

— maraca

लेकिन क्या पूरी दुनिया इस मानक को समझती है? अगर आप दुनिया में हर किसी के लिए ऐप बनाते हैं तो सावधान रहें। अंग्रेजी के लिए यह 10M है, लेकिन रूसी के लिए यह 10 млн है और इसी तरह

— user924

Answer 2

मुझे पता है, यह एक सी प्रोग्राम की तरह दिखता है, लेकिन यह सुपर लाइटवेट है!

public static void main(String args[]) {
    long[] numbers = new long[]{1000, 5821, 10500, 101800, 2000000, 7800000, 92150000, 123200000, 9999999};
    for(long n : numbers) {
        System.out.println(n + " => " + coolFormat(n, 0));
    }
}

private static char[] c = new char[]{'k', 'm', 'b', 't'};

/**
 * Recursive implementation, invokes itself for each factor of a thousand, increasing the class on each invokation.
 * @param n the number to format
 * @param iteration in fact this is the class from the array c
 * @return a String representing the number n formatted in a cool looking way.
 */
private static String coolFormat(double n, int iteration) {
    double d = ((long) n / 100) / 10.0;
    boolean isRound = (d * 10) %10 == 0;//true if the decimal part is equal to 0 (then it's trimmed anyway)
    return (d < 1000? //this determines the class, i.e. 'k', 'm' etc
        ((d > 99.9 || isRound || (!isRound && d > 9.99)? //this decides whether to trim the decimals
         (int) d * 10 / 10 : d + "" // (int) d * 10 / 10 drops the decimal
         ) + "" + c[iteration]) 
        : coolFormat(d, iteration+1));

}

यह आउटपुट:

1000 => 1k
5821 => 5.8k
10500 => 10k
101800 => 101k
2000000 => 2m
7800000 => 7.8m
92150000 => 92m
123200000 => 123m
9999999 => 9.9m

Comments

अस्पष्ट कोड। हमें आजकल इस तरह कोड नहीं करना है। उम्मीद के मुताबिक काम कर सकते हैं, लेकिन मैं लेखक को रोजर सी। मार्टिन

— एंड्रियास डॉक

Obfuscated? मैं आपसे क्षमा चाहता हूं, लेकिन आप शायद एक किताब पढ़ते हैं और सोचते हैं कि आप आजकल किसी भी तरह से कोड कर सकते हैं। उसके बारे में जोएल ( joelonsoftware.com/articles/ThePerilsofJavaSchools.html ) को बताएं । मैं किसी भी कोड की हिम्मत कर सकता हूं जो आप संभवतः मेरी पद्धति की गति के करीब पाने के लिए लिख सकते हैं!

— एलिजा सौनकिन

D, c, n चरों को कुछ अधिक पठनीय (तेज समझ) में बदलना इस कोड को मेरे विचार से सभ्य बनाता है

— Gennadiy Ryabkin

प्रदर्शन को लेकर यह जुनून क्यों? प्रदर्शन के बारे में सोचकर भी कोई भी पर्याप्त संख्या में इन रूपांतरणों को निष्पादित क्यों करना चाहेगा? पठनीयता पहले, यदि आवश्यक हो तो ही प्रदर्शन को आगे बढ़ाएं।

— एमोस कारपेंटर

मुझे @ AmosM.Carpenter से सहमत होना होगा। जब मैंने 4 साल पहले यह उत्तर लिखा था, तो मुझे कोड मेंटेनेंस के बारे में पता नहीं था। यह ऑप्टिमाइज़ करना बुरा नहीं है, आम तौर पर बोलना, लेकिन पहले पठनीयता आती है। वैसे, यह इतना बुरा प्रदर्शन-वार नहीं है: एक मार्का की तुलना में 5 गुना धीमा नहीं है - यह उसी के बारे में है (मैंने एक बेंचमार्क के लिए कुछ समाधान यहां डाल दिए हैं github.com/esaounkine/number-format- बेंचमार्क )।

— एलिजा सौनकिन

Answer 3

यहाँ एक समाधान है जो DecimalFormat के इंजीनियरिंग नोटेशन का उपयोग करता है:

public static void main(String args[]) {
    long[] numbers = new long[]{7, 12, 856, 1000, 5821, 10500, 101800, 2000000, 7800000, 92150000, 123200000, 9999999};
    for(long number : numbers) {
        System.out.println(number + " = " + format(number));
    }
}

private static String[] suffix = new String[]{"","k", "m", "b", "t"};
private static int MAX_LENGTH = 4;

private static String format(double number) {
    String r = new DecimalFormat("##0E0").format(number);
    r = r.replaceAll("E[0-9]", suffix[Character.getNumericValue(r.charAt(r.length() - 1)) / 3]);
    while(r.length() > MAX_LENGTH || r.matches("[0-9]+\\.[a-z]")){
        r = r.substring(0, r.length()-2) + r.substring(r.length() - 1);
    }
    return r;
}

आउटपुट:

7 = 7
12 = 12
856 = 856
1000 = 1k
5821 = 5.8k
10500 = 10k
101800 = 102k
2000000 = 2m
7800000 = 7.8m
92150000 = 92m
123200000 = 123m
9999999 = 10m

Comments

@ नई आवश्यकताओं को संभालने के लिए अपडेट

— jzd

क्या मुद्रा के साथ समान कार्यक्षमता प्राप्त करने के लिए मुद्रा इंस्टेंस के साथ इसे संयोजित करने का एक आसान तरीका है?

— xdumaine

@roviuser, निश्चित नहीं कि आपका क्या मतलब है, लेकिन यह एक अलग प्रश्न लगता है।

— jzd

राउंड 160000 से 200k और साथ ही राउंड 120000 डाउन टू 100k

— k1komans

यह टूट गया है, मैंने 10000000000000.0 नंबर दर्ज किया है और यह 103 कहता है।

— ओलिवर डिक्सन

Answer 4

कुछ सुधार की आवश्यकता है, लेकिन: बचाव के लिए स्ट्रिक्टमैथ!
आप प्रत्यय को स्ट्रिंग या एरे में रख सकते हैं और पावर के आधार पर, या ऐसा कुछ प्राप्त कर सकते हैं।
विभाजन को शक्ति के चारों ओर भी प्रबंधित किया जा सकता है, मुझे लगता है कि लगभग सब कुछ बिजली के मूल्य के बारे में है। आशा करता हूँ की ये काम करेगा!

public static String formatValue(double value) {
int power; 
    String suffix = " kmbt";
    String formattedNumber = "";

    NumberFormat formatter = new DecimalFormat("#,###.#");
    power = (int)StrictMath.log10(value);
    value = value/(Math.pow(10,(power/3)*3));
    formattedNumber=formatter.format(value);
    formattedNumber = formattedNumber + suffix.charAt(power/3);
    return formattedNumber.length()>4 ?  formattedNumber.replaceAll("\\.[0-9]+", "") : formattedNumber;  
}

आउटपुट:

999
1.2k
98k
911k
1.1m
11b
712b
34t

Comments

4 पठनीय मुद्दे को हल करने के लिए बेहतर पठनीयता को थोड़ा बढ़ा दिया गया, बस jzd से रिटर्न स्टेटमेंट जोड़ने की जरूरत थी। और याद रखें कि AIOOB अपवाद से बचने के लिए t पर जाने पर प्रत्यय जोड़ना। ;)

— झुरताडो 21:11

यह कोड लोकेल के प्रति संवेदनशील है, उदाहरण के लिए sv_SE लोकेल 1000 में 10x10 sensitive में कनवर्ट किया जाता है, जो रेगेक्स द्वारा सही ढंग से मिलान नहीं किया जाता है।

— जोकिम लुंडबोर्ग

0 के लिए एक अपवाद फेंकता है, नकारात्मक संख्याओं के लिए काम नहीं करता है, 9,999,999 को ठीक से गोल नहीं करता है (प्रिंट 10 एम) ...

— 8

Answer 5

करंट जवाब के साथ समस्या

• वर्तमान समाधानों में से कई इन उपसर्गों का उपयोग कर रहे हैं k = 10 ³ , m = 10 ⁶ , b = 10 ⁹ , t = 10 ¹² । हालांकि, विभिन्न स्रोतों के अनुसार , सही उपसर्ग k = 10 ³ , M = 10 ⁶ , G = 10 ⁹ , T = 10 ^{12 हैं}
• नकारात्मक संख्याओं के लिए समर्थन का अभाव (या कम से कम परीक्षणों का अभाव यह दर्शाता है कि नकारात्मक संख्याएँ समर्थित हैं)
• उलटा ऑपरेशन के लिए समर्थन का अभाव, उदाहरण के लिए 1.1k को 1100 में बदलना (हालांकि यह मूल प्रश्न के दायरे से बाहर है)

जावा सॉल्यूशन

यह समाधान ( इस उत्तर का विस्तार ) उपरोक्त मुद्दों को संबोधित करता है।

import org.apache.commons.lang.math.NumberUtils;

import java.text.DecimalFormat;
import java.text.FieldPosition;
import java.text.Format;
import java.text.ParsePosition;
import java.util.regex.Pattern;


/**
 * Converts a number to a string in <a href="http://en.wikipedia.org/wiki/Metric_prefix">metric prefix</a> format.
 * For example, 7800000 will be formatted as '7.8M'. Numbers under 1000 will be unchanged. Refer to the tests for further examples.
 */
class RoundedMetricPrefixFormat extends Format {

    private static final String[] METRIC_PREFIXES = new String[]{"", "k", "M", "G", "T"};

    /**
     * The maximum number of characters in the output, excluding the negative sign
     */
    private static final Integer MAX_LENGTH = 4;

    private static final Pattern TRAILING_DECIMAL_POINT = Pattern.compile("[0-9]+\\.[kMGT]");

    private static final Pattern METRIC_PREFIXED_NUMBER = Pattern.compile("\\-?[0-9]+(\\.[0-9])?[kMGT]");

    @Override
    public StringBuffer format(Object obj, StringBuffer output, FieldPosition pos) {

        Double number = Double.valueOf(obj.toString());

        // if the number is negative, convert it to a positive number and add the minus sign to the output at the end
        boolean isNegative = number < 0;
        number = Math.abs(number);

        String result = new DecimalFormat("##0E0").format(number);

        Integer index = Character.getNumericValue(result.charAt(result.length() - 1)) / 3;
        result = result.replaceAll("E[0-9]", METRIC_PREFIXES[index]);

        while (result.length() > MAX_LENGTH || TRAILING_DECIMAL_POINT.matcher(result).matches()) {
            int length = result.length();
            result = result.substring(0, length - 2) + result.substring(length - 1);
        }

        return output.append(isNegative ? "-" + result : result);
    }

    /**
     * Convert a String produced by <tt>format()</tt> back to a number. This will generally not restore
     * the original number because <tt>format()</tt> is a lossy operation, e.g.
     *
     * <pre>
     * {@code
     * def formatter = new RoundedMetricPrefixFormat()
     * Long number = 5821L
     * String formattedNumber = formatter.format(number)
     * assert formattedNumber == '5.8k'
     *
     * Long parsedNumber = formatter.parseObject(formattedNumber)
     * assert parsedNumber == 5800
     * assert parsedNumber != number
     * }
     * </pre>
     *
     * @param source a number that may have a metric prefix
     * @param pos if parsing succeeds, this should be updated to the index after the last parsed character
     * @return a Number if the the string is a number without a metric prefix, or a Long if it has a metric prefix
     */
    @Override
    public Object parseObject(String source, ParsePosition pos) {

        if (NumberUtils.isNumber(source)) {

            // if the value is a number (without a prefix) don't return it as a Long or we'll lose any decimals
            pos.setIndex(source.length());
            return toNumber(source);

        } else if (METRIC_PREFIXED_NUMBER.matcher(source).matches()) {

            boolean isNegative = source.charAt(0) == '-';
            int length = source.length();

            String number = isNegative ? source.substring(1, length - 1) : source.substring(0, length - 1);
            String metricPrefix = Character.toString(source.charAt(length - 1));

            Number absoluteNumber = toNumber(number);

            int index = 0;

            for (; index < METRIC_PREFIXES.length; index++) {
                if (METRIC_PREFIXES[index].equals(metricPrefix)) {
                    break;
                }
            }

            Integer exponent = 3 * index;
            Double factor = Math.pow(10, exponent);
            factor *= isNegative ? -1 : 1;

            pos.setIndex(source.length());
            Float result = absoluteNumber.floatValue() * factor.longValue();
            return result.longValue();
        }

        return null;
    }

    private static Number toNumber(String number) {
        return NumberUtils.createNumber(number);
    }
}

ग्रूवी समाधान

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

import org.apache.commons.lang.math.NumberUtils

import java.text.DecimalFormat
import java.text.FieldPosition
import java.text.Format
import java.text.ParsePosition
import java.util.regex.Pattern


/**
 * Converts a number to a string in <a href="http://en.wikipedia.org/wiki/Metric_prefix">metric prefix</a> format.
 * For example, 7800000 will be formatted as '7.8M'. Numbers under 1000 will be unchanged. Refer to the tests for further examples.
 */
class RoundedMetricPrefixFormat extends Format {

    private static final METRIC_PREFIXES = ["", "k", "M", "G", "T"]

    /**
     * The maximum number of characters in the output, excluding the negative sign
     */
    private static final Integer MAX_LENGTH = 4

    private static final Pattern TRAILING_DECIMAL_POINT = ~/[0-9]+\.[kMGT]/

    private static final Pattern METRIC_PREFIXED_NUMBER = ~/\-?[0-9]+(\.[0-9])?[kMGT]/

    @Override
    StringBuffer format(Object obj, StringBuffer output, FieldPosition pos) {

        Double number = obj as Double

        // if the number is negative, convert it to a positive number and add the minus sign to the output at the end
        boolean isNegative = number < 0
        number = Math.abs(number)

        String result = new DecimalFormat("##0E0").format(number)

        Integer index = Character.getNumericValue(result.charAt(result.size() - 1)) / 3
        result = result.replaceAll("E[0-9]", METRIC_PREFIXES[index])

        while (result.size() > MAX_LENGTH || TRAILING_DECIMAL_POINT.matcher(result).matches()) {
            int length = result.size()
            result = result.substring(0, length - 2) + result.substring(length - 1)
        }

        output << (isNegative ? "-$result" : result)
    }

    /**
     * Convert a String produced by <tt>format()</tt> back to a number. This will generally not restore
     * the original number because <tt>format()</tt> is a lossy operation, e.g.
     *
     * <pre>
     * {@code
     * def formatter = new RoundedMetricPrefixFormat()
     * Long number = 5821L
     * String formattedNumber = formatter.format(number)
     * assert formattedNumber == '5.8k'
     *
     * Long parsedNumber = formatter.parseObject(formattedNumber)
     * assert parsedNumber == 5800
     * assert parsedNumber != number
     * }
     * </pre>
     *
     * @param source a number that may have a metric prefix
     * @param pos if parsing succeeds, this should be updated to the index after the last parsed character
     * @return a Number if the the string is a number without a metric prefix, or a Long if it has a metric prefix
     */
    @Override
    Object parseObject(String source, ParsePosition pos) {

        if (source.isNumber()) {

            // if the value is a number (without a prefix) don't return it as a Long or we'll lose any decimals
            pos.index = source.size()
            toNumber(source)

        } else if (METRIC_PREFIXED_NUMBER.matcher(source).matches()) {

            boolean isNegative = source[0] == '-'

            String number = isNegative ? source[1..-2] : source[0..-2]
            String metricPrefix = source[-1]

            Number absoluteNumber = toNumber(number)

            Integer exponent = 3 * METRIC_PREFIXES.indexOf(metricPrefix)
            Long factor = 10 ** exponent
            factor *= isNegative ? -1 : 1

            pos.index = source.size()
            (absoluteNumber * factor) as Long
        }
    }

    private static Number toNumber(String number) {
        NumberUtils.createNumber(number)
    }
}

टेस्ट (ग्रूवी)

परीक्षण ग्रूवी में लिखे गए हैं, लेकिन या तो जावा या ग्रूवी वर्ग को सत्यापित करने के लिए उपयोग किया जा सकता है (क्योंकि वे दोनों एक ही नाम और एपीआई हैं)।

import java.text.Format
import java.text.ParseException

class RoundedMetricPrefixFormatTests extends GroovyTestCase {

    private Format roundedMetricPrefixFormat = new RoundedMetricPrefixFormat()

    void testNumberFormatting() {

        [
                7L         : '7',
                12L        : '12',
                856L       : '856',
                1000L      : '1k',
                (-1000L)   : '-1k',
                5821L      : '5.8k',
                10500L     : '10k',
                101800L    : '102k',
                2000000L   : '2M',
                7800000L   : '7.8M',
                (-7800000L): '-7.8M',
                92150000L  : '92M',
                123200000L : '123M',
                9999999L   : '10M',
                (-9999999L): '-10M'
        ].each { Long rawValue, String expectedRoundValue ->

            assertEquals expectedRoundValue, roundedMetricPrefixFormat.format(rawValue)
        }
    }

    void testStringParsingSuccess() {
        [
                '7'    : 7,
                '8.2'  : 8.2F,
                '856'  : 856,
                '-856' : -856,
                '1k'   : 1000,
                '5.8k' : 5800,
                '-5.8k': -5800,
                '10k'  : 10000,
                '102k' : 102000,
                '2M'   : 2000000,
                '7.8M' : 7800000L,
                '92M'  : 92000000L,
                '-92M' : -92000000L,
                '123M' : 123000000L,
                '10M'  : 10000000L

        ].each { String metricPrefixNumber, Number expectedValue ->

            def parsedNumber = roundedMetricPrefixFormat.parseObject(metricPrefixNumber)
            assertEquals expectedValue, parsedNumber
        }
    }

    void testStringParsingFail() {

        shouldFail(ParseException) {
            roundedMetricPrefixFormat.parseObject('notNumber')
        }
    }
}

Comments

मुझे लगता है कि आप सीएस उपसर्गों के बारे में सोच रहे हैं, यह देखते हुए कि वह अरबों और खरबों के बारे में बात कर रहा है, मुझे लगता है कि वह छोटे पैमाने के अंक चाहता है।

— झटराडो

9999999 को प्रिंट करना चाहिए जैसा कि मैं मानता हूं 9.9m (संख्याओं को छोटा किया जाता है, गोल नहीं)।

— assylias

इस समाधान में उन मानों के लिए उपसर्गों का समर्थन नहीं है, जो 1 से छोटे हैं, जैसे u (माइक्रो) और m (मिली)।

— gbmhunter

Answer 6

आईसीयू lib संख्या के लिए एक नियम आधारित फ़ॉर्मेटर है, जो संख्या spellout आदि मैं के लिए इस्तेमाल किया जा सकता का उपयोग कर लगता है कि आईसीयू आप एक पठनीय और maintanable समाधान देना होगा है।

[उपयोग]

सही वर्ग RuleBasedNumberFormat है। प्रारूप खुद को अलग फ़ाइल (या स्ट्रिंग स्थिर, IIRC) के रूप में संग्रहीत किया जा सकता है।

से उदाहरण http://userguide.icu-project.org/formatparse/numbers

double num = 2718.28;
NumberFormat formatter = 
    new RuleBasedNumberFormat(RuleBasedNumberFormat.SPELLOUT);
String result = formatter.format(num);
System.out.println(result);

एक ही पृष्ठ रोमन अंकों को दर्शाता है, इसलिए मुझे लगता है कि आपका मामला भी संभव होना चाहिए।

Comments

थ्रेड में एकमात्र समाधान जो पूरी तरह से अलग नहीं होता है यदि आपको स्थानीयकरण की आवश्यकता है।

— ग्रूज

यदि आपको Android विकास के लिए इसकी आवश्यकता है, तो यह पहले से ही फ्रेमवर्क में शामिल है। के लिए देखो CompactDecimalFormat। एपीआई स्तर 24+

— गोचन अरीक

Answer 7

साथ जावा 12 + , आप उपयोग कर सकते NumberFormat.getCompactNumberInstanceसंख्या फ़ॉर्मेट करने के लिए। आप NumberFormatपहले जैसा बना सकते हैं

NumberFormat fmt = NumberFormat.getCompactNumberInstance(Locale.US, NumberFormat.Style.SHORT);

और फिर इसका उपयोग करें format:

fmt.format(1000)
$5 ==> "1K"

fmt.format(10000000)
$9 ==> "10M"

fmt.format(1000000000)
$11 ==> "1B"

Answer 8

महत्वपूर्ण: उत्तर देने के लिए कास्टिंग की doubleतरह संख्या के लिए विफल हो जाएगा 99999999999999999Lऔर 100Pइसके बजाय वापस लौटा 99Pक्योंकि मानकdouble का उपयोग करता है :IEEE

यदि अधिकतम 15 महत्वपूर्ण अंकों वाला एक दशमलव स्ट्रिंग IEEE 754 डबल सटीक प्रतिनिधित्व में बदल जाता है और फिर समान संख्या में महत्वपूर्ण अंकों के साथ वापस स्ट्रिंग में परिवर्तित हो जाता है, तो अंतिम स्ट्रिंग मूल से मेल खाना चाहिए। [ longहै अप करने के लिए 19 महत्वपूर्ण अंक ।]

System.out.println((long)(double)99999999999999992L); // 100000000000000000
System.out.println((long)(double)99999999999999991L); //  99999999999999984
// it is even worse for the logarithm:
System.out.println(Math.log10(99999999999999600L)); // 17.0
System.out.println(Math.log10(99999999999999500L)); // 16.999999999999996

---

यह समाधान अवांछित अंकों को काट देता है और सभी longमूल्यों के लिए काम करता है । सरल लेकिन निष्पादन योग्य कार्यान्वयन (नीचे तुलना)। -120k को 4 वर्णों के साथ व्यक्त नहीं किया जा सकता है, यहां तक ​​कि -0.1M बहुत लंबा है, इसीलिए नकारात्मक संख्याओं के लिए 5 वर्णों को ठीक होना चाहिए:

private static final char[] magnitudes = {'k', 'M', 'G', 'T', 'P', 'E'}; // enough for long

public static final String convert(long number) {
    String ret;
    if (number >= 0) {
        ret = "";
    } else if (number <= -9200000000000000000L) {
        return "-9.2E";
    } else {
        ret = "-";
        number = -number;
    }
    if (number < 1000)
        return ret + number;
    for (int i = 0; ; i++) {
        if (number < 10000 && number % 1000 >= 100)
            return ret + (number / 1000) + '.' + ((number % 1000) / 100) + magnitudes[i];
        number /= 1000;
        if (number < 1000)
            return ret + number + magnitudes[i];
    }
}

else ifशुरुआत में परीक्षण आवश्यक है क्योंकि न्यूनतम है -(2^63)और अधिकतम है (2^63)-1और इसलिए असाइनमेंट number = -numberविफल हो जाएगा number == Long.MIN_VALUE। अगर हमें एक चेक करना है, तो हम सिर्फ चेक करने के बजाय अधिक से अधिक नंबर शामिल कर सकते हैं number == Long.MIN_VALUE।

इस कार्यान्वयन की तुलना उस व्यक्ति के साथ की जाती है जिसे सबसे अधिक अपवोट्स (वर्तमान में सबसे तेज़ कहा जाता है) से पता चला है कि यह 5 गुना से अधिक तेज़ी से है (यह परीक्षण सेटिंग्स पर निर्भर करता है, लेकिन अधिक संख्या के साथ लाभ बड़ा हो जाता है और इस कार्यान्वयन में है) अधिक जांच करना क्योंकि यह सभी मामलों को संभालता है, इसलिए यदि दूसरे को ठीक किया जाएगा तो अंतर और भी बड़ा हो जाएगा)। यह तेज़ है क्योंकि कोई फ़्लोटिंग पॉइंट ऑपरेशन नहीं हैं, कोई लघुगणक नहीं, कोई शक्ति नहीं है, कोई पुनरावृत्ति नहीं है, कोई रेगेक्स नहीं है, कोई परिष्कृत स्वरूपण नहीं है और बनाई गई वस्तुओं की मात्रा कम से कम है।

---

यहाँ परीक्षण कार्यक्रम है:

public class Test {

    public static void main(String[] args) {
        long[] numbers = new long[20000000];
        for (int i = 0; i < numbers.length; i++)
            numbers[i] = Math.random() < 0.5 ? (long) (Math.random() * Long.MAX_VALUE) : (long) (Math.random() * Long.MIN_VALUE);
        System.out.println(convert1(numbers) + " vs. " + convert2(numbers));
    }

    private static long convert1(long[] numbers) {
        long l = System.currentTimeMillis();
        for (int i = 0; i < numbers.length; i++)
            Converter1.convert(numbers[i]);
        return System.currentTimeMillis() - l;
    }

    private static long convert2(long[] numbers) {
        long l = System.currentTimeMillis();
        for (int i = 0; i < numbers.length; i++)
            Converter2.coolFormat(numbers[i], 0);
        return System.currentTimeMillis() - l;
    }

}

संभव उत्पादन: 2309 vs. 11591(उसी के बारे में जब केवल सकारात्मक संख्याओं का उपयोग करना और बहुत अधिक चरम जब निष्पादन के क्रम को उलटते हैं, शायद यह कचरा संग्रह के साथ कुछ करना है)

Answer 9

यहाँ पुनरावृत्ति के बिना एक संक्षिप्त कार्यान्वयन है और बस एक बहुत छोटा लूप है। नकारात्मक संख्याओं के साथ काम नहीं करता है लेकिन सभी सकारात्मक longs का समर्थन करता है Long.MAX_VALUE:

private static final char[] SUFFIXES = {'k', 'm', 'g', 't', 'p', 'e' };

public static String format(long number) {
    if(number < 1000) {
        // No need to format this
        return String.valueOf(number);
    }
    // Convert to a string
    final String string = String.valueOf(number);
    // The suffix we're using, 1-based
    final int magnitude = (string.length() - 1) / 3;
    // The number of digits we must show before the prefix
    final int digits = (string.length() - 1) % 3 + 1;

    // Build the string
    char[] value = new char[4];
    for(int i = 0; i < digits; i++) {
        value[i] = string.charAt(i);
    }
    int valueLength = digits;
    // Can and should we add a decimal point and an additional number?
    if(digits == 1 && string.charAt(1) != '0') {
        value[valueLength++] = '.';
        value[valueLength++] = string.charAt(1);
    }
    value[valueLength++] = SUFFIXES[magnitude - 1];
    return new String(value, 0, valueLength);
}

आउटपुट:

1k
5.8k
10k
101k
2m
7.8M
92m
123m
9.2e (यह है Long.MAX_VALUE)

मैंने कुछ बहुत ही साधारण बेंचमार्किंग भी की (10 मिलियन रैंडम लॉन्ग फॉर्मेटिंग) और यह एलियाह के कार्यान्वयन की तुलना में काफी तेज है और एसिलियास के कार्यान्वयन से थोड़ा तेज है।

मेरा: 1137.028 एमएस
एलिजा: 2664.396 एमएस
असाइलियास ': 1373.473 एमएस

Comments

अपने अंतिम अद्यतन में, आपने एक बग जोड़ा। यह अब 101k नंबर के लिए 1k देता है ।

— सूफियान

ध्यान देने के लिए धन्यवाद, यह तय है

— रंजीज़

Answer 10

किसी के लिए भी जो गोल करना चाहता है। यह एक शानदार, आसान समाधान है, जो Java.Lang.Math लाइब्रेरी का लाभ उठाता है

 public static String formatNumberExample(Number number) {
        char[] suffix = {' ', 'k', 'M', 'B', 'T', 'P', 'E'};
        long numValue = number.longValue();
        int value = (int) Math.floor(Math.log10(numValue));
        int base = value / 3;
        if (value >= 3 && base < suffix.length) {
            return new DecimalFormat("~#0.0").format(numValue / Math.pow(10, base * 3)) + suffix[base];
        } else {
            return new DecimalFormat("#,##0").format(numValue);
        }
    }

Answer 11

निम्नलिखित कोड दिखाता है कि आप इसे आसानी से ध्यान में रखकर कैसे कर सकते हैं।

"मैजिक" ज्यादातर makeDecimalफ़ंक्शन में निहित होता है, जिसमें पारित किए गए सही मानों के लिए, गारंटी देता है कि आपके पास आउटपुट में चार से अधिक वर्ण नहीं होंगे।

यह पहली बार किसी दिए गए भाजक के लिए पूरे और दसवें हिस्से को निकालता है, उदाहरण के लिए, 12,345,678एक भाजक के साथ 1,000,000एक wholeमान 12और के tenthsमूल्य देगा 3।

उस से, यह तय कर सकते हैं कि क्या यह नियमों का उपयोग करके पूरे भाग या पूरे और दसवें भाग दोनों को आउटपुट करता है:

• यदि दसवां भाग शून्य है, तो बस पूरे भाग और प्रत्यय का उत्पादन करें।
• यदि पूरा हिस्सा नौ से अधिक है, तो बस पूरे भाग और प्रत्यय का उत्पादन करें।
• अन्यथा, पूरे भाग, दसवें भाग और प्रत्यय का उत्पादन।

इसके लिए कोड निम्न है:

static private String makeDecimal(long val, long div, String sfx) {
    val = val / (div / 10);
    long whole = val / 10;
    long tenths = val % 10;
    if ((tenths == 0) || (whole >= 10))
        return String.format("%d%s", whole, sfx);
    return String.format("%d.%d%s", whole, tenths, sfx);
}

फिर, डेवलपर के लिए जीवन को आसान बनाने के लिए कुछ स्थिरांक सहित सही मानों के साथ उस सहायक फ़ंक्शन को कॉल करने का एक सरल मामला है:

static final long THOU =                1000L;
static final long MILL =             1000000L;
static final long BILL =          1000000000L;
static final long TRIL =       1000000000000L;
static final long QUAD =    1000000000000000L;
static final long QUIN = 1000000000000000000L;

static private String Xlat(long val) {
    if (val < THOU) return Long.toString(val);
    if (val < MILL) return makeDecimal(val, THOU, "k");
    if (val < BILL) return makeDecimal(val, MILL, "m");
    if (val < TRIL) return makeDecimal(val, BILL, "b");
    if (val < QUAD) return makeDecimal(val, TRIL, "t");
    if (val < QUIN) return makeDecimal(val, QUAD, "q");
    return makeDecimal(val, QUIN, "u");
}

तथ्य यह है कि makeDecimalफ़ंक्शन ग्रंट कार्य करता है इसका मतलब है कि परे विस्तार 999,999,999करना सिर्फ एक अतिरिक्त लाइन जोड़ने का मामला है Xlat, इतना आसान है कि मैंने इसे आपके लिए किया है।

फाइनल returnमें Xlatसशर्त की जरूरत नहीं होती है क्योंकि सबसे बड़े मूल्य जो आप 64-बिट हस्ताक्षरित लंबे समय तक रख सकते हैं, वह केवल 9.2 क्विंटल का है।

लेकिन अगर, कुछ विचित्र आवश्यकता से, ओरेकल 128-बिट longerप्रकार या 1024-बिट damn_longप्रकार जोड़ने का निर्णय लेता है , तो आप इसके लिए तैयार होंगे :-)

---

और, आखिरकार, कार्यक्षमता का सत्यापन करने के लिए आप एक छोटा सा परीक्षण हार्नेस का उपयोग कर सकते हैं।

public static void main(String[] args) {
    long vals[] = {
        999L, 1000L, 5821L, 10500L, 101800L, 2000000L,
        7800000L, 92150000L, 123200000L, 999999999L,
        1000000000L, 1100000000L, 999999999999L,
        1000000000000L, 999999999999999L,
        1000000000000000L, 9223372036854775807L
    };
    for (long val: vals)
        System.out.println ("" + val + " -> " + Xlat(val));
    }
}

आप आउटपुट से देख सकते हैं कि यह आपको वह देता है जो आपको चाहिए:

999 -> 999
1000 -> 1k
5821 -> 5.8k
10500 -> 10k
101800 -> 101k
2000000 -> 2m
7800000 -> 7.8m
92150000 -> 92m
123200000 -> 123m
999999999 -> 999m
1000000000 -> 1b
1100000000 -> 1.1b
999999999999 -> 999b
1000000000000 -> 1t
999999999999999 -> 999t
1000000000000000 -> 1q
9223372036854775807 -> 9.2u

---

और, एक तरफ के रूप में, अवगत रहें कि इस फ़ंक्शन के लिए एक नकारात्मक संख्या में गुजरने से आपकी आवश्यकताओं के लिए एक स्ट्रिंग बहुत लंबी हो जाएगी, क्योंकि यह < THOUपथ का अनुसरण करता है)। मुझे लगा कि आप प्रश्न में केवल गैर-नकारात्मक मूल्यों का उल्लेख करते हैं, ठीक था।

Answer 12

मुझे नहीं पता कि यह सबसे अच्छा तरीका है लेकिन, यह वही है जो मैंने किया था।

7=>7
12=>12
856=>856
1000=>1.0k
5821=>5.82k
10500=>10.5k
101800=>101.8k
2000000=>2.0m
7800000=>7.8m
92150000=>92.15m
123200000=>123.2m
9999999=>10.0m

--- कोड ---

public String Format(Integer number){
    String[] suffix = new String[]{"k","m","b","t"};
    int size = (number.intValue() != 0) ? (int) Math.log10(number) : 0;
    if (size >= 3){
        while (size % 3 != 0) {
            size = size - 1;
        }
    }
    double notation = Math.pow(10, size);
    String result = (size >= 3) ? + (Math.round((number / notation) * 100) / 100.0d)+suffix[(size/3) - 1] : + number + "";
    return result
}

Answer 13

बड़ी संख्या को छोटी संख्या (2 अंकों के साथ) में बदलने का मेरा कार्य। आप में परिवर्तन करके अंकों की संख्या को बदल सकते #.##हैंDecimalFormat

public String formatValue(float value) {
    String arr[] = {"", "K", "M", "B", "T", "P", "E"};
    int index = 0;
    while ((value / 1000) >= 1) {
        value = value / 1000;
        index++;
    }
    DecimalFormat decimalFormat = new DecimalFormat("#.##");
    return String.format("%s %s", decimalFormat.format(value), arr[index]);
}

परिक्षण

System.out.println(formatValue(100));     //  100
System.out.println(formatValue(1000));    // 1 K
System.out.println(formatValue(10345));   // 10.35 K
System.out.println(formatValue(10012));   // 10.01 K
System.out.println(formatValue(123456));  // 123.46 K
System.out.println(formatValue(4384324)); // 4.38 M
System.out.println(formatValue(10000000)); // 10 M
System.out.println(formatValue(Long.MAX_VALUE)); // 9.22 E

आशा है कि यह मदद करेगा

Answer 14

मेरा जावा जंग खा रहा है, लेकिन यहाँ मैं इसे C # में कैसे लागू करूँगा:

private string  FormatNumber(double value)
    {
    string[]  suffixes = new string[] {" k", " m", " b", " t", " q"};
    for (int j = suffixes.Length;  j > 0;  j--)
        {
        double  unit = Math.Pow(1000, j);
        if (value >= unit)
            return (value / unit).ToString("#,##0.0") + suffixes[--j];
        }
    return value.ToString("#,##0");
    }

मीट्रिक किलो के बजाय CS किलो (1,024) का उपयोग करने या अधिक इकाइयों को जोड़ने के लिए इसे समायोजित करना आसान होगा। यह "1 k" के बजाय 1,000 "1.0 k" के रूप में प्रारूपित करता है, लेकिन मुझे विश्वास है कि यह सारहीन है।

अधिक विशिष्ट आवश्यकता "चार वर्णों से अधिक नहीं" को पूरा करने के लिए, प्रत्ययों से पहले रिक्त स्थान को हटा दें और मध्य खंड को इस तरह समायोजित करें:

if (value >= unit)
  {
  value /= unit;
  return (value).ToString(value >= unit * 9.95 ? "#,##0" : "#,##0.0") + suffixes[--j];
  }

Comments

दुर्भाग्य से यह ToStringविधि जावा में मौजूद नहीं है - आपको एक नंबरफ़ॉर्मैट की आवश्यकता होगी जो अन्य मुद्दे (स्थानीय संवेदनशील आदि) बना सकती है।

— 7

Answer 15

मेरा मनपसंद। आप "के" और इतने पर दशमलव के लिए संकेतक के रूप में भी उपयोग कर सकते हैं, जैसे कि इलेक्ट्रॉनिक डोमेन में आम है। यह आपको अतिरिक्त स्थान के बिना एक अतिरिक्त अंक देगा

दूसरा कॉलम जितना संभव हो उतना अंकों का उपयोग करने की कोशिश करता है

1000 => 1.0k | 1000
5821 => 5.8k | 5821
10500 => 10k | 10k5
101800 => 101k | 101k
2000000 => 2.0m | 2m
7800000 => 7.8m | 7m8
92150000 => 92m | 92m1
123200000 => 123m | 123m
9999999 => 9.9m | 9m99

यह कोड है

public class HTTest {
private static String[] unit = {"u", "k", "m", "g", "t"};
/**
 * @param args
 */
public static void main(String[] args) {
    int[] numbers = new int[]{1000, 5821, 10500, 101800, 2000000, 7800000, 92150000, 123200000, 9999999};
    for(int n : numbers) {
        System.out.println(n + " => " + myFormat(n) + " | " + myFormat2(n));
    }
}

private static String myFormat(int pN) {
    String str = Integer.toString(pN);
    int len = str.length ()-1;
    if (len <= 3) return str;
    int level = len / 3;
    int mode = len % 3;
    switch (mode) {
    case 0: return str.substring(0, 1) + "." + str.substring(1, 2) + unit[level];
    case 1: return str.substring(0, 2) + unit[level];
    case 2: return str.substring(0, 3) + unit[level];
    }
    return "how that?";
}
private static String trim1 (String pVal) {
    if (pVal.equals("0")) return "";
    return pVal;
}
private static String trim2 (String pVal) {
    if (pVal.equals("00")) return "";
    return pVal.substring(0, 1) + trim1(pVal.substring(1,2));
}
private static String myFormat2(int pN) {
    String str = Integer.toString(pN);
    int len = str.length () - 1;
    if (len <= 3) return str;
    int level = len / 3;
    int mode = len % 3;
    switch (mode) {
    case 0: return str.substring(0, 1) + unit[level] + trim2(str.substring(1, 3));
    case 2: return str.substring(0, 3) + unit[level];
    case 1: return str.substring(0, 2) + unit[level] + trim1(str.substring(2, 3));
    }
    return "how that?";
}
}

Answer 16

मेरी टिप्पणी के लिए सच रहना कि मैं प्रदर्शन के ऊपर पठनीयता को महत्व दूंगा, यहां एक संस्करण है जहां यह स्पष्ट होना चाहिए कि क्या हो रहा है (यह मानकर कि आपने पहले इस्तेमाल किया है BigDecimal) अत्यधिक टिप्पणी किए बिना (मैं स्व-दस्तावेजीकरण कोड में विश्वास करता हूं), प्रदर्शन की चिंता किए बिना। (चूँकि मैं ऐसा परिदृश्य नहीं देख सकता जहाँ आप ऐसा लाखों बार करना चाहते हैं कि प्रदर्शन भी एक विचार बन जाए)।

यह संस्करण:

• BigDecimalसटीकता के लिए और गोलाई के मुद्दों से बचने के लिए उपयोग करता है
• ओपी के अनुरोध के अनुसार राउंडिंग के लिए काम करता है
• अन्य राउंडिंग मोड्स के लिए काम करता है, जैसे HALF_UPपरीक्षणों में
• आप सटीक (परिवर्तन REQUIRED_PRECISION) को समायोजित करने की अनुमति देता है
• enumथ्रेसहोल्ड को परिभाषित करने के लिए एक का उपयोग करता है, यानी के / एम / बी / टी, आदि के बजाय केबी / एमबी / जीबी / टीबी का उपयोग करने के लिए आसानी से समायोजित किया जा सकता है, और TRILLIONयदि आवश्यक हो तो निश्चित रूप से आगे बढ़ाया जा सकता है।
• पूरी तरह से यूनिट परीक्षणों के साथ आता है, क्योंकि प्रश्न में परीक्षण के मामले सीमाओं का परीक्षण नहीं कर रहे थे
• शून्य और ऋणात्मक संख्याओं के लिए काम करना चाहिए

थ्रेशोल्ड.जावा :

import java.math.BigDecimal;

public enum Threshold {
  TRILLION("1000000000000", 12, 't', null),
  BILLION("1000000000", 9, 'b', TRILLION),
  MILLION("1000000", 6, 'm', BILLION),
  THOUSAND("1000", 3, 'k', MILLION),
  ZERO("0", 0, null, THOUSAND);

  private BigDecimal value;
  private int zeroes;
  protected Character suffix;
  private Threshold higherThreshold;

  private Threshold(String aValueString, int aNumberOfZeroes, Character aSuffix,
      Threshold aThreshold) {
    value = new BigDecimal(aValueString);
    zeroes = aNumberOfZeroes;
    suffix = aSuffix;
    higherThreshold = aThreshold;
  }

  public static Threshold thresholdFor(long aValue) {
    return thresholdFor(new BigDecimal(aValue));
  }

  public static Threshold thresholdFor(BigDecimal aValue) {
    for (Threshold eachThreshold : Threshold.values()) {
      if (eachThreshold.value.compareTo(aValue) <= 0) {
        return eachThreshold;
      }
    }
    return TRILLION; // shouldn't be needed, but you might have to extend the enum
  }

  public int getNumberOfZeroes() {
    return zeroes;
  }

  public String getSuffix() {
    return suffix == null ? "" : "" + suffix;
  }

  public Threshold getHigherThreshold() {
    return higherThreshold;
  }
}

नंबरशास्त्री.जवा :

import java.math.BigDecimal;
import java.math.RoundingMode;

public class NumberShortener {

  public static final int REQUIRED_PRECISION = 2;

  public static BigDecimal toPrecisionWithoutLoss(BigDecimal aBigDecimal,
      int aPrecision, RoundingMode aMode) {
    int previousScale = aBigDecimal.scale();
    int previousPrecision = aBigDecimal.precision();
    int newPrecision = Math.max(previousPrecision - previousScale, aPrecision);
    return aBigDecimal.setScale(previousScale + newPrecision - previousPrecision,
        aMode);
  }

  private static BigDecimal scaledNumber(BigDecimal aNumber, RoundingMode aMode) {
    Threshold threshold = Threshold.thresholdFor(aNumber);
    BigDecimal adjustedNumber = aNumber.movePointLeft(threshold.getNumberOfZeroes());
    BigDecimal scaledNumber = toPrecisionWithoutLoss(adjustedNumber, REQUIRED_PRECISION,
        aMode).stripTrailingZeros();
    // System.out.println("Number: <" + aNumber + ">, adjusted: <" + adjustedNumber
    // + ">, rounded: <" + scaledNumber + ">");
    return scaledNumber;
  }

  public static String shortenedNumber(long aNumber, RoundingMode aMode) {
    boolean isNegative = aNumber < 0;
    BigDecimal numberAsBigDecimal = new BigDecimal(isNegative ? -aNumber : aNumber);
    Threshold threshold = Threshold.thresholdFor(numberAsBigDecimal);
    BigDecimal scaledNumber = aNumber == 0 ? numberAsBigDecimal : scaledNumber(
        numberAsBigDecimal, aMode);
    if (scaledNumber.compareTo(new BigDecimal("1000")) >= 0) {
      scaledNumber = scaledNumber(scaledNumber, aMode);
      threshold = threshold.getHigherThreshold();
    }
    String sign = isNegative ? "-" : "";
    String printNumber = sign + scaledNumber.stripTrailingZeros().toPlainString()
        + threshold.getSuffix();
    // System.out.println("Number: <" + sign + numberAsBigDecimal + ">, rounded: <"
    // + sign + scaledNumber + ">, print: <" + printNumber + ">");
    return printNumber;
  }
}

( printlnयह क्या कर रहा है यह देखने के लिए अपने पसंदीदा लकड़हारे का उपयोग करने के लिए बयानों को बदल दें या बदल दें।)

और अंत में, नंबरशॉर्टनरटेस्ट में परीक्षण (सादे JUnit 4):

import static org.junit.Assert.*;

import java.math.BigDecimal;
import java.math.RoundingMode;

import org.junit.Test;

public class NumberShortenerTest {

  private static final long[] NUMBERS_FROM_OP = new long[] { 1000, 5821, 10500, 101800, 2000000, 7800000, 92150000, 123200000 };
  private static final String[] EXPECTED_FROM_OP = new String[] { "1k", "5.8k", "10k", "101k", "2m", "7.8m", "92m", "123m" };
  private static final String[] EXPECTED_FROM_OP_HALF_UP = new String[] { "1k", "5.8k", "11k", "102k", "2m", "7.8m", "92m", "123m" };
  private static final long[] NUMBERS_TO_TEST = new long[] { 1, 500, 999, 1000, 1001, 1009, 1049, 1050, 1099, 1100, 12345, 123456, 999999, 1000000,
      1000099, 1000999, 1009999, 1099999, 1100000, 1234567, 999999999, 1000000000, 9123456789L, 123456789123L };
  private static final String[] EXPECTED_FROM_TEST = new String[] { "1", "500", "999", "1k", "1k", "1k", "1k", "1k", "1k", "1.1k", "12k", "123k",
      "999k", "1m", "1m", "1m", "1m", "1m", "1.1m", "1.2m", "999m", "1b", "9.1b", "123b" };
  private static final String[] EXPECTED_FROM_TEST_HALF_UP = new String[] { "1", "500", "999", "1k", "1k", "1k", "1k", "1.1k", "1.1k", "1.1k", "12k",
      "123k", "1m", "1m", "1m", "1m", "1m", "1.1m", "1.1m", "1.2m", "1b", "1b", "9.1b", "123b" };

  @Test
  public void testThresholdFor() {
    assertEquals(Threshold.ZERO, Threshold.thresholdFor(1));
    assertEquals(Threshold.ZERO, Threshold.thresholdFor(999));
    assertEquals(Threshold.THOUSAND, Threshold.thresholdFor(1000));
    assertEquals(Threshold.THOUSAND, Threshold.thresholdFor(1234));
    assertEquals(Threshold.THOUSAND, Threshold.thresholdFor(9999));
    assertEquals(Threshold.THOUSAND, Threshold.thresholdFor(999999));
    assertEquals(Threshold.MILLION, Threshold.thresholdFor(1000000));
  }

  @Test
  public void testToPrecision() {
    RoundingMode mode = RoundingMode.DOWN;
    assertEquals(new BigDecimal("1"), NumberShortener.toPrecisionWithoutLoss(new BigDecimal("1.23456"), 1, mode));
    assertEquals(new BigDecimal("1.2"), NumberShortener.toPrecisionWithoutLoss(new BigDecimal("1.23456"), 2, mode));
    assertEquals(new BigDecimal("1.23"), NumberShortener.toPrecisionWithoutLoss(new BigDecimal("1.23456"), 3, mode));
    assertEquals(new BigDecimal("1.234"), NumberShortener.toPrecisionWithoutLoss(new BigDecimal("1.23456"), 4, mode));
    assertEquals(new BigDecimal("999").toPlainString(), NumberShortener.toPrecisionWithoutLoss(new BigDecimal("999"), 4, mode).stripTrailingZeros()
        .toPlainString());
    assertEquals(new BigDecimal("999").toPlainString(), NumberShortener.toPrecisionWithoutLoss(new BigDecimal("999"), 2, mode).stripTrailingZeros()
        .toPlainString());
    assertEquals(new BigDecimal("999").toPlainString(), NumberShortener.toPrecisionWithoutLoss(new BigDecimal("999.9"), 2, mode).stripTrailingZeros()
        .toPlainString());

    mode = RoundingMode.HALF_UP;
    assertEquals(new BigDecimal("1"), NumberShortener.toPrecisionWithoutLoss(new BigDecimal("1.23456"), 1, mode));
    assertEquals(new BigDecimal("1.2"), NumberShortener.toPrecisionWithoutLoss(new BigDecimal("1.23456"), 2, mode));
    assertEquals(new BigDecimal("1.23"), NumberShortener.toPrecisionWithoutLoss(new BigDecimal("1.23456"), 3, mode));
    assertEquals(new BigDecimal("1.235"), NumberShortener.toPrecisionWithoutLoss(new BigDecimal("1.23456"), 4, mode));
    assertEquals(new BigDecimal("999").toPlainString(), NumberShortener.toPrecisionWithoutLoss(new BigDecimal("999"), 4, mode).stripTrailingZeros()
        .toPlainString());
    assertEquals(new BigDecimal("999").toPlainString(), NumberShortener.toPrecisionWithoutLoss(new BigDecimal("999"), 2, mode).stripTrailingZeros()
        .toPlainString());
    assertEquals(new BigDecimal("1000").toPlainString(), NumberShortener.toPrecisionWithoutLoss(new BigDecimal("999.9"), 2, mode)
        .stripTrailingZeros().toPlainString());
  }

  @Test
  public void testNumbersFromOP() {
    for (int i = 0; i < NUMBERS_FROM_OP.length; i++) {
      assertEquals("Index " + i + ": " + NUMBERS_FROM_OP[i], EXPECTED_FROM_OP[i],
          NumberShortener.shortenedNumber(NUMBERS_FROM_OP[i], RoundingMode.DOWN));
      assertEquals("Index " + i + ": " + NUMBERS_FROM_OP[i], EXPECTED_FROM_OP_HALF_UP[i],
          NumberShortener.shortenedNumber(NUMBERS_FROM_OP[i], RoundingMode.HALF_UP));
    }
  }

  @Test
  public void testBorders() {
    assertEquals("Zero: " + 0, "0", NumberShortener.shortenedNumber(0, RoundingMode.DOWN));
    assertEquals("Zero: " + 0, "0", NumberShortener.shortenedNumber(0, RoundingMode.HALF_UP));
    for (int i = 0; i < NUMBERS_TO_TEST.length; i++) {
      assertEquals("Index " + i + ": " + NUMBERS_TO_TEST[i], EXPECTED_FROM_TEST[i],
          NumberShortener.shortenedNumber(NUMBERS_TO_TEST[i], RoundingMode.DOWN));
      assertEquals("Index " + i + ": " + NUMBERS_TO_TEST[i], EXPECTED_FROM_TEST_HALF_UP[i],
          NumberShortener.shortenedNumber(NUMBERS_TO_TEST[i], RoundingMode.HALF_UP));
    }
  }

  @Test
  public void testNegativeBorders() {
    for (int i = 0; i < NUMBERS_TO_TEST.length; i++) {
      assertEquals("Index " + i + ": -" + NUMBERS_TO_TEST[i], "-" + EXPECTED_FROM_TEST[i],
          NumberShortener.shortenedNumber(-NUMBERS_TO_TEST[i], RoundingMode.DOWN));
      assertEquals("Index " + i + ": -" + NUMBERS_TO_TEST[i], "-" + EXPECTED_FROM_TEST_HALF_UP[i],
          NumberShortener.shortenedNumber(-NUMBERS_TO_TEST[i], RoundingMode.HALF_UP));
    }
  }
}

अगर मैं एक महत्वपूर्ण परीक्षण मामले में चूक गया या अपेक्षित मूल्यों को समायोजित किया जाना चाहिए, तो टिप्पणियों में इंगित करने के लिए स्वतंत्र महसूस करें।

Comments

आपके समाधान में केवल स्पष्ट नकारात्मक पहलू आपके कोड के लिए V + H-स्क्रॉलबार लगता है, यह पठनीयता को कम करता है। क्या आपको लगता है कि स्पष्टता खोए बिना एक पुन: सुधार संभव होगा?

— वुल्फ

@Wolf: मेरी आईडीई से कॉपी / पेस्ट करने की उम्मीद कर रहा था, लेकिन आप सही हैं, यह पठनीयता का दावा करने और क्षैतिज स्क्रॉलिंग की आवश्यकता के लिए मेरे लिए पाखंडी है, इसलिए इसे इंगित करने के लिए धन्यवाद। ;-) मैंने कोड के पहले दो बिट्स को अपडेट कर दिया है, क्योंकि वे वही हैं जो आप देखना चाहते हैं कि क्या हो रहा है, लेकिन परीक्षण कोड को छोड़ दिया, क्योंकि यह अपने आप में देखना इतना उपयोगी नहीं है - आप ' d शायद इकाई परीक्षणों को चलाने के लिए अपने खुद के IDE में चिपकाना चाहते हैं यदि आप देखना चाहते हैं कि परीक्षण काम करते हैं। आशा है कि यह ठीक है।

— एमोस कारपेंटर

आह अच्छा। लेकिन आखिरी बॉक्स में, परीक्षण के मामले, अपेक्षित परिणाम हो सकते हैं - वैकल्पिक रूप से - इनपुट से संबंधित (मेरा मतलब है कि पहले 6 सरणियों में शाब्दिक अर्थ)।

— वुल्फ

@Wolf: मैं रिक्त स्थान या टैब के साथ एक पंक्ति में आइटम संरेखित करने की कोशिश का प्रशंसक नहीं हूं - जिसे आसानी से मेरे पसंदीदा फ़ॉर्मेटर (ग्रहण) में सभी मामलों के लिए लगातार कॉन्फ़िगर नहीं किया जा सकता है, और इसे मैन्युअल रूप से कर रहा है ... इस तरह से पागलपन निहित है , क्योंकि सभी समायोजन के लिए आपको हर बार जब आप किसी आइटम को जोड़ते हैं या निकालते हैं। अगर मैं वास्तव में उन्हें संरेखित देखना चाहता था, तो मैं सीएसवी के रूप में एक स्प्रेडशीट में संख्याओं / मूल्यों को चिपकाऊंगा।

— एमोस कारपेंटर

सभी इस बात पर निर्भर करते हैं कि आप आखिर क्या हैं, @assylias। यदि आप एक बार उपयोग के मामले को हल करने के बाद हैं, तो आपका समाधान ठीक काम करना चाहिए; मुझे TreeMapअप्रोच पसंद है । "पठनीयता" व्यक्तिपरक है, निश्चित रूप से। ;-) अब क्या होगा अगर कोई आपके संस्करण में छंटनी की तुलना में अलग तरीके से गोल करना चाहता है? (उदाहरण के लिए, जब फ़ाइल आकार को इंगित करने के लिए इसका उपयोग करते हैं, तो कौन अलग करना चाहेगा?) यदि आप 10 के बजाय 2 की शक्ति चाहते हैं? तुम एक निष्पक्ष बिट को फिर से लिखना होगा, क्या तुम नहीं? जैसा कि मैंने कहा, मैं जानबूझकर अपने कोड को गोल करने की कोशिश नहीं कर रहा था, जिनमें से बहुत को छोटा किया जा सकता था (उदाहरण के लिए, मैं एक लाइन पर कभी भी नहीं रखूंगा)।

— अमोस एम। बढ़ई

Answer 17

यह मेरा कोड है। साफ और सरल।

public static String getRoughNumber(long value) {
    if (value <= 999) {
        return String.valueOf(value);
    }

    final String[] units = new String[]{"", "K", "M", "B", "P"};
    int digitGroups = (int) (Math.log10(value) / Math.log10(1000));
    return new DecimalFormat("#,##0.#").format(value / Math.pow(1000, digitGroups)) + "" + units[digitGroups];

}

Answer 18

अपने स्वयं के उत्तर, जावा कोड, स्वयं व्याख्यात्मक कोड जोड़ना ।।

import java.math.BigDecimal;

/**
 * Method to convert number to formatted number.
 * 
 * @author Gautham PJ
 */
public class ShortFormatNumbers
{

    /**
     * Main method. Execution starts here.
     */
    public static void main(String[] args)
    {

        // The numbers that are being converted.
        int[] numbers = {999, 1400, 2500, 45673463, 983456, 234234567};


        // Call the "formatNumber" method on individual numbers to format 
        // the number.
        for(int number : numbers)
        {
            System.out.println(number + ": " + formatNumber(number));
        }

    }


    /**
     * Format the number to display it in short format.
     * 
     * The number is divided by 1000 to find which denomination to be added 
     * to the number. Dividing the number will give the smallest possible 
     * value with the denomination.
     * 
     * @param the number that needs to be converted to short hand notation.
     * @return the converted short hand notation for the number.
     */
    private static String formatNumber(double number)
    {
        String[] denominations = {"", "k", "m", "b", "t"};
        int denominationIndex = 0;

        // If number is greater than 1000, divide the number by 1000 and 
        // increment the index for the denomination.
        while(number > 1000.0)
        {
            denominationIndex++;
            number = number / 1000.0;
        }

        // To round it to 2 digits.
        BigDecimal bigDecimal = new BigDecimal(number);
        bigDecimal = bigDecimal.setScale(2, BigDecimal.ROUND_HALF_EVEN);


        // Add the number with the denomination to get the final value.
        String formattedNumber = bigDecimal + denominations[denominationIndex];
        return formattedNumber;
    }

}

Answer 19

यह कोड केवल घातक सरल और साफ कोड को स्निपेट करता है, और पूरी तरह से काम करता है:

private static char[] c = new char[]{'K', 'M', 'B', 'T'};
private String formatK(double n, int iteration) {
    if (n < 1000) {
        // print 999 or 999K
        if (iteration <= 0) {
            return String.valueOf((long) n);
        } else {
            return String.format("%d%s", Math.round(n), c[iteration-1]);
        }
    } else if (n < 10000) {
        // Print 9.9K
        return String.format("%.1f%s", n/1000, c[iteration]);
    } else {
        // Increase 1 iteration
        return formatK(Math.round(n/1000), iteration+1);
    }
}

Answer 20

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

public String Format(Integer number){
    String[] suffix = new String[]{"k","m","b","t"};
    int size = (number.intValue() != 0) ? (int) Math.log10(number) : 0;
    if (size >= 3){
        while (size % 3 != 0) {
            size = size - 1;
        }
    }
    double notation = Math.pow(10, size);
    String result = (size >= 3) ? + (Math.round((number / notation) * 100) / 100.0d)+suffix[(size/3) - 1] : + number + "";
    return result
}

Answer 21

public class NumberToReadableWordFormat {

    public static void main(String[] args) {
        Integer[] numbers = new Integer[]{1000, 5821, 10500, 101800, 2000000, 7800000, 92150000, 123200000, 9999999,999};
        for(int n : numbers) {
            System.out.println(n + " => " + coolFormat(n));
        }
    }

    private static String[] c = new String[]{"K", "L", "Cr"};
    private static String coolFormat(int n) {
        int size = String.valueOf(n).length();
        if (size>=4 && size<6) {
                int value = (int) Math.pow(10, 1);
                double d = (double) Math.round(n/1000.0 * value) / value;
                return (double) Math.round(n/1000.0 * value) / value+" "+c[0];
        } else if(size>5 && size<8) {
                int value = (int) Math.pow(10, 1);
                return (double) Math.round(n/100000.0 * value) / value+" "+c[1];
        } else if(size>=8) {
                int value = (int) Math.pow(10, 1);
                return (double) Math.round(n/10000000.0 * value) / value+" "+c[2];
        } else {
            return n+"";
        }
    }
}

आउटपुट:

1000 => 1.0 K

5821 => 5.8 K

10500 => 10.5 K

101800 => 1.0 L

2000000 => 20.0 L

7800000 => 78.0 L

92150000 => 9.2 Cr

123200000 => 12.3 Cr

9999999 => 100.0 L

999 => 999

Answer 22

//code longer but work sure...

public static String formatK(int number) {
    if (number < 999) {
        return String.valueOf(number);
    }

    if (number < 9999) {
        String strNumber = String.valueOf(number);
        String str1 = strNumber.substring(0, 1);
        String str2 = strNumber.substring(1, 2);
        if (str2.equals("0")) {
            return str1 + "k";
        } else {
            return str1 + "." + str2 + "k";
        }
    }

    if (number < 99999) {
        String strNumber = String.valueOf(number);
        String str1 = strNumber.substring(0, 2);
        return str1 + "k";
    }

    if (number < 999999) {
        String strNumber = String.valueOf(number);
        String str1 = strNumber.substring(0, 3);
        return str1 + "k";
    }

    if (number < 9999999) {
        String strNumber = String.valueOf(number);
        String str1 = strNumber.substring(0, 1);
        String str2 = strNumber.substring(1, 2);
        if (str2.equals("0")) {
            return str1 + "m";
        } else {
            return str1 + "." + str2 + "m";
        }
    }

    if (number < 99999999) {
        String strNumber = String.valueOf(number);
        String str1 = strNumber.substring(0, 2);
        return str1 + "m";
    }

    if (number < 999999999) {
        String strNumber = String.valueOf(number);
        String str1 = strNumber.substring(0, 3);
        return str1 + "m";
    }

    NumberFormat formatterHasDigi = new DecimalFormat("###,###,###");
    return formatterHasDigi.format(number);
}

Comments

यह आपके सभी किनारे के मामलों के लिए काम नहीं करता है। उदाहरण के लिए 999 का प्रयास करें।

— jzd