Java 实现数字到字符串程序的另一种有效方法是什么

考虑到约束条件

1，我已经编写了一个将数字转换为单词的代码，如图所示，
Java
中没有任何方法可以为您这样做

您可以做的是尝试创建一个方法，为数字生成字符串

因此，此方法将具有表示每个数字所需的所有字符串：

zero - nine, ten, twenty, thirty , hundred, thousand, [m-b-tr-quad..]illion 
eleven, twelve, thirteen and negative

14 - 19 => [4-9] + teen
30 - 90 => [3-9] + ty
10^6 - 10^3n => [m for 10^6, b for 10^9] + illion

您必须删除重叠的
t
s

即
是
80
而不是
8

我刚刚创建了一个适用于
-100000000
的程序。
很抱歉耽搁了，但我想确保它工作正常

代码
import java.util.HashMap；
导入java.util.Iterator；
导入java.util.Map.Entry；
导入java.util.regex.Matcher；
导入java.util.regex.Pattern；
公共类编号转换{
公共静态最终int MAX_NUMBER=99999999；//高达近10亿
公共静态最终哈希图编号；
公共静态最终HashMap模式；
公共静态最终字符串负=“负”；
公共静态最终字符串ZERO=“ZERO”；
静止的{
数字=新的HashMap（）；
数字。将（0，“）；
数字。放入（1，“一”）；
数字。放入（2，“2”）；
数字。放入（3，“三”）；
数字。放入（4，“4”）；
数字。放入（5，“5”）；
数字。放入（6，“6”）；
数字。放入（7，“7”）；
数字。放入（8，“8”）；
数字。放入（9，“9”）；
数字。放入（10，“10”）；
数字。放入（11，“11”）；
数字。放入（12，“12”）；
（13，“十三”）；
数字。放（15，“15”）；
patterns=newhashmap（）；
“1[4-9]，“[]青少年”）；
模式。把（“2”，“20”）；
模式。把（“3.”，“30”）；
模式。put（“[4-9]。”，“[]ty”）；
模式。投入（“[1-9]……”，“[]百”）；
模式。put（“[0-9]{1,3}…”，“[]千”）；
模式。投入（“[0-9]{1,3}……”，“[]百万”）；
}
公共静态字符串getValue（整数）{
返回编号！=0？getValue（String.valueOf（number））：“零”；
}
公共静态字符串getValue（字符串编号）{
//验证
int parsed=Integer.parseInt（数字）；
如果（已解析>最大值）{
抛出新的IllegalArgumentException（“数字：“+number+””太大，无法转换。”）；
}
if（解析<0）{
返回负值+getValue（number.substring（1））；
}
//如果数字映射中存在该数字，请按原样返回。
if（number.containsKey（已解析））{
返回数字。获取（解析）；
}
StringBuilder结果=新建StringBuilder（）；//返回的字符串
迭代器迭代器=patterns.entrySet（）.Iterator（）；
while（iterator.hasNext（））{
String key=iterator.next（）.getKey（）；
Pattern=Pattern.compile（键）；
匹配器匹配器=模式匹配器（编号）；
if（matcher.matches（））{
int index=key.indexOf（'.'）；
字符串温度；
如果（索引18，第八个->第八十个
返回result.toString（）.replace（“tt”，“t”）；
}
公共静态void main（字符串[]args）{
System.out.println（getValue（312321））；
}
}

如果您想添加
模式。put（“[0-9]{1,3}………”，“[]十亿”）；
您必须将每个
int
更改为
long
，如图所示，
Java
中没有为您执行此操作的方法

您可以做的是尝试创建一个方法，为数字生成字符串

因此，此方法将具有表示每个数字所需的所有字符串：

zero - nine, ten, twenty, thirty , hundred, thousand, [m-b-tr-quad..]illion 
eleven, twelve, thirteen and negative

14 - 19 => [4-9] + teen
30 - 90 => [3-9] + ty
10^6 - 10^3n => [m for 10^6, b for 10^9] + illion

您必须删除重叠的
t
s

即
是
80
而不是
8

我刚刚创建了一个适用于
-100000000
的程序。
很抱歉耽搁了，但我想确保它工作正常

代码
import java.util.HashMap；
导入java.util.Iterator；
导入java.util.Map.Entry；
导入java.util.regex.Matcher；
导入java.util.regex.Pattern；
公共类编号转换{
公共静态最终int MAX_NUMBER=99999999；//高达近10亿
公共静态最终哈希图编号；
公共静态最终HashMap模式；
公共静态最终字符串负=“负”；
公共静态最终字符串ZERO=“ZERO”；
静止的{
数字=新的HashMap（）；
数字。将（0，“）；
数字。放入（1，“一”）；
数字。放入（2，“2”）；
数字。放入（3，“三”）；
数字。放入（4，“4”）；
数字。放入（5，“5”）；
数字。放入（6，“6”）；
数字。放入（7，“7”）；
数字。放入（8，“8”）；
数字。放入（9，“9”）；
数字。放入（10，“10”）；
数字。放入（11，“11”）；
数字。放入（12，“12”）；
（13，“十三”）；
数字。放（15，“15”）；
patterns=newhashmap（）；
“1[4-9]，“[]青少年”）；
模式。把（“2”，“20”）；
模式。把（“3.”，“30”）；
模式。put（“[4-9]。”，“[]ty”）；
模式。投入（“[1-9]……”，“[]百”）；
模式。put（“[0-9]{1,3}…”，“[]千”）；
模式。投入（“[0-9]{1,3}……”，“[]百万”）；
}
公共静态字符串getValue（整数）{
返回编号！=0？getValue（String.valueOf（number））：“零”；
}
公共静态字符串getValue（字符串编号）{
//验证
int parsed=Integer.parseInt（数字）；
如果（已解析>最大值）{
抛出新的IllegalArgumentException（“数字：“+number+””太大，无法转换。”）；
}
如果（PAR）
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class NumberConversion {
    public static final int MAX_NUMBER = 999999999;// up to almost 1 billion
    public static final HashMap<Integer, String> numbers;
    public static final HashMap<String, String> patterns;
    public static final String NEGATIVE = "Minus ";
    public static final String ZERO = "Zero";

    static {
        numbers = new HashMap<Integer, String>();
        numbers.put(0, "");
        numbers.put(1, "One");
        numbers.put(2, "Two");
        numbers.put(3, "Three");
        numbers.put(4, "Four");
        numbers.put(5, "Five");
        numbers.put(6, "Six");
        numbers.put(7, "Seven");
        numbers.put(8, "Eight");
        numbers.put(9, "Nine");
        numbers.put(10, "Ten");
        numbers.put(11, "Eleven");
        numbers.put(12, "Twelve");
        numbers.put(13, "Thirteen");
        numbers.put(15, "Fifteen");
        patterns = new HashMap<String, String>();
        patterns.put("1[4-9]", "[]teen ");
        patterns.put("2.", "Twenty ");
        patterns.put("3.", "Thirty ");
        patterns.put("[4-9].", "[]ty ");
        patterns.put("[1-9]..", "[] Hundred ");
        patterns.put("[0-9]{1,3}...", "[] Thousand ");
        patterns.put("[0-9]{1,3}......", "[] Million ");
    }

    public static String getValue(int number) {
        return number != 0 ? getValue(String.valueOf(number)) : "Zero";
    }

    public static String getValue(String number) {
        // Validation
        int parsed = Integer.parseInt(number);
        if (parsed > MAX_NUMBER) {
            throw new IllegalArgumentException("The number: '" + number + "' is too large to be converted.");
        }
        if (parsed < 0) {
            return NEGATIVE + getValue(number.substring(1));
        }
        // If the number exists in the numbers map, return it as is.
        if (numbers.containsKey(parsed)) {
            return numbers.get(parsed);
        }
        StringBuilder result = new StringBuilder();// The returned string
        Iterator<Entry<String, String>> iterator = patterns.entrySet().iterator();
        while (iterator.hasNext()) {
            String key = iterator.next().getKey();
            Pattern pattern = Pattern.compile(key);
            Matcher matcher = pattern.matcher(number);
            if (matcher.matches()) {
                int index = key.indexOf('.');
                String temp;
                if (index <= 0) {
                    index = key.indexOf('[');
                    temp = number.substring(index);
                } else {
                    int size = key.length() - index;
                    index = number.length() - size;
                    temp = number.substring(0, index);
                }
                String string = patterns.get(key);
                number = number.substring(index);
                result.append(string.replace("[]", getValue(temp)));
            }
        }
        if (number != "") {
            /*
             * In the event of having a number like 121. The output will be 120
             * and the variable number will still hold the 1.
             */
            result.append(getValue(number));
        }
        // Eightten -> Eighteen, Eightty -> Eighty
        return result.toString().replace("tt", "t");
    }

    public static void main(String[] args) {
        System.out.println(getValue(312321));
    }
}