Java Program Number to Word

In this section, we will create a Java program that converts the given number into words. For example, if the given number is 54,297 then the output should be Fifty-Four Thousand Two Hundred Ninety-Seven. Let’s create a Java program for the same.

NumberToWordExample1.java

  1. class NumberToWordExample1   
  2. {  
  3. //user-defined static method that converts a number into words  
  4. static void numberToWords(char num[])  
  5. {  
  6. //determines the number of digits in the given number  
  7. int len = num.length;  
  8. //checks the given number has number or not  
  9. if (len == 0)   
  10. {  
  11. //if the given number is empty prints the following statement     
  12. System.out.println(“The string is empty.”);  
  13. return;  
  14. }  
  15. //here, we have specified the length of the number to 4  
  16. //it means that the number (that you want to convert) should be four or less than four digits  
  17. if (len > 4)   
  18. {  
  19. //if the given number is more than four-digit number, it prints the following statement    
  20. System.out.println(“\n The given number has more than 4 digits.”);  
  21. return;  
  22. }  
  23. //string type array for one-digit numbers    
  24. String[] onedigit = new String[] {“Zero”, “One”, “Two”, “Three”, “Four”, “Five”, “Six”, “Seven”, “Eight”, “Nine”};  
  25. //string type array for two digits numbers    
  26. //the first index is empty because it makes indexing easy   
  27. String[] twodigits = new String[] {“”, “Ten”, “Eleven”, “Twelve”, “Thirteen”, “Fourteen”, “Fifteen”, “Sixteen”, “Seventeen”, “Eighteen”, “Nineteen”};  
  28. //string type array of tens multiples   
  29. //the first two indexes are empty because it makes indexing easy   
  30. String[] multipleoftens = new String[] {“”,  “”, “Twenty”, “Thirty”, “Forty”, “Fifty”, “Sixty”, “Seventy”, “Eighty”, “Ninety”};  
  31. //string type array of power of tens   
  32. String[] poweroftens = new String[] {“Hundred”, “Thousand”};  
  33. //Used for debugging purpose only   
  34. //the valueOf() method returns the string representation of the character array argument  
  35. System.out.print(String.valueOf(num) + “: “);  
  36. //checks whether the length of the given string is one or not  
  37. if (len == 1)   
  38. {  
  39. //if the above condition returns true, it accesses the corresponding index and prints the value of that index  
  40. //[num[0]-‘0’]: getting the number equal the decimal value of the character (assuming the char is the digit)  
  41. System.out.println(onedigit[num[0]-‘0’]);  
  42. return;  
  43. }  
  44. int x = 0;  
  45. //executes until num does not become not ‘\0’  
  46. while (x < num.length)   
  47. {  
  48. //executes if the length of the string is greater than equal to three  
  49. if (len >= 3)   
  50. {  
  51. if (num[x] – ‘0’ != 0)   
  52. {  
  53. System.out.print(onedigit[num[x] – ‘0’] + ” “);  
  54. //here length can be 3 or 4  
  55. System.out.print(poweroftens[len – 3]+ ” “);  
  56. }  
  57. //decrements the length of the string by 1  
  58. –len;  
  59. }  
  60. //executes if the given number has two digits  
  61. else   
  62. {  
  63. //the if-statement handles the numbers from 10 to 19 only     
  64. if (num[x] – ‘0’ == 1)   
  65. {  
  66. //adding the digits of the given number   
  67. //the logic behind sum up the digits is that we will use the sum for accessing the index of the array   
  68. //for example: 17, sum of digits = 8  
  69. //we will access the 8th index in twodigits[] array i.e. Seventeen  
  70. int sum = num[x] – ‘0’ + num[x + 1] – ‘0’;  
  71. System.out.println(twodigits[sum]);  
  72. return;  
  73. }  
  74. //the else-if statement handles the number 20 only  
  75. //compares the tens and unit place with 2 and 0 respectively  
  76. else if (num[x] – ‘0’ == 2 && num[x + 1] – ‘0’ == 0)   
  77. {  
  78. //executes if the above else-if condition returns true    
  79. System.out.println(“Twenty”);  
  80. return;  
  81. }  
  82. //the else block handles the numbers from 21 to 100  
  83. else   
  84. {  
  85. int i = (num[x] – ‘0’);  
  86. if (i > 0)  
  87. //prints the ith index element of the array multipleoftens[]  
  88. System.out.print(multipleoftens[i]+ ” “);  
  89. else  
  90. //prints space  
  91. System.out.print(“”);  
  92. //increments the variable i by 1  
  93. ++x;  
  94. //checks whether the number is not equal to zero, it means the number has only a digit  
  95. if (num[x] – ‘0’ != 0)  
  96. //prints the ith index element of the array onedigit[]  
  97. System.out.println(onedigit[num[x] – ‘0’]);  
  98. }  
  99. }  
  100. //increments the variable i by 1  
  101. ++x;  
  102. }  
  103. }  
  104. //main() method  
  105. public static void main(String args[])  
  106. {  
  107. //calling the user-defined method and that invokes another predefined method toCharArray()  
  108. //the method toCharArray() converts the given number into character array  
  109. numberToWords(“1111”.toCharArray());  
  110. numberToWords(“673”.toCharArray());  
  111. numberToWords(“85”.toCharArray());  
  112. numberToWords(“5”.toCharArray());  
  113. numberToWords(“0”.toCharArray());  
  114. numberToWords(“20”.toCharArray());  
  115. numberToWords(“1000”.toCharArray());  
  116. numberToWords(“12345”.toCharArray());  
  117. //passing empty string   
  118. numberToWords(“”.toCharArray());  
  119. }  
  120. }  

