我正在开发一个将数字转换为单词的程序，但是我遇到了Numbers类中toString（）方法的问题。所有的方法都给了我，所以我可以实施;因此，我不能删除任何一个......
号码：4564 - ＆gt;四千五百六十四个
这是代码 数字类
package numberstowords;
import java.util.*;
public class Numbers {
//array containing single digits words numbers:0-9
private final String[] SINGLE_DIGITS_WORDS;
//array containing special words words eg:10-19
private final String[] TEEN_DIGITS_WORDS;
//array containing tens words numbers:20-90
private final String[] TEN_DIGITS_WORDS;
private int value, //number to be converted to words
one, //number to store digits
ten, //number to store tens
hundred, //number to store hundred
thousand;//number to store thousand
private String strOut;
//conscructor: Initializing value and arrays
public Numbers(int n)
//getting single digit number
private int getOnes()
{
one = value % 10;
return one;
}
//getting tens numbers
private int getTens()
{
ten = value % 100;
ten /= 10;
return ten;
}
//getting hundreds numbers
private int getHundreds()
{
hundred = value % 1000;
hundred /= 100;
return hundred;
}
//getting thousands numbers
private int getThousands()
{
thousand = value % 10000;
thousand /= 1000;
return thousand;
}
//converting and returning string of ones
private String digitsToString(int one)
{
return SINGLE_DIGITS_WORDS[one];
}
//converting and returning strings of tens and teens
private String tensAndOnesToString(int ten, int one)
{
if(ten == 1)//if number is a teen return, else return tens
{
return TEEN_DIGITS_WORDS[one];
}
return TEN_DIGITS_WORDS[ten-2];
}
//converting and returning strings of hundreds
private String hundredsToString(int hundred)
{
return digitsToString(hundred) + " hundred";
}
private String thousandsToString(int thousand)
{
return digitsToString(thousand) + " thousand";
}
答案 0 :(得分：1)
根据您的评论，问题是您获得了ones之间数字的11-19输出。
查看您的tensAndOnesToString()方法，它会检查是否ten == 1，以便识别teens个数字。那么，为什么不在if(d4 != 0)行中进行类似的检查，
if(d4 != 0 && d3 != 1) // CHANGED THIS LINE
{
if(strOut.equals(""))
strOut = digitsToString(one);
else
{
strOut = strOut +" "+ digitsToString(one);
}
}
现在，如果one不是d4，并且0（tens） 't d3。
答案 1 :(得分：0)
在这个简短的代码中，我使用了递归函数来使它具有良好的性能。 我将给定数字除以小数学可理解值。 这种划分是基于数学的，主要由CPU执行并使用较少的内存。
public class NumbersLetter {
private java.util.HashMap<Long, String> hashMap = new java.util.HashMap<>(34);
private long[] dividers = {
1_000_000_000_000_000_000L, 1_000_000_000_000_000L, 1_000_000_000_000L,
1_000_000_000L, 1_000_000L, 1_000L, 100L, 10L, 1L};
public String getNaturalNumbersLetter(long number) {
String regex = "[0-9]+";
if (!Long.toString(number).matches(regex)) {
number = 0;
}
return divideNumber(number);
}
private String getDigitLetter(long digit) {
return hashMap.get(digit);
}
private String addSeparation(boolean addSeperator) {
if (addSeperator) return " and ";
return "";
}
private String divideNumber(long digit) {
//Check if the number is a pure number
// and mapped in our @hashMap
if (hashMap.containsKey(digit)) {
return " " + getDigitLetter(digit);
}
// Start to divide the given number
// to small pieces of math understandable values
// This type of divide is math based
// which do mostly by the CPU and
// use small amount of RAM.
for (long i : dividers) {
/**
* Start divide the given number to smaller pieces
* for example will change 4,321 to
* 4000 , 300 ,20 & 1
* this is one of those formats which is human readable.
* The important thing about this design is that
* I use calculation instead of buffering strings.
* */
if ((digit >= i)) {
if (digit % i == 0) {
//
return divideNumber(digit / i) + divideNumber(i);
} else {
if ((digit / i) == 1) {
return divideNumber(digit / i)
+ divideNumber((digit / i) * i)
+ divideNumber(digit % i);
} else {
return divideNumber((digit / i) * i)
+ divideNumber(digit % i);
}
}
}
}
return "";
}
public NumbersLetter() {
// NumbersLetter Constructor
hashMap.put(0L, "Zero");
hashMap.put(1L, "One");
hashMap.put(2L, "Two");
hashMap.put(3L, "Three");
hashMap.put(4L, "Four");
hashMap.put(5L, "Five");
hashMap.put(6L, "Six");
hashMap.put(7L, "Seven");
hashMap.put(8L, "Eight");
hashMap.put(9L, "Nine");
hashMap.put(10L, "Ten");
hashMap.put(11L, "Eleven");
hashMap.put(12L, "Twelve");
hashMap.put(13L, "Thirteen");
hashMap.put(14L, "Fourteen");
hashMap.put(15L, "Fifteen");
hashMap.put(16L, "Sixteen");
hashMap.put(17L, "Seventeen");
hashMap.put(18L, "Eighteen");
hashMap.put(19L, "Nineteen");
hashMap.put(20L, "Twenty");
hashMap.put(30L, "Thirty");
hashMap.put(40L, "Forty");
hashMap.put(50L, "Fifty");
hashMap.put(60L, "Sixty");
hashMap.put(70L, "Seventy");
hashMap.put(80L, "Eighty");
hashMap.put(90L, "Ninety");
hashMap.put(100L, "Hundred");
hashMap.put(1_000L, "Thousand");
hashMap.put(1_000_000L, "Million");
hashMap.put(1_000_000_000L, "Billion");
hashMap.put(1_000_000_000_000L, "Trillion");
hashMap.put(1_000_000_000_000_000L, "Quadrillion");
hashMap.put(1_000_000_000_000_000_000L, "Quintillion");
}
}