java编写的金额转中文大写

  1 package com.coxon.finance.tool;
  2 
  3 public class ChinaNumber
  4 {
  5 
  6     private static String[] CH = { "", "", "拾", "佰", "仟", "万", "", "", "", "亿", "", "", "", "兆" };
  7     
  8     private static String[] CHS_NUMBER={"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};
  9     
 10     /**
 11      * 传入数字金额字符串，返回数字金额对应的中文大字与读法
 12      * 
 13      * @param money
 14      *            金额字符串
 15      * @return 金额中文大写
 16      */
 17     public static String getCHSNumber(String money)
 18     {
 19         String chs = "";
 20 
 21         String tmp_int = money.substring(0, money.indexOf("."));
 22         String tmp_down = money.substring(money.indexOf(".") + 1, money.length());
 23 
 24         char[] tmp_int_char = tmp_int.toCharArray();
 25         String[] tmp_chs = new String[tmp_int_char.length];
 26 
 27         int tab = 0;
 28         for (int i = 0; i < tmp_int_char.length; i++)
 29         {
 30 
 31             tab = tmp_int_char.length - i - 1;
 32 
 33             if (tmp_int_char.length <= 5)
 34             {
 35                 tmp_chs[tab] = CHS_NUMBER[(int) Float.parseFloat(tmp_int_char[i] + ".0")];
 36 
 37                 if (!tmp_chs[tab].equals("零"))
 38                 {
 39 
 40                     // tmp_int_char.length - i 为数字所在的位数
 41                     chs = chs + tmp_chs[tab] + CH[tmp_int_char.length - i];
 42                 } else
 43                 {// 当数字中有零时就在后加上零，如果超过１个以上的零也只加一个零
 44                     if (!chs.endsWith("零") && tab != 0)
 45                     {
 46                         chs = chs + tmp_chs[tab];
 47 
 48                     } else if (chs.endsWith("零") && tab == 0)
 49                     {
 50                         chs = chs.substring(0, chs.length() - 1);
 51                     }
 52 
 53                 }
 54             }
 55 
 56             // 　如果数字的位数大于５和小于９时
 57             if (tmp_int_char.length > 5 && tmp_int_char.length < 9)
 58             {
 59                 tmp_chs[tab] = CHS_NUMBER[(int) Float.parseFloat(tmp_int_char[i] + ".0")];
 60 
 61                 // 如：123,1234分成两部分
 62                 // 第１部分123：万以上亿以下
 63                 if (tab >= 4)
 64                 {
 65                     // 当前数字不是大小零时
 66                     if (!tmp_chs[tab].equals("零"))
 67                     {
 68                         chs = chs + tmp_chs[tab] + CH[tab - 3];
 69 
 70                         // 　当第１部分算完时在加上"万"
 71                         if (tab == 4)
 72                         {
 73                             chs = chs + "万";
 74                         }
 75 
 76                     } else
 77                     {
 78                         // 当前数字为大小"零"时
 79                         // 判断前一次形成在字符串结尾有没有零
 80                         // 　如果没有零就加上零
 81                         if (!chs.endsWith("零"))
 82                         {
 83                             chs = chs + tmp_chs[tab];
 84 
 85                         }
 86 
 87                         // 当第１部分算完时
 88 
 89                         if (tab == 4)
 90                         {
 91                             // 　先判断字符串有没有零
 92                             // 　如果有零时就把零去掉再加上"万"
 93                             if (chs.endsWith("零"))
 94                             {
 95                                 chs = chs.substring(0, chs.length() - 1);
 96                                 chs = chs + "万";
 97                             } else
 98                             {
 99                                 // 　如果没有零就直接加上"万"
100                                 chs = chs + "万";
101                             }
102                         }
103                     }
104                 }
105 
106                 // 如：123,1234分成两部分
107                 // 第１部分1234：万以下
108                 if (tab < 4)
109                 {
110 
111                     if (!tmp_chs[tab].equals("零"))
112                     {
113 
114                         // tmp_int_char.length - i 为数字所在的位数
115                         chs = chs + tmp_chs[tab] + CH[tmp_int_char.length - i];
116                     } else
117                     {// 当数字中有零时就在后加上零，如果超过１个以上的零也只加一个零
118                         if (!chs.endsWith("零") && tab != 0)
119                         {
120                             chs = chs + tmp_chs[tab];
121 
122                         }
123 
124                         if (chs.endsWith("零") && tab == 0)
125                         {
126                             chs = chs.substring(0, chs.length() - 1);
127                         }
128                     }
129                 }
130             }
131 
132             // 　如果数字的位数大于５和小于９时
133             if (tmp_int_char.length >= 9 && tmp_int_char.length <= 12)
134             {
135                 tmp_chs[tab] = CHS_NUMBER[(int) Float.parseFloat(tmp_int_char[i] + ".0")];
136 
137                 if (tab >= 8 && tab < 12)
138                 {
139                     // 当前数字不是大小零时
140                     if (!tmp_chs[tab].equals("零"))
141                     {
142                         chs = chs + tmp_chs[tab] + CH[tab - 7];
143 
144                         // 　当第１部分算完时在加上"万"
145                         if (tab == 8)
146                         {
147                             chs = chs + "亿";
148                         }
149 
150                     } else
151                     {
152                         // 当前数字为大小"零"时
153                         // 判断前一次形成在字符串结尾有没有零
154                         // 　如果没有零就加上零
155                         if (!chs.endsWith("零"))
156                         {
157                             chs = chs + tmp_chs[tab];
158 
159                         }
160 
161                         // 当第１部分算完时
162 
163                         if (tab == 8)
164                         {
165                             // 　先判断字符串有没有零
166                             // 　如果有零时就把零去掉再加上"万"
167                             if (chs.endsWith("零"))
168                             {
169                                 chs = chs.substring(0, chs.length() - 1);
170                                 chs = chs + "亿";
171                             } else
172                             {
173                                 // 　如果没有零就直接加上"万"
174                                 chs = chs + "亿";
175                             }
176                         }
177                     }
178                 }
179                 // 如：123,1234分成两部分
180                 // 第１部分123：万以上亿以下
181                 if (tab >= 4 && tab < 8)
182                 {
183                     // 当前数字不是大小零时
184                     if (!tmp_chs[tab].equals("零"))
185                     {
186                         chs = chs + tmp_chs[tab] + CH[tab - 3];
187 
188                         // 　当第１部分算完时在加上"万"
189                         if (tab == 4)
190                         {
191                             chs = chs + "万";
192                         }
193 
194                     } else
195                     {
196                         // 当前数字为大小"零"时
197                         // 判断前一次形成在字符串结尾有没有零
198                         // 　如果没有零就加上零
199                         if (!chs.endsWith("零"))
200                         {
201                             chs = chs + tmp_chs[tab];
202 
203                         }
204 
205                         // 当第１部分算完时
206 
207                         if (tab == 4)
208                         {
209                             // 　先判断字符串有没有零
210                             // 　如果有零时就把零去掉再加上"万"
211                             if (chs.endsWith("零"))
212                             {
213                                 chs = chs.substring(0, chs.length() - 1);
214 
215                                 if (!chs.endsWith("亿"))
216                                     chs = chs + "万";
217                             } else
218                             {
219                                 // 　如果没有零就直接加上"万"
220                                 if (!chs.endsWith("亿"))
221                                     chs = chs + "万";
222                             }
223                         }
224                     }
225                 }
226 
227                 // 如：123,1234分成两部分
228                 // 第１部分1234：万以下
229                 if (tab < 4)
230                 {
231 
232                     if (!tmp_chs[tab].equals("零"))
233                     {
234 
235                         // tmp_int_char.length - i 为数字所在的位数
236                         chs = chs + tmp_chs[tab] + CH[tmp_int_char.length - i];
237                     } else
238                     {// 当数字中有零时就在后加上零，如果超过１个以上的零也只加一个零
239                         if (!chs.endsWith("零") && tab != 0)
240                         {
241                             chs = chs + tmp_chs[tab];
242 
243                         }
244 
245                         if (chs.endsWith("零") && tab == 0)
246                         {
247                             chs = chs.substring(0, chs.length() - 1);
248                         }
249                     }
250                 }
251             }
252 
253             // 　如果数字的位数大于12和小于16时
254             if (tmp_int_char.length > 12 && tmp_int_char.length <= 16)
255             {
256                 tmp_chs[tab] = CHS_NUMBER[(int) Float.parseFloat(tmp_int_char[i] + ".0")];
257 
258                 if (tab >= 12 && tab < 16)
259                 {
260                     // 当前数字不是大小零时
261                     if (!tmp_chs[tab].equals("零"))
262                     {
263                         chs = chs + tmp_chs[tab] + CH[tab - 11];
264 
265                         // 　当第１部分算完时在加上"万"
266                         if (tab == 12)
267                         {
268                             chs = chs + "兆";
269                         }
270 
271                     } else
272                     {
273                         // 当前数字为大小"零"时
274                         // 判断前一次形成在字符串结尾有没有零
275                         // 　如果没有零就加上零
276                         if (!chs.endsWith("零"))
277                         {
278                             chs = chs + tmp_chs[tab];
279 
280                         }
281 
282                         // 当第１部分算完时
283 
284                         if (tab == 12)
285                         {
286                             // 　先判断字符串有没有零
287                             // 　如果有零时就把零去掉再加上"万"
288                             if (chs.endsWith("零"))
289                             {
290                                 chs = chs.substring(0, chs.length() - 1);
291                                 chs = chs + "兆";
292                             } else
293                             {
294                                 // 　如果没有零就直接加上"万"
295                                 chs = chs + "兆";
296                             }
297                         }
298                     }
299                 }
300 
301                 if (tab >= 8 && tab < 12)
302                 {
303                     // 当前数字不是大小零时
304                     if (!tmp_chs[tab].equals("零"))
305                     {
306                         chs = chs + tmp_chs[tab] + CH[tab - 7];
307 
308                         // 　当第１部分算完时在加上"万"
309                         if (tab == 8)
310                         {
311                             chs = chs + "亿";
312                         }
313 
314                     } else
315                     {
316                         // 当前数字为大小"零"时
317                         // 判断前一次形成在字符串结尾有没有零
318                         // 　如果没有零就加上零
319                         if (!chs.endsWith("零"))
320                         {
321                             chs = chs + tmp_chs[tab];
322 
323                         }
324 
325                         // 当第１部分算完时
326 
327                         if (tab == 8)
328                         {
329                             // 　先判断字符串有没有零
330                             // 　如果有零时就把零去掉再加上"万"
331                             if (chs.endsWith("零"))
332                             {
333                                 chs = chs.substring(0, chs.length() - 1);
334                                 if (!chs.endsWith("兆"))
335                                     chs = chs + "亿";
336                             } else
337                             {
338                                 // 　如果没有零就直接加上"万"
339                                 if (!chs.endsWith("兆"))
340                                     chs = chs + "亿";
341                             }
342                         }
343                     }
344                 }
345                 // 如：123,1234分成两部分
346                 // 第１部分123：万以上亿以下
347                 if (tab >= 4 && tab < 8)
348                 {
349                     // 当前数字不是大小零时
350                     if (!tmp_chs[tab].equals("零"))
351                     {
352                         chs = chs + tmp_chs[tab] + CH[tab - 3];
353 
354                         // 　当第１部分算完时在加上"万"
355                         if (tab == 4)
356                         {
357                             chs = chs + "万";
358                         }
359 
360                     } else
361                     {
362                         // 当前数字为大小"零"时
363                         // 判断前一次形成在字符串结尾有没有零
364                         // 　如果没有零就加上零
365                         if (!chs.endsWith("零"))
366                         {
367                             chs = chs + tmp_chs[tab];
368 
369                         }
370 
371                         // 当第１部分算完时
372 
373                         if (tab == 4)
374                         {
375                             // 　先判断字符串有没有零
376                             // 　如果有零时就把零去掉再加上"万"
377                             if (chs.endsWith("零"))
378                             {
379                                 chs = chs.substring(0, chs.length() - 1);
380 
381                                 if (!chs.endsWith("亿"))
382                                     if (!chs.endsWith("兆"))
383                                         if (!chs.endsWith("兆"))
384                                             chs = chs + "万";
385                             } else
386                             {
387                                 // 　如果没有零就直接加上"万"
388                                 if (!chs.endsWith("亿"))
389                                     if (!chs.endsWith("兆"))
390                                         chs = chs + "万";
391                             }
392                         }
393                     }
394                 }
395 
396                 // 如：123,1234分成两部分
397                 // 第１部分1234：万以下
398                 if (tab < 4)
399                 {
400 
401                     if (!tmp_chs[tab].equals("零"))
402                     {
403 
404                         // tmp_int_char.length - i 为数字所在的位数
405                         chs = chs + tmp_chs[tab] + CH[tmp_int_char.length - i];
406                     } else
407                     {// 当数字中有零时就在后加上零，如果超过１个以上的零也只加一个零
408                         if (!chs.endsWith("零") && tab != 0)
409                         {
410                             chs = chs + tmp_chs[tab];
411 
412                         }
413 
414                         if (chs.endsWith("零") && tab == 0)
415                         {
416                             chs = chs.substring(0, chs.length() - 1);
417                         }
418                     }
419                 }
420             }
421 
422             // 　如果数字的位数大于16
423             if (tmp_int_char.length > 16)
424             {
425                 tmp_chs[tab] = CHS_NUMBER[(int) Float.parseFloat(tmp_int_char[i] + ".0")];
426 
427                 if (tab >= 12)
428                 {
429                     chs = chs + tmp_chs[tab];
430 
431                     // 　当第１部分算完时在加上"万"
432                     if (tab == 12)
433                     {
434                         chs = chs + "兆";
435                     }
436 
437                 }
438 
439                 if (tab >= 8 && tab < 12)
440                 {
441                     // 当前数字不是大小零时
442                     if (!tmp_chs[tab].equals("零"))
443                     {
444                         chs = chs + tmp_chs[tab] + CH[tab - 7];
445 
446                         // 　当第１部分算完时在加上"万"
447                         if (tab == 8)
448                         {
449                             chs = chs + "亿";
450                         }
451 
452                     } else
453                     {
454                         // 当前数字为大小"零"时
455                         // 判断前一次形成在字符串结尾有没有零
456                         // 　如果没有零就加上零
457                         if (!chs.endsWith("零"))
458                         {
459                             chs = chs + tmp_chs[tab];
460 
461                         }
462 
463                         // 当第１部分算完时
464 
465                         if (tab == 8)
466                         {
467                             // 　先判断字符串有没有零
468                             // 　如果有零时就把零去掉再加上"万"
469                             if (chs.endsWith("零"))
470                             {
471                                 chs = chs.substring(0, chs.length() - 1);
472                                 if (!chs.endsWith("兆"))
473                                     chs = chs + "亿";
474                             } else
475                             {
476                                 // 　如果没有零就直接加上"万"
477                                 if (!chs.endsWith("兆"))
478                                     chs = chs + "亿";
479                             }
480                         }
481                     }
482                 }
483                 // 如：123,1234分成两部分
484                 // 第１部分123：万以上亿以下
485                 if (tab >= 4 && tab < 8)
486                 {
487                     // 当前数字不是大小零时
488                     if (!tmp_chs[tab].equals("零"))
489                     {
490                         chs = chs + tmp_chs[tab] + CH[tab - 3];
491 
492                         // 　当第１部分算完时在加上"万"
493                         if (tab == 4)
494                         {
495                             chs = chs + "万";
496                         }
497 
498                     } else
499                     {
500                         // 当前数字为大小"零"时
501                         // 判断前一次形成在字符串结尾有没有零
502                         // 　如果没有零就加上零
503                         if (!chs.endsWith("零"))
504                         {
505                             chs = chs + tmp_chs[tab];
506 
507                         }
508 
509                         // 当第１部分算完时
510 
511                         if (tab == 4)
512                         {
513                             // 　先判断字符串有没有零
514                             // 　如果有零时就把零去掉再加上"万"
515                             if (chs.endsWith("零"))
516                             {
517                                 chs = chs.substring(0, chs.length() - 1);
518 
519                                 if (!chs.endsWith("兆"))
520 
521                                     if (!chs.endsWith("亿"))
522 
523                                         chs = chs + "万";
524                             } else
525                             {
526                                 // 　如果没有零就直接加上"万"
527                                 if (!chs.endsWith("兆"))
528 
529                                     if (!chs.endsWith("亿"))
530                                         chs = chs + "万";
531                             }
532                         }
533                     }
534                 }
535 
536                 // 如：123,1234分成两部分
537                 // 第１部分1234：万以下
538                 if (tab < 4)
539                 {
540 
541                     if (!tmp_chs[tab].equals("零"))
542                     {
543 
544                         // tmp_int_char.length - i 为数字所在的位数
545                         chs = chs + tmp_chs[tab] + CH[tmp_int_char.length - i];
546                     } else
547                     {// 当数字中有零时就在后加上零，如果超过１个以上的零也只加一个零
548                         if (!chs.endsWith("零") && tab != 0)
549                         {
550                             chs = chs + tmp_chs[tab];
551 
552                         }
553 
554                         if (chs.endsWith("零") && tab == 0)
555                         {
556                             chs = chs.substring(0, chs.length() - 1);
557                         }
558                     }
559                 }
560             }
561         }
562 
563         if (tmp_down != null)
564         {
565             char[] tmp = tmp_down.toCharArray();
566 
567             if (tmp.length == 1)
568             {
569                 if (tmp[0] != '0')
570                     chs = chs + "元" + CHS_NUMBER[(int) Float.parseFloat(tmp[0] + ".0")] + "角整";
571                 else
572                     chs = chs + "元整";
573             } else
574             {
575                 if (tmp[1] != '0' && tmp[0] != '0')
576                 {
577                     chs = chs + "元" + CHS_NUMBER[(int) Float.parseFloat(tmp[0] + ".0")] + "角"
578                             + CHS_NUMBER[(int) Float.parseFloat(tmp[1] + ".0")] + "分";
579                 } else if (tmp[1] != '0' && tmp[0] == '0')
580                 {
581                     chs = chs + "元零" + CHS_NUMBER[(int) Float.parseFloat(tmp[1] + ".0")] + "分";
582                 }
583             }
584 
585         } else
586         {
587             chs = chs + "元整";
588         }
589 
590         return chs;
591     }
592     
593     public static void main(String[] args)
594     {
595         String m = "6136347.42";
596         System.out.println(ChinaNumber.getCHSNumber(m));
597         m = "641295403.34";
598         System.out.println(ChinaNumber.getCHSNumber(m));
599     }
600 }
相关阅读:
按钮组件如何处理点击事件（将原生事件绑定到自定义组件）
一个简单的transition动画
 根据路由记录（利用matched）动态生成面包屑导航
 assets和static的异同
 Ceph集群概念以及部署
 腾讯质量效能提升最佳实践：智能自动化测试探索和建设
 腾讯WeTest压测大师通过中国计量科学研究院测试认证，获国家级权威认可
 新办公司每年费用
 2
Leetcode刷题第三题无重复字符的最长子串
原文地址：https://www.cnblogs.com/XiaoGer/p/2683103.html