Output:

Java Program Number to Word

The number is not limited to four digits. Then what if the user enters more than 5 five digits numbers. The above program does not work for large digit numbers.

Converting Large Numbers into Words

The logic for converting the large digit numbers is quite different. Let’s see the approach to convert large digits numbers.

NumberToWordExample2.java

  1. import java.text.DecimalFormat;  
  2. public class NumberToWordExample2   
  3. {  
  4. //string type array for one digit numbers     
  5. private static final String[] twodigits = {“”, ” Ten”, ” Twenty”, ” Thirty”, ” Forty”, ” Fifty”, ” Sixty”, ” Seventy”, ” Eighty”, ” Ninety”};  
  6. //string type array for two digits numbers   
  7. private static final String[] onedigit = {“”, ” One”, ” Two”, ” Three”, ” Four”, ” Five”, ” Six”, ” Seven”, ” Eight”, ” Nine”, ” Ten”, ” Eleven”, ” Twelve”, ” Thirteen”, ” Fourteen”, ” Fifteen”, ” Sixteen”, ” Seventeen”, ” Eighteen”, ” Nineteen”};  
  8. //defining constructor of the class  
  9. private NumberToWordExample2()   
  10. {  
  11. }  
  12. //user-defined method that converts a number to words (up to 1000)  
  13. private static String convertUptoThousand(int number)   
  14. {  
  15. String soFar;  
  16. if (number % 100 < 20)  
  17. {  
  18. soFar = onedigit[number % 100];  
  19. number = number/ 100;  
  20. }  
  21. else   
  22. {  
  23. soFar = onedigit[number % 10];  
  24. number = number/ 10;  
  25. soFar = twodigits[number % 10] + soFar;  
  26. number = number/ 10;  
  27. }  
  28. if (number == 0)   
  29. return soFar;  
  30. return onedigit[number] + ” Hundred ” + soFar;  
  31. }  
  32. //user-defined method that converts a long number (0 to 999999999) to string    
  33. public static String convertNumberToWord(long number)   
  34. {  
  35. //checks whether the number is zero or not  
  36. if (number == 0)   
  37. {   
  38. //if the given number is zero it returns zero  
  39. return “zero”;   
  40. }  
  41. //the toString() method returns a String object that represents the specified long  
  42. String num = Long.toString(number);  
  43. //for creating a mask padding with “0”   
  44. String pattern = “000000000000”;  
  45. //creates a DecimalFormat using the specified pattern and also provides the symbols for the default locale  
  46. DecimalFormat decimalFormat = new DecimalFormat(pattern);  
  47. //format a number of the DecimalFormat instance  
  48. num = decimalFormat.format(number);  
  49. //format: XXXnnnnnnnnn  
  50. //the subString() method returns a new string that is a substring of this string  
  51. //the substring begins at the specified beginIndex and extends to the character at index endIndex – 1  
  52. //the parseInt() method converts the string into integer  
  53. int billions = Integer.parseInt(num.substring(0,3));  
  54. //format: nnnXXXnnnnnn  
  55. int millions  = Integer.parseInt(num.substring(3,6));  
  56. //format: nnnnnnXXXnnn  
  57. int hundredThousands = Integer.parseInt(num.substring(6,9));  
  58. //format: nnnnnnnnnXXX  
  59. int thousands = Integer.parseInt(num.substring(9,12));  
  60. String tradBillions;  
  61. switch (billions)   
  62. {  
  63. case 0:  
  64. tradBillions = “”;  
  65. break;  
  66. case 1 :  
  67. tradBillions = convertUptoThousand(billions)+ ” Billion “;  
  68. break;  
  69. default :  
  70. tradBillions = convertUptoThousand(billions)+ ” Billion “;  
  71. }  
  72. String result =  tradBillions;  
  73. String tradMillions;  
  74. switch (millions)   
  75. {  
  76. case 0:  
  77. tradMillions = “”;  
  78. break;  
  79. case 1 :  
  80. tradMillions = convertUptoThousand(millions)+ ” Million “;  
  81. break;  
  82. default :  
  83. tradMillions = convertUptoThousand(millions)+ ” Million “;  
  84. }  
  85. result =  result + tradMillions;  
  86. String tradHundredThousands;  
  87. switch (hundredThousands)   
  88. {  
  89. case 0:  
  90. tradHundredThousands = “”;  
  91. break;  
  92. case 1 :  
  93. tradHundredThousands = “One Thousand “;  
  94. break;  
  95. default :  
  96. tradHundredThousands = convertUptoThousand(hundredThousands)+ ” Thousand “;  
  97. }  
  98. result =  result + tradHundredThousands;  
  99. String tradThousand;  
  100. tradThousand = convertUptoThousand(thousands);  
  101. result =  result + tradThousand;  
  102. //removing extra space if any  
  103. return result.replaceAll(“^\\s+”, “”).replaceAll(“\\b\\s{2,}\\b”, ” “);  
  104. }  
  105. //main() method  
  106. public static void main(String args[])   
  107. {  
  108. //calling the user-defined method that converts the parsed number into words  
  109. System.out.println(convertNumberToWord(2));  
  110. System.out.println(convertNumberToWord(99));  
  111. System.out.println(convertNumberToWord(456));  
  112. System.out.println(convertNumberToWord(1101));  
  113. System.out.println(convertNumberToWord(19812));  
  114. System.out.println(convertNumberToWord(674319));  
  115. System.out.println(convertNumberToWord(909087531));  
  116. System.out.println(convertNumberToWord(1000000000));  
  117. System.out.println(convertNumberToWord(359999999));  
  118. System.out.println(convertNumberToWord(1213000000L));  
  119. System.out.println(convertNumberToWord(1000000));  
  120. System.out.println(convertNumberToWord(1111111111));  
  121. System.out.println(convertNumberToWord(3000200));  
  122. System.out.println(convertNumberToWord(700000));  
  123. System.out.println(convertNumberToWord(9000000));  
  124. }  
  125. }  

