Java 如何将1-1000转换成单词？

当这项任务分配给我时，我已经想到了如何做，但我所想的“事情”是手动完成1-1000，就像这样：

import.java.io.*
    public static void main(String[] args) throws IOException
    {
       BufferedReader in=new BufferedReader(new InputStreamReader(System.in));

       int num;

         System.out.println("Enter Numbers to convert: ");
         num=Integer.parseInt(in.readLine());

         if (num==1)
         {
             System.out.println("one");
         }     
         else if(num==2)
         {
             System.out.println("two");
         }
         else if(num==3)
         {
             System.out.println("three");
         }
  \*and so on up to 1000*\

请帮帮我，我不想那样做！我只是一个noob程序员：（

从中获得并根据您的需要对其进行修改。这段代码的原始所有者将获得全部荣誉

import java.text.DecimalFormat;

public class EnglishNumberToWords {

  private static final String[] tensNames = {
    "",
    " ten",
    " twenty",
    " thirty",
    " forty",
    " fifty",
    " sixty",
    " seventy",
    " eighty",
    " ninety"
  };

  private static final String[] numNames = {
    "",
    " one",
    " two",
    " three",
    " four",
    " five",
    " six",
    " seven",
    " eight",
    " nine",
    " ten",
    " eleven",
    " twelve",
    " thirteen",
    " fourteen",
    " fifteen",
    " sixteen",
    " seventeen",
    " eighteen",
    " nineteen"
  };

  private EnglishNumberToWords() {}

  private static String convertLessThanOneThousand(int number) {
    String soFar;

    if (number % 100 < 20){
      soFar = numNames[number % 100];
      number /= 100;
    }
    else {
      soFar = numNames[number % 10];
      number /= 10;

      soFar = tensNames[number % 10] + soFar;
      number /= 10;
    }
    if (number == 0) return soFar;
    return numNames[number] + " hundred" + soFar;
  }


  public static String convert(long number) {
    // 0 to 999 999 999 999
    if (number == 0) { return "zero"; }

    String snumber = Long.toString(number);

    // pad with "0"
    String mask = "000000000000";
    DecimalFormat df = new DecimalFormat(mask);
    snumber = df.format(number);

    // XXXnnnnnnnnn
    int billions = Integer.parseInt(snumber.substring(0,3));
    // nnnXXXnnnnnn
    int millions  = Integer.parseInt(snumber.substring(3,6));
    // nnnnnnXXXnnn
    int hundredThousands = Integer.parseInt(snumber.substring(6,9));
    // nnnnnnnnnXXX
    int thousands = Integer.parseInt(snumber.substring(9,12));

    String tradBillions;
    switch (billions) {
    case 0:
      tradBillions = "";
      break;
    case 1 :
      tradBillions = convertLessThanOneThousand(billions)
      + " billion ";
      break;
    default :
      tradBillions = convertLessThanOneThousand(billions)
      + " billion ";
    }
    String result =  tradBillions;

    String tradMillions;
    switch (millions) {
    case 0:
      tradMillions = "";
      break;
    case 1 :
      tradMillions = convertLessThanOneThousand(millions)
         + " million ";
      break;
    default :
      tradMillions = convertLessThanOneThousand(millions)
         + " million ";
    }
    result =  result + tradMillions;

    String tradHundredThousands;
    switch (hundredThousands) {
    case 0:
      tradHundredThousands = "";
      break;
    case 1 :
      tradHundredThousands = "one thousand ";
      break;
    default :
      tradHundredThousands = convertLessThanOneThousand(hundredThousands)
         + " thousand ";
    }
    result =  result + tradHundredThousands;

    String tradThousand;
    tradThousand = convertLessThanOneThousand(thousands);
    result =  result + tradThousand;

    // remove extra spaces!
    return result.replaceAll("^\\s+", "").replaceAll("\\b\\s{2,}\\b", " ");
  }

  /**
   * testing
   * @param args
   */
  public static void main(String[] args)  {

    try {
      Scanner scanner = new Scanner(System.in);
      System.out.println("Enter the number");
      int i = scanner.nextInt();
      System.out.println("*** " + EnglishNumberToWords.convert(i));
    }
    catch(Exception e) {

    }
  }
}

导入java.text.DecimalFormat；
公共类英语数字词{
私有静态最终字符串[]tensNames={
"",
“十”，
“二十”，
“三十”，
“四十”，
“五十”，
“六十”，
“七十”，
“八十”，
“九十”
};
私有静态最终字符串[]numNames={
"",
“一个”，
“两个”，
“三”，
“四”，
“五个”，
“六”，
“七”，
“八”，
“九”，
“十”，
“十一”，
“十二”，
“十三”，
“十四”，
“十五”，
“十六”，
“十七”，
“十八”，
“十九”
};
private EnglishNumberToWords（）{}
私有静态字符串convertlessthannethousand（整数）{
弦索；
如果（数量%100<20）{
soFar=numNames[数量%100]；
数目/=100；
}
否则{
soFar=numNames[数量%10]；
数目/=10；
soFar=tensNames[编号%10]+soFar；
数目/=10；
}
如果（数字==0），则返回soFar；
返回numNames[数字]+“百”+soFar；
}
公共静态字符串转换（长数字）{
//0至999
如果（number==0）{返回“零”；}
字符串snumber=Long.toString（数字）；
//用“0”填充
字符串掩码=“000000000000”；
DecimalFormat df=新的DecimalFormat（掩码）；
snumber=df.format（数字）；
//xxxnnnnnnnnnnn
int十亿=整数.parseInt（snumber.substring（0,3））；
//nnnxxnnnnnn
int数百万=Integer.parseInt（snumber.substring（3,6））；
//nnnnnnXXXnnn
int hundredthoussands=Integer.parseInt（snumber.substring（6,9））；
//nnnnnnxxx
int千=整数.parseInt（snumber.substring（9,12））；
弦乐；
交换机（十亿）{
案例0：
trad=”；
打破
案例1：
TRADBLIONALYST=可转换的酒店和酒店（十亿）
+“亿”；
打破
违约：
TRADBLIONALYST=可转换的酒店和酒店（十亿）
+“亿”；
}
字符串结果=trad；
百万美元；
交换机（百万）{
案例0：
tradmillumns=“”；
打破
案例1：
TradMillowns=可转换的曼哈顿净房屋和（百万）
+“百万”；
打破
违约：
TradMillowns=可转换的曼哈顿净房屋和（百万）
+“百万”；
}
结果=结果+结果；
串成百上千；
交换机（百分之一百）{
案例0：
TradHundthundsands=“”；
打破
案例1：
Traddredthoundsands=“一千”；
打破
违约：
TradHundthousands=无转炉炼钢厂（Hundthousands）
+“千”；
}
结果=结果+交易的百分之一百；
串千；
TRAD千零=可转换的Hanonethousand（千）；
结果=结果+1000；
//删除额外的空间！
返回结果.replaceAll（“^\\s+”，”）.replaceAll（“\\b\\s{2，}\\b”，”）；
}
/**
*测试
*@param args
*/
公共静态void main（字符串[]args）{
试一试{
扫描仪=新的扫描仪（System.in）；
System.out.println（“输入编号”）；
int i=scanner.nextInt（）；
System.out.println（“***”+英文数字转换（i））；
}
捕获（例外e）{
}
}
}

更简单的一点是：

public class ConvertNumberToWords {

    final private  static String[] units = {"Zero","One","Two","Three","Four",
        "Five","Six","Seven","Eight","Nine","Ten",
        "Eleven","Twelve","Thirteen","Fourteen","Fifteen",
        "Sixteen","Seventeen","Eighteen","Nineteen"};
    final private static String[] tens = {"","","Twenty","Thirty","Forty","Fifty",
        "Sixty","Seventy","Eighty","Ninety"};


    public static String convert(Integer i) {
        if( i < 20)  return units[i];
        if( i < 100) return tens[i/10] + ((i % 10 > 0)? " " + convert(i % 10):"");
        if( i < 1000) return units[i/100] + " Hundred" + ((i % 100 > 0)?" and " + convert(i % 100):"");
        if( i < 1000000) return convert(i / 1000) + " Thousand " + ((i % 1000 > 0)? " " + convert(i % 1000):"") ;
        return convert(i / 1000000) + " Million " + ((i % 1000000 > 0)? " " + convert(i % 1000000):"") ;
    }
    public static void main(String[]args){
        for(int i=1;i<1000;i++){
            System.out.println(i+" \t "+convert(i));
        }
    }


}

公共类转换器numbertowords{
最终私有静态字符串[]单位={“零”、“一”、“二”、“三”、“四”，
“五”、“六”、“七”、“八”、“九”、“十”，
“十一”、“十二”、“十三”、“十四”、“十五”，
“十六”、“十七”、“十八”、“十九”}；
最后一个私有静态字符串[]十={“”，“二十”，“三十”，“四十”，“五十”，
“六十”、“七十”、“八十”、“九十”}；
公共静态字符串转换（整数i）{
如果（i<20）返回单位[i]；
如果（i<100）返回十位[i/10]+（（i%10>0）？“+转换（i%10）：”；
如果（i<1000）返回单位[i/100]+“100”+（（i%100>0）和“+转换（i%100）：”）；
如果（i<1000000）返回转换（i/1000）+“千”+（（i%1000>0）？“+转换（i%1000）：”）；
返回转换（i/1000000）+“百万”+（（i%1000000>0）？“+转换（i%1000000）：”）；
}
公共静态void main（字符串[]args）{
对于（int i=1；i如果要针对每个读取的数字打印字符串，则必须使numberArray最多可计数1000个：p

 public static void main(String[] args) throws IOException
 {   

        public static final String[] numberArray = new String[] {
        "one", "two", "three", "four", "five", "six", "seven", "eight", "nine",
        "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen",     "eighteen", "nineteen"
        };


  BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
  String number = in.readLine();

  int num = 0;

  while(num!=1000){
    if (num == Integer.parseInt(number)) {
      System.out.println(numberArray[num]);
    }
    num++;
  }
}

没有任何规则可以用来创建这样的字符串吗？请参见尝试先将数字分解为数字，然后您也可以这样做，只需根据它们的位置向它们添加
100
，
1000
，…就可以了。对于以00到20结尾的数字，没有一般的简单规则，但在20之后，它就变得非常简单了。试试d如果您想要更多建议，请将数字（千、百）合成并提交到此处。您忘记了提及。此外，如果源代码不在堆栈溢出之外，则不应将其作为您自己的答案重新发布，而应将此问题标记为重复。主要根据OP需要，使用：for（长i=1；i@Pshemo是的，sirEven完成了归因，但这并不能摆脱这样一个事实，即你基本上已经为他们完成了OP的家庭作业。我不能真的复制它，因为我会向全班解释……我不能复制我不理解的东西……谢谢你给我一些想法：）表达式的非法开始>静态私有最终字符串[]数字raray=新字符串[]为什么？在你的情况下，这是有效的！还是你需要的？不是如果所有1-1000都显示为单词，我需要的是一个程序的想法如果你输入一个数字，给出的数字将显示结果