zoukankan      html  css  js  c++  java
  • 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                 {// 当数字中有零时就在后加上零,如果超过1个以上的零也只加一个零
     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             //  如果数字的位数大于5和小于9时
     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                 // 第1部分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                         //  当第1部分算完时在加上"万"
     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                         // 当第1部分算完时
     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                 // 第1部分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                     {// 当数字中有零时就在后加上零,如果超过1个以上的零也只加一个零
    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             //  如果数字的位数大于5和小于9时
    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                         //  当第1部分算完时在加上"万"
    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                         // 当第1部分算完时
    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                 // 第1部分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                         //  当第1部分算完时在加上"万"
    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                         // 当第1部分算完时
    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                 // 第1部分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                     {// 当数字中有零时就在后加上零,如果超过1个以上的零也只加一个零
    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                         //  当第1部分算完时在加上"万"
    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                         // 当第1部分算完时
    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                         //  当第1部分算完时在加上"万"
    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                         // 当第1部分算完时
    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                 // 第1部分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                         //  当第1部分算完时在加上"万"
    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                         // 当第1部分算完时
    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                 // 第1部分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                     {// 当数字中有零时就在后加上零,如果超过1个以上的零也只加一个零
    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                     //  当第1部分算完时在加上"万"
    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                         //  当第1部分算完时在加上"万"
    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                         // 当第1部分算完时
    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                 // 第1部分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                         //  当第1部分算完时在加上"万"
    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                         // 当第1部分算完时
    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                 // 第1部分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                     {// 当数字中有零时就在后加上零,如果超过1个以上的零也只加一个零
    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 }
  • 相关阅读:
    MYSQL 注射精华
    MySQL数据库安全配置
    linux命令
    python异常处理、反射、socket
    random、面向对象编程
    序列化、常用模块以及面向对象基础
    python 装饰器、递归原理、模块导入方式
    python递归、collections系列以及文件操作进阶
    python基础
    python简介
  • 原文地址:https://www.cnblogs.com/XiaoGer/p/2683103.html
Copyright © 2011-2022 走看看