Output:

Java Program Number to Word

Converting Very Long Numbers into Words

The logic for the conversion of very long numbers into words is different from the previous one. Before moving ahead, it is important to learn the name of large numbers. The following table describes the name of the larger numbers.

NameShort Scale
(US, English Canada, modern British, Australia, and Eastern Europe)
Long Scale
(French Canada, older British, Western & Central Europe)
Million106106
MilliardNot used109
Billion1091012
BilliardNot used1015
Trillion10121018
Quadrillion10151024
Quintillion10181030
Sextillion10211036
Septillion10241042
Octillion10271048
Nonillion10301054
Decillion10331060
Undecillion10361066
Duodecillion10391072
Tredecillion10421078
Quattuordecillion10451084
Quindecillion10481090
Sexdecillion10511096
Septendecillion105410102
Octodecillion105710108
Novemdecillion106010114
Vigintillion106310120
Centillion1030310600

Let’s create a Java program that converts very long numbers into words.

The following Java program also converts the negative and decimal numbers into words.

NumberToWordExample3.java

  1. import java.util.*;  
  2. public class NumberToWordExample3   
  3. {  
  4. static public class ScaleUnit   
  5. {  
  6. private int exponent;  
  7. private String[] names;  
  8. private ScaleUnit(int exponent, String…names)   
  9. {  
  10. this.exponent = exponent;  
  11. this.names = names;  
  12. }  
  13. public int getExponent()   
  14. {  
  15. return exponent;  
  16. }  
  17. public String getName(int index)   
  18. {  
  19. return names[index];  
  20. }  
  21. }  
  22. static private ScaleUnit[] SCALE_UNITS = new ScaleUnit[]   
  23. {  
  24. new ScaleUnit(63, “vigintillion”, “decilliard”),  
  25. new ScaleUnit(60, “novemdecillion”, “decillion”),  
  26. new ScaleUnit(57, “octodecillion”, “nonilliard”),  
  27. new ScaleUnit(54, “septendecillion”, “nonillion”),  
  28. new ScaleUnit(51, “sexdecillion”, “octilliard”),  
  29. new ScaleUnit(48, “quindecillion”, “octillion”),  
  30. new ScaleUnit(45, “quattuordecillion”, “septilliard”),  
  31. new ScaleUnit(42, “tredecillion”, “septillion”),  
  32. new ScaleUnit(39, “duodecillion”, “sextilliard”),  
  33. new ScaleUnit(36, “undecillion”, “sextillion”),  
  34. new ScaleUnit(33, “decillion”, “quintilliard”),  
  35. new ScaleUnit(30, “nonillion”, “quintillion”),  
  36. new ScaleUnit(27, “octillion”, “quadrilliard”),  
  37. new ScaleUnit(24, “septillion”, “quadrillion”),  
  38. new ScaleUnit(21, “sextillion”, “trilliard”),  
  39. new ScaleUnit(18, “quintillion”, “trillion”),  
  40. new ScaleUnit(15, “quadrillion”, “billiard”),  
  41. new ScaleUnit(12, “trillion”, “billion”),  
  42. new ScaleUnit(9, “billion”, “milliard”),  
  43. new ScaleUnit(6, “million”, “million”),  
  44. new ScaleUnit(3, “thousand”, “thousand”),  
  45. new ScaleUnit(2, “hundred”, “hundred”),  
  46. //new ScaleUnit(1, “ten”, “ten”),  
  47. //new ScaleUnit(0, “one”, “one”),  
  48. new ScaleUnit(-1, “tenth”, “tenth”),  
  49. new ScaleUnit(-2, “hundredth”, “hundredth”),  
  50. new ScaleUnit(-3, “thousandth”, “thousandth”),  
  51. new ScaleUnit(-4, “ten-thousandth”, “ten-thousandth”),  
  52. new ScaleUnit(-5, “hundred-thousandth”, “hundred-thousandth”),  
  53. new ScaleUnit(-6, “millionth”, “millionth”),  
  54. new ScaleUnit(-7, “ten-millionth”, “ten-millionth”),  
  55. new ScaleUnit(-8, “hundred-millionth”, “hundred-millionth”),  
  56. new ScaleUnit(-9, “billionth”, “milliardth”),  
  57. new ScaleUnit(-10, “ten-billionth”, “ten-milliardth”),  
  58. new ScaleUnit(-11, “hundred-billionth”, “hundred-milliardth”),  
  59. new ScaleUnit(-12, “trillionth”, “billionth”),  
  60. new ScaleUnit(-13, “ten-trillionth”, “ten-billionth”),  
  61. new ScaleUnit(-14, “hundred-trillionth”, “hundred-billionth”),  
  62. new ScaleUnit(-15, “quadrillionth”, “billiardth”),  
  63. new ScaleUnit(-16, “ten-quadrillionth”, “ten-billiardth”),  
  64. new ScaleUnit(-17, “hundred-quadrillionth”, “hundred-billiardth”),  
  65. new ScaleUnit(-18, “quintillionth”, “trillionth”),  
  66. new ScaleUnit(-19, “ten-quintillionth”, “ten-trillionth”),  
  67. new ScaleUnit(-20, “hundred-quintillionth”, “hundred-trillionth”),  
  68. new ScaleUnit(-21, “sextillionth”, “trilliardth”),  
  69. new ScaleUnit(-22, “ten-sextillionth”, “ten-trilliardth”),  
  70. new ScaleUnit(-23, “hundred-sextillionth”, “hundred-trilliardth”),  
  71. new ScaleUnit(-24, “septillionth”,”quadrillionth”),  
  72. new ScaleUnit(-25, “ten-septillionth”,”ten-quadrillionth”),  
  73. new ScaleUnit(-26, “hundred-septillionth”,”hundred-quadrillionth”),  
  74. };  
  75. static public enum Scale   
  76. {  
  77. SHORT,  
  78. LONG;  
  79. public String getName(int exponent)   
  80. {  
  81. for (ScaleUnit unit : SCALE_UNITS)   
  82. {  
  83. if (unit.getExponent() == exponent)   
  84. {  
  85. return unit.getName(this.ordinal());  
  86. }  
  87. }  
  88. return “”;   
  89. }  
  90. }  
  91. /** 
  92. * Change this scale to support American and modern British value (short scale) 
  93. * or Traditional British value (long scale) 
  94. */  
  95. static public Scale SCALE = Scale.SHORT;   
  96. static abstract public class AbstractProcessor   
  97. {  
  98. static protected final String SEPARATOR = ” “;  
  99. static protected final int NO_VALUE = -1;  
  100. protected List<Integer> getDigits(long value)   
  101. {  
  102. ArrayList<Integer> digits = new ArrayList<Integer>();  
  103. if (value == 0)  
  104. {  
  105. digits.add(0);  
  106. }   
  107. else   
  108. {  
  109. while (value > 0)   
  110. {  
  111. digits.add(0, (int) value % 10);  
  112. value /= 10;  
  113. }  
  114. }  
  115. return digits;  
  116. }  
  117. public String getName(long value)   
  118. {  
  119. return getName(Long.toString(value));  
  120. }  
  121. public String getName(double value)   
  122. {  
  123. return getName(Double.toString(value));  
  124. }  
  125. abstract public String getName(String value);  
  126. }  
  127. static public class UnitProcessor extends AbstractProcessor   
  128. {  
  129. static private final String[] TOKENS = new String[]   
  130. {  
  131. “one”, “two”, “three”, “four”, “five”, “six”, “seven”, “eight”, “nine”, “ten”, “eleven”, “twelve”, “thirteen”, “fourteen”, “fifteen”, “sixteen”, “seventeen”, “eighteen”, “nineteen”  
  132. };  
  133. @Override  
  134. public String getName(String value)   
  135. {  
  136. StringBuilder buffer = new StringBuilder();  
  137. int offset = NO_VALUE;  
  138. int number;  
  139. if (value.length() > 3)   
  140. {  
  141. number = Integer.valueOf(value.substring(value.length() – 3), 10);  
  142. }   
  143. else   
  144. {  
  145. number = Integer.valueOf(value, 10);  
  146. }  
  147. number %= 100;  
  148. if (number < 10)   
  149. {  
  150. offset = (number % 10) – 1;  
  151. //number /= 10;  
  152. }   
  153. else if (number < 20)   
  154. {  
  155. offset = (number % 20) – 1;  
  156. //number /= 100;  
  157. }  
  158. if (offset != NO_VALUE && offset < TOKENS.length)   
  159. {  
  160. buffer.append(TOKENS[offset]);  
  161. }  
  162. return buffer.toString();  
  163. }  
  164. }  
  165. static public class TensProcessor extends AbstractProcessor   
  166. {  
  167. static private final String[] TOKENS = new String[]   
  168. {  
  169. “twenty”, “thirty”, “forty”, “fifty”, “sixty”, “seventy”, “eighty”, “ninety”  
  170. };  
  171. static private final String UNION_SEPARATOR = “-“;  
  172. private UnitProcessor unitProcessor = new UnitProcessor();  
  173. @Override  
  174. public String getName(String value)   
  175. {  
  176. StringBuilder buffer = new StringBuilder();  
  177. boolean tensFound = false;  
  178. int number;  
  179. if (value.length() > 3)   
  180. {  
  181. number = Integer.valueOf(value.substring(value.length() – 3), 10);  
  182. }   
  183. else   
  184. {  
  185. number = Integer.valueOf(value, 10);  
  186. }  
  187. number %= 100;   // keep only two digits  
  188. if (number >= 20)   
  189. {  
  190. buffer.append(TOKENS[(number / 10) – 2]);  
  191. number %= 10;  
  192. tensFound = true;  
  193. }  
  194. else   
  195. {  
  196. number %= 20;  
  197. }  
  198. if (number != 0)   
  199. {  
  200. if (tensFound)   
  201. {  
  202. buffer.append(UNION_SEPARATOR);  
  203. }  
  204. buffer.append(unitProcessor.getName(number));  
  205. }  
  206. return buffer.toString();  
  207. }  
  208. }  
  209. static public class HundredProcessor extends AbstractProcessor   
  210. {  
  211. private int EXPONENT = 2;  
  212. private UnitProcessor unitProcessor = new UnitProcessor();  
  213. private TensProcessor tensProcessor = new TensProcessor();  
  214. @Override  
  215. public String getName(String value)   
  216. {  
  217. StringBuilder buffer = new StringBuilder();  
  218. int number;  
  219. if (value.isEmpty())   
  220. {  
  221. number = 0;  
  222. }   
  223. else if (value.length() > 4)   
  224. {  
  225. number = Integer.valueOf(value.substring(value.length() – 4), 10);  
  226. }  
  227. else   
  228. {  
  229. number = Integer.valueOf(value, 10);  
  230. }  
  231. number %= 1000;  // keep at least three digits  
  232. if (number >= 100)   
  233. {  
  234. buffer.append(unitProcessor.getName(number / 100));  
  235. buffer.append(SEPARATOR);  
  236. buffer.append(SCALE.getName(EXPONENT));  
  237. }  
  238. String tensName = tensProcessor.getName(number % 100);  
  239. if (!tensName.isEmpty() && (number >= 100))   
  240. {  
  241. buffer.append(SEPARATOR);  
  242. }  
  243. buffer.append(tensName);  
  244. return buffer.toString();  
  245. }  
  246. }  
  247. static public class CompositeBigProcessor extends AbstractProcessor   
  248. {  
  249. private HundredProcessor hundredProcessor = new HundredProcessor();  
  250. private AbstractProcessor lowProcessor;  
  251. private int exponent;  
  252. public CompositeBigProcessor(int exponent)   
  253. {  
  254. if (exponent <= 3)   
  255. {  
  256. lowProcessor = hundredProcessor;  
  257. }   
  258. else   
  259. {  
  260. lowProcessor = new CompositeBigProcessor(exponent – 3);  
  261. }  
  262. this.exponent = exponent;  
  263. }  
  264. public String getToken()   
  265. {  
  266. return SCALE.getName(getPartDivider());  
  267. }  
  268. protected AbstractProcessor getHighProcessor()   
  269. {  
  270. return hundredProcessor;  
  271. }  
  272. protected AbstractProcessor getLowProcessor()   
  273. {  
  274. return lowProcessor;  
  275. }  
  276. public int getPartDivider()   
  277. {  
  278. return exponent;  
  279. }  
  280. @Override  
  281. public String getName(String value)   
  282. {  
  283. StringBuilder buffer = new StringBuilder();  
  284. String high, low;  
  285. if (value.length() < getPartDivider())   
  286. {  
  287. high = “”;  
  288. low = value;  
  289. }   
  290. else   
  291. {  
  292. int index = value.length() – getPartDivider();  
  293. high = value.substring(0, index);  
  294. low = value.substring(index);  
  295. }  
  296. String highName = getHighProcessor().getName(high);  
  297. String lowName = getLowProcessor().getName(low);  
  298. if (!highName.isEmpty())   
  299. {  
  300. buffer.append(highName);  
  301. buffer.append(SEPARATOR);  
  302. buffer.append(getToken());  
  303. if (!lowName.isEmpty())   
  304. {  
  305. buffer.append(SEPARATOR);  
  306. }  
  307. }  
  308. if (!lowName.isEmpty())   
  309. {  
  310. buffer.append(lowName);  
  311. }  
  312. return buffer.toString();  
  313. }  
  314. }  
  315. static public class DefaultProcessor extends AbstractProcessor   
  316. {  
  317. static private String MINUS = “minus”;  
  318. static private String UNION_AND = “and”;  
  319. static private String ZERO_TOKEN = “zero”;  
  320. private AbstractProcessor processor = new CompositeBigProcessor(63);  
  321. @Override  
  322. public String getName(String value)   
  323. {  
  324. boolean negative = false;  
  325. if (value.startsWith(“-“))   
  326. {  
  327. negative = true;  
  328. value = value.substring(1);  
  329. }  
  330. int decimals = value.indexOf(“.”);  
  331. String decimalValue = null;  
  332. if (0 <= decimals)   
  333. {  
  334. decimalValue = value.substring(decimals + 1);  
  335. value = value.substring(0, decimals);  
  336. }  
  337. String name = processor.getName(value);  
  338. if (name.isEmpty())   
  339. {  
  340. name = ZERO_TOKEN;  
  341. }   
  342. else if (negative)   
  343. {  
  344. name = MINUS.concat(SEPARATOR).concat(name);   
  345. }  
  346. if (!(null == decimalValue || decimalValue.isEmpty()))   
  347. {  
  348. name = name.concat(SEPARATOR).concat(UNION_AND).concat(SEPARATOR)  
  349. .concat(processor.getName(decimalValue)).concat(SEPARATOR).concat(SCALE.getName(-decimalValue.length()));  
  350. }  
  351. return name;  
  352. }  
  353. }  
  354. static public AbstractProcessor processor;  
  355. public static void main(String…args)   
  356. {  
  357. processor = new DefaultProcessor();  
  358. long[] values = new long[]   
  359. {            0,4,10,12,100,108,299,1000,1003,2040,45213,100000,100005,100010,202020,202022,999999,1000000,1000001,10000000,10000007,99999999,  
  360. Long.MAX_VALUE,  
  361. Long.MIN_VALUE  
  362. };  
  363. String[] strValues = new String[]   
  364. {  
  365. “0001.2”,”3.141592″  
  366. };  
  367. for (long val : values)   
  368. {  
  369. System.out.println(val + ” = ” + processor.getName(val) );  
  370. }  
  371. for (String strVal : strValues)   
  372. {  
  373. System.out.println(strVal + ” = ” + processor.getName(strVal) );  
  374. }  
  375. //generates a very large number  
  376. StringBuilder bigNumber = new StringBuilder();  
  377. for (int d=0; d<66; d++)   
  378. {  
  379. bigNumber.append( (char) ((Math.random() * 10) + ‘0’));  
  380. }  
  381. bigNumber.append(“.”);  
  382. for (int d=0; d<26; d++)   
  383. {  
  384. bigNumber.append( (char) ((Math.random() * 10) + ‘0’));  
  385. }  
  386. System.out.println(bigNumber.toString() + ” = ” + processor.getName(bigNumber.toString()));  
  387. }  
  388. }  

Output:

0 = zero
4 = four
10 = ten
12 = twelve
100 = one hundred
108 = one hundred eight
299 = two hundred ninety-nine
1000 = one thousand
1003 = one thousand three
2040 = two thousand forty
45213 = forty-five thousand two hundred thirteen
100000 = one hundred thousand
100005 = one hundred thousand five
100010 = one hundred thousand ten
202020 = two hundred two thousand twenty
202022 = two hundred two thousand twenty-two
999999 = nine hundred ninety-nine thousand nine hundred ninety-nine
1000000 = one million
1000001 = one million one
10000000 = ten million
10000007 = ten million seven
99999999 = ninety-nine million nine hundred ninety-nine thousand nine hundred ninety-nine
9223372036854775807 = nine quintillion two hundred twenty-three quadrillion three hundred seventy-two trillion thirty-six billion eight hundred fifty-four million seven hundred seventy-five thousand eight hundred seven
-9223372036854775808 = minus nine quintillion two hundred twenty-three quadrillion three hundred seventy-two trillion thirty-six billion eight hundred fifty-four million seven hundred seventy-five thousand eight hundred eight
0001.2 = one and two tenth
3.141592 = three and one hundred forty-one thousand five hundred ninety-two milliont

Leave a Comment