`

java编写的金额转中文大写（转）

    博客分类：
  • java
java
阅读更多
package com.itcast;

public class Test
{

     private static String[] CH = { "", "", "拾", "佰", "仟", "万", "", "", "", "亿", "", "", "", "兆" };
    
     private static String[] CHS_NUMBER={"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};
    
     /**
      * 传入数字金额字符串，返回数字金额对应的中文大字与读法
      *
      * @param money
      *            金额字符串
      * @return 金额中文大写
      */
     public static String getCHSNumber(String money)
     {
         String chs = "";

         String tmp_int = money.substring(0, money.indexOf("."));
         String tmp_down = money.substring(money.indexOf(".") + 1, money.length());

         char[] tmp_int_char = tmp_int.toCharArray();
         String[] tmp_chs = new String[tmp_int_char.length];

         int tab = 0;
         for (int i = 0; i < tmp_int_char.length; i++)
         {

             tab = tmp_int_char.length - i - 1;

             if (tmp_int_char.length <= 5)
             {
                 tmp_chs[tab] = CHS_NUMBER[(int) Float.parseFloat(tmp_int_char[i] + ".0")];

                 if (!tmp_chs[tab].equals("零"))
                 {

                     // tmp_int_char.length - i 为数字所在的位数
                     chs = chs + tmp_chs[tab] + CH[tmp_int_char.length - i];
                 } else
                 {// 当数字中有零时就在后加上零，如果超过１个以上的零也只加一个零
                     if (!chs.endsWith("零") && tab != 0)
                     {
                         chs = chs + tmp_chs[tab];

                     } else if (chs.endsWith("零") && tab == 0)
                     {
                         chs = chs.substring(0, chs.length() - 1);
                     }

                 }
             }

             // 　如果数字的位数大于５和小于９时
             if (tmp_int_char.length > 5 && tmp_int_char.length < 9)
             {
                 tmp_chs[tab] = CHS_NUMBER[(int) Float.parseFloat(tmp_int_char[i] + ".0")];

                 // 如：123,1234分成两部分
                 // 第１部分123：万以上亿以下
                 if (tab >= 4)
                 {
                     // 当前数字不是大小零时
                     if (!tmp_chs[tab].equals("零"))
                     {
                         chs = chs + tmp_chs[tab] + CH[tab - 3];

                         // 　当第１部分算完时在加上"万"
                         if (tab == 4)
                         {
                             chs = chs + "万";
                         }

                     } else
                     {
                         // 当前数字为大小"零"时
                         // 判断前一次形成在字符串结尾有没有零
                         // 　如果没有零就加上零
                         if (!chs.endsWith("零"))
                         {
                             chs = chs + tmp_chs[tab];

                         }

                         // 当第１部分算完时

                         if (tab == 4)
                         {
                             // 　先判断字符串有没有零
                             // 　如果有零时就把零去掉再加上"万"
                             if (chs.endsWith("零"))
                             {
                                 chs = chs.substring(0, chs.length() - 1);
                                 chs = chs + "万";
                             } else
                             {
                                 // 　如果没有零就直接加上"万"
                                 chs = chs + "万";
                             }
                         }
                     }
                 }

                 // 如：123,1234分成两部分
                 // 第１部分1234：万以下
                 if (tab < 4)
                 {

                     if (!tmp_chs[tab].equals("零"))
                     {

                         // tmp_int_char.length - i 为数字所在的位数
                         chs = chs + tmp_chs[tab] + CH[tmp_int_char.length - i];
                     } else
                     {// 当数字中有零时就在后加上零，如果超过１个以上的零也只加一个零
                         if (!chs.endsWith("零") && tab != 0)
                         {
                             chs = chs + tmp_chs[tab];

                         }

                         if (chs.endsWith("零") && tab == 0)
                         {
                             chs = chs.substring(0, chs.length() - 1);
                         }
                     }
                 }
             }

             // 　如果数字的位数大于9和小于12时
             if (tmp_int_char.length >= 9 && tmp_int_char.length <= 12)
             {
                 tmp_chs[tab] = CHS_NUMBER[(int) Float.parseFloat(tmp_int_char[i] + ".0")];

                 if (tab >= 8 && tab < 12)
                 {
                     // 当前数字不是大小零时
                     if (!tmp_chs[tab].equals("零"))
                     {
                         chs = chs + tmp_chs[tab] + CH[tab - 7];

                         // 　当第１部分算完时在加上"万"
                         if (tab ==
                         {
                             chs = chs + "亿";
                         }

                     } else
                     {
                         // 当前数字为大小"零"时
                         // 判断前一次形成在字符串结尾有没有零
                         // 　如果没有零就加上零
                         if (!chs.endsWith("零"))
                         {
                             chs = chs + tmp_chs[tab];

                         }

                         // 当第１部分算完时

                         if (tab ==
                         {
                             // 　先判断字符串有没有零
                             // 　如果有零时就把零去掉再加上"万"
                             if (chs.endsWith("零"))
                             {
                                 chs = chs.substring(0, chs.length() - 1);
                                 chs = chs + "亿";
                             } else
                             {
                                 // 　如果没有零就直接加上"万"
                                 chs = chs + "亿";
                             }
                         }
                     }
                 }
                 // 如：123,1234分成两部分
                 // 第１部分123：万以上亿以下
                 if (tab >= 4 && tab <
                 {
                     // 当前数字不是大小零时
                     if (!tmp_chs[tab].equals("零"))
                     {
                         chs = chs + tmp_chs[tab] + CH[tab - 3];

                         // 　当第１部分算完时在加上"万"
                         if (tab == 4)
                         {
                             chs = chs + "万";
                         }

                     } else
                     {
                         // 当前数字为大小"零"时
                         // 判断前一次形成在字符串结尾有没有零
                         // 　如果没有零就加上零
                         if (!chs.endsWith("零"))
                         {
                             chs = chs + tmp_chs[tab];

                         }

                         // 当第１部分算完时

                         if (tab == 4)
                         {
                             // 　先判断字符串有没有零
                             // 　如果有零时就把零去掉再加上"万"
                             if (chs.endsWith("零"))
                             {
                                 chs = chs.substring(0, chs.length() - 1);

                                 if (!chs.endsWith("亿"))
                                     chs = chs + "万";
                             } else
                             {
                                 // 　如果没有零就直接加上"万"
                                 if (!chs.endsWith("亿"))
                                     chs = chs + "万";
                             }
                         }
                     }
                 }

                 // 如：123,1234分成两部分
                 // 第１部分1234：万以下
                 if (tab < 4)
                 {

                     if (!tmp_chs[tab].equals("零"))
                     {

                         // tmp_int_char.length - i 为数字所在的位数
                         chs = chs + tmp_chs[tab] + CH[tmp_int_char.length - i];
                     } else
                     {// 当数字中有零时就在后加上零，如果超过１个以上的零也只加一个零
                         if (!chs.endsWith("零") && tab != 0)
                         {
                             chs = chs + tmp_chs[tab];

                         }

                         if (chs.endsWith("零") && tab == 0)
                         {
                             chs = chs.substring(0, chs.length() - 1);
                         }
                     }
                 }
             }

             // 　如果数字的位数大于12和小于16时
             if (tmp_int_char.length > 12 && tmp_int_char.length <= 16)
             {
                 tmp_chs[tab] = CHS_NUMBER[(int) Float.parseFloat(tmp_int_char[i] + ".0")];

                 if (tab >= 12 && tab < 16)
                 {
                     // 当前数字不是大小零时
                     if (!tmp_chs[tab].equals("零"))
                     {
                         chs = chs + tmp_chs[tab] + CH[tab - 11];

                         // 　当第１部分算完时在加上"万"
                         if (tab == 12)
                         {
                             chs = chs + "兆";
                         }

                     } else
                     {
                         // 当前数字为大小"零"时
                         // 判断前一次形成在字符串结尾有没有零
                         // 　如果没有零就加上零
                         if (!chs.endsWith("零"))
                         {
                             chs = chs + tmp_chs[tab];

                         }

                         // 当第１部分算完时

                         if (tab == 12)
                         {
                             // 　先判断字符串有没有零
                             // 　如果有零时就把零去掉再加上"万"
                             if (chs.endsWith("零"))
                             {
                                 chs = chs.substring(0, chs.length() - 1);
                                 chs = chs + "兆";
                             } else
                             {
                                 // 　如果没有零就直接加上"万"
                                 chs = chs + "兆";
                             }
                         }
                     }
                 }

                 if (tab >= 8 && tab < 12)
                 {
                     // 当前数字不是大小零时
                     if (!tmp_chs[tab].equals("零"))
                     {
                         chs = chs + tmp_chs[tab] + CH[tab - 7];

                         // 　当第１部分算完时在加上"万"
                         if (tab ==
                         {
                             chs = chs + "亿";
                         }

                     } else
                     {
                         // 当前数字为大小"零"时
                         // 判断前一次形成在字符串结尾有没有零
                         // 　如果没有零就加上零
                         if (!chs.endsWith("零"))
                         {
                             chs = chs + tmp_chs[tab];

                         }

                         // 当第１部分算完时

                         if (tab ==
                         {
                             // 　先判断字符串有没有零
                             // 　如果有零时就把零去掉再加上"万"
                             if (chs.endsWith("零"))
                             {
                                 chs = chs.substring(0, chs.length() - 1);
                                 if (!chs.endsWith("兆"))
                                     chs = chs + "亿";
                             } else
                             {
                                 // 　如果没有零就直接加上"万"
                                 if (!chs.endsWith("兆"))
                                     chs = chs + "亿";
                             }
                         }
                     }
                 }
                 // 如：123,1234分成两部分
                 // 第１部分123：万以上亿以下
                 if (tab >= 4 && tab <
                 {
                     // 当前数字不是大小零时
                     if (!tmp_chs[tab].equals("零"))
                     {
                         chs = chs + tmp_chs[tab] + CH[tab - 3];

                         // 　当第１部分算完时在加上"万"
                         if (tab == 4)
                         {
                             chs = chs + "万";
                         }

                     } else
                     {
                         // 当前数字为大小"零"时
                         // 判断前一次形成在字符串结尾有没有零
                         // 　如果没有零就加上零
                         if (!chs.endsWith("零"))
                         {
                             chs = chs + tmp_chs[tab];

                         }

                         // 当第１部分算完时

                         if (tab == 4)
                         {
                             // 　先判断字符串有没有零
                             // 　如果有零时就把零去掉再加上"万"
                             if (chs.endsWith("零"))
                             {
                                 chs = chs.substring(0, chs.length() - 1);

                                 if (!chs.endsWith("亿"))
                                     if (!chs.endsWith("兆"))
                                         if (!chs.endsWith("兆"))
                                             chs = chs + "万";
                             } else
                             {
                                 // 　如果没有零就直接加上"万"
                                 if (!chs.endsWith("亿"))
                                     if (!chs.endsWith("兆"))
                                         chs = chs + "万";
                             }
                         }
                     }
                 }

                 // 如：123,1234分成两部分
                 // 第１部分1234：万以下
                 if (tab < 4)
                 {

                     if (!tmp_chs[tab].equals("零"))
                     {

                         // tmp_int_char.length - i 为数字所在的位数
                         chs = chs + tmp_chs[tab] + CH[tmp_int_char.length - i];
                     } else
                     {// 当数字中有零时就在后加上零，如果超过１个以上的零也只加一个零
                         if (!chs.endsWith("零") && tab != 0)
                         {
                             chs = chs + tmp_chs[tab];

                         }

                         if (chs.endsWith("零") && tab == 0)
                         {
                             chs = chs.substring(0, chs.length() - 1);
                         }
                     }
                 }
             }

             // 　如果数字的位数大于16
             if (tmp_int_char.length > 16)
             {
                 tmp_chs[tab] = CHS_NUMBER[(int) Float.parseFloat(tmp_int_char[i] + ".0")];

                 if (tab >= 12)
                 {
                     chs = chs + tmp_chs[tab];

                     // 　当第１部分算完时在加上"万"
                     if (tab == 12)
                     {
                         chs = chs + "兆";
                     }

                 }

                 if (tab >= 8 && tab < 12)
                 {
                     // 当前数字不是大小零时
                     if (!tmp_chs[tab].equals("零"))
                     {
                         chs = chs + tmp_chs[tab] + CH[tab - 7];

                         // 　当第１部分算完时在加上"万"
                         if (tab ==
                         {
                             chs = chs + "亿";
                         }

                     } else
                     {
                         // 当前数字为大小"零"时
                         // 判断前一次形成在字符串结尾有没有零
                         // 　如果没有零就加上零
                         if (!chs.endsWith("零"))
                         {
                             chs = chs + tmp_chs[tab];

                         }

                         // 当第１部分算完时

                         if (tab ==
                         {
                             // 　先判断字符串有没有零
                             // 　如果有零时就把零去掉再加上"万"
                             if (chs.endsWith("零"))
                             {
                                 chs = chs.substring(0, chs.length() - 1);
                                 if (!chs.endsWith("兆"))
                                     chs = chs + "亿";
                             } else
                             {
                                 // 　如果没有零就直接加上"万"
                                 if (!chs.endsWith("兆"))
                                     chs = chs + "亿";
                             }
                         }
                     }
                 }
                 // 如：123,1234分成两部分
                 // 第１部分123：万以上亿以下
                 if (tab >= 4 && tab <
                 {
                     // 当前数字不是大小零时
                     if (!tmp_chs[tab].equals("零"))
                     {
                         chs = chs + tmp_chs[tab] + CH[tab - 3];

                         // 　当第１部分算完时在加上"万"
                         if (tab == 4)
                         {
                             chs = chs + "万";
                         }

                     } else
                     {
                         // 当前数字为大小"零"时
                         // 判断前一次形成在字符串结尾有没有零
                         // 　如果没有零就加上零
                         if (!chs.endsWith("零"))
                         {
                             chs = chs + tmp_chs[tab];

                         }

                         // 当第１部分算完时

                         if (tab == 4)
                         {
                             // 　先判断字符串有没有零
                             // 　如果有零时就把零去掉再加上"万"
                             if (chs.endsWith("零"))
                             {
                                 chs = chs.substring(0, chs.length() - 1);

                                 if (!chs.endsWith("兆"))

                                     if (!chs.endsWith("亿"))

                                         chs = chs + "万";
                             } else
                             {
                                 // 　如果没有零就直接加上"万"
                                 if (!chs.endsWith("兆"))

                                     if (!chs.endsWith("亿"))
                                         chs = chs + "万";
                             }
                         }
                     }
                 }

                 // 如：123,1234分成两部分
                 // 第１部分1234：万以下
                 if (tab < 4)
                 {

                     if (!tmp_chs[tab].equals("零"))
                     {

                         // tmp_int_char.length - i 为数字所在的位数
                         chs = chs + tmp_chs[tab] + CH[tmp_int_char.length - i];
                     } else
                     {// 当数字中有零时就在后加上零，如果超过１个以上的零也只加一个零
                         if (!chs.endsWith("零") && tab != 0)
                         {
                             chs = chs + tmp_chs[tab];

                         }

                         if (chs.endsWith("零") && tab == 0)
                         {
                             chs = chs.substring(0, chs.length() - 1);
                         }
                     }
                 }
             }
         }

         if (tmp_down != null)
         {
             char[] tmp = tmp_down.toCharArray();

             if (tmp.length == 1)
             {
                 if (tmp[0] != '0')
                     chs = chs + "元" + CHS_NUMBER[(int) Float.parseFloat(tmp[0] + ".0")] + "角整";
                 else
                     chs = chs + "元整";
             } else
             {
                 if (tmp[1] != '0' && tmp[0] != '0')
                 {
                     chs = chs + "元" + CHS_NUMBER[(int) Float.parseFloat(tmp[0] + ".0")] + "角"
                             + CHS_NUMBER[(int) Float.parseFloat(tmp[1] + ".0")] + "分";
                 } else if (tmp[1] != '0' && tmp[0] == '0')
                 {
                     chs = chs + "元零" + CHS_NUMBER[(int) Float.parseFloat(tmp[1] + ".0")] + "分";
                 }
             }

         } else
         {
             chs = chs + "元整";
         }

         return chs;
     }
    
     public static void main(String[] args)
     {
         String m = "6136347.42";
         System.out.println(Test.getCHSNumber(m));
         m = "641295403.34";
         System.out.println(Test.getCHSNumber(m));
     }
}
分享到：
| ognl简单标签
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java 实现 金额转成中文大写形式

    在Java编程中，将金额的阿拉伯数字转换为中文汉字大写是常见的财务处理需求，主要用于防止数字篡改，增加财务数据的安全性和准确性。这个过程通常称为金额数字化，它涉及到将小数点、整数和小数部分分别转换，并且...

    将阿拉伯数字转换为金额的汉字大写

    本文将深入探讨如何使用Java来实现阿拉伯数字到金额汉字大写的转换。 首先，我们需要了解金额汉字大写的基本规则。在中国，金额的汉字大写有特定的规则，例如1到10的汉字大写分别是壹、贰、叁、肆、伍、陆、柒、捌...

    Java编程-金额小写转大写

    通过理解数字到大写汉字的映射规则，以及编写相应的转换函数，我们可以实现符合财务规范的金额显示。而`GetAmount.java`文件提供了一个实现这一功能的起点，开发者可以根据实际需求对其进行扩展和完善。

    Java将数字金额转为大写中文金额

    Java程序实现数字金额转为大写中文金额，是一项常见的编程任务，尤其在金融行业以及需要处理财务数据的软件中应用广泛。其核心功能是将阿拉伯数字表示的金额转换成中文大写形式，以满足财务凭证、支票、合同等文档中...

    Android中数字转中文，金额转大写

    本文将深入探讨如何在Android环境中实现这一功能，包括数字转中文以及数字金额转大写，并且会涉及到口语化的转换。 首先，数字转中文主要是将阿拉伯数字（如1、2、3等）转换成中文数字（如一、二、三等）。在Java或...

    小写金额转大写

    在IT行业中，编程语言Java是广泛使用的，尤其在金融、财务等领域，经常需要将小写的金额转换为大写的汉字表示，以满足规范的财务报告需求。这个“小写金额转大写”的主题就涉及到这样的一个功能实现。在这个压缩包...

    java阿拉伯数字转大写金额+大写金额转阿拉伯数字

    综上所述，Java中实现阿拉伯数字与大写金额之间的转换涉及到字符串处理、数字映射、金额单位识别等多个方面，需要理解转换规则并编写相应的处理逻辑。通过封装成函数或利用现有库，可以简化这部分的开发工作。

    金额中文大写转换

    用Java编写的金额中文大写转换系统，实现对输入的金额转换成中文大写，精确到分位，实现自动加零。

    java写的将阿拉伯数字转化为中文金额的大写方式

    在Java编程中，将阿拉伯数字转化为中文金额大写是一项常见的任务，特别是在财务系统或报表生成中。这个题目要求实现一个程序，能够读取输入的阿拉伯数字字符串，然后将其转换为符合中国会计规范的中文大写金额表示。...

    Ireport实现金额大写(自己实现的)

    通过这样的方式，我们利用Ireport的Scriptlet功能成功实现了自定义的金额大写转换。这种自定义逻辑不仅可以用于金额转换，还可以应用于其他复杂的数据处理，使报表更具灵活性和功能性。在实际的项目中，可以根据具体...

    js金额小写转大写脚本

    "js金额小写转大写脚本"指的是JavaScript编程语言中用于将小写的货币金额（阿拉伯数字）转换为大写的汉字数字的代码片段。这样的脚本有助于提高财务报表的可读性和规范性，因为在中国，正式的财务文档通常要求金额以...

    MYSQL金额转大写.7z

    本篇文章将深入探讨如何在MySQL中实现这个功能，特别是结合描述中的"字符串分割"和"金额转大写"这两个关键知识点。 首先，我们来讨论“字符串分割”操作。在MySQL中，可以使用内置的`SUBSTRING_INDEX()`函数来分割...

    Ireport实现金额大写.doc

    其中，实现金额大写是报表设计中的一项重要功能，它可以将数字金额转换为汉字大写形式。 在本文中，我们将详细介绍如何使用 iReport 实现金额大写，并提供了一个完整的示例来演示实现金额大写的步骤。 第一步：...

    数字金额转人民币大写金额

    总之，“数字金额转人民币大写金额”是一项重要的财务管理工具，涉及汉字与数字之间的转换规则，以及在编程中实现这些规则的逻辑。这样的工具在会计、银行和其他金融领域有着广泛的应用，确保了财务数据的安全性和...

    人民币小写转大写（Java 实现）

    //ChangeRMB.java /** * * programmed by HuangHeliang * 2009.04.15 10:20:51 * */ //package com.avtech.hhl; import java.io.*; public final class ChangeRMB { //每个数字对应的大写 private static ...

    基于java的人民币大写的转换

    1. **数字转大写**：创建一个字符串数组，存储每个数字对应的汉字大写形式，例如：`{"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"}`。然后通过数字的值作为索引来获取对应的大写字符。 2. **处理...

    ATM自动取款机&金额转换成大写

    在Java中，可以编写一个辅助方法，将数字转换为中文大写的表示，例如“壹”、“贰”等。这个过程可能涉及到字符串处理和数字比较，可以使用switch语句或者映射表来实现。 在开发ATM模拟程序时，我们还需要考虑以下...

    金钱大写转数字类型，精确到分

    在IT行业中，尤其是在编程领域，处理财务数据时经常会遇到将汉字大写金额转换为数字类型的需求。这主要是因为中国的财务规范要求金额在正式文件中必须用大写汉字表示，以防止篡改和增加清晰度。Java作为一种广泛使用...

    将数字转为中文金额的大写方式（Java版）

    "将数字转为中文金额的大写方式（Java版）"意味着我们要编写一个Java程序，它能接受一个数字输入，然后输出其对应的中文大写金额。中文大写金额的表示方式有其特定的规则，如数字1对应"壹"，2对应"贰"，以此类推，而...

    java 金额大小写转换器

    这个作业要求我们使用AWT（Abstract Window Toolkit）库来构建用户界面，并实现金额数字与大写汉字之间的相互转换功能。下面将详细介绍如何完成这个任务。 首先，我们需要了解AWT组件的基本用法。AWT是Java提供的...

Magicbox
Global site tag (gtag.js) - Google Analytics