人民币大小写转换算法

更新时间：2024-03-27 16:07:01 阅读量：综合文库文档下载

说明：文章内容仅供预览，部分内容可能不全。下载后的文档，内容与下面显示的完全一致。下载之前请确认下面内容是否您想要的，是否完整无缺。

人民币大小写转换算法

1.先把你的金额转换成Chat String类型;

2.把Chat Strin类型的金额变量已小数点为界分成两个部分; 3.分别用两个转换函数对小数点左右部分进行转换 AnsiString ChineseNumber(AnsiString num) \\ {

num.Delete(num.Length()-2,1);//删除小数点

num.Insert(num.StringOfChar('0',8-num.Length()),1);

AnsiString retval="",CNum="零壹贰叁肆伍陆柒捌玖",CUnit="拾万仟佰拾元角分"; for(int p,i=1;i<9;i++) {

p=num.SubString(i,1).ToInt();

retval+=CNum.SubString(p*2+1,2)+CUnit.SubString(i*2-1,2); }

return retval; 例2

1.先把你的金额转换成Chat String类型;

2.把Chat Strin类型的金额变量已小数点为界分成两个部分; 3.分别用两个转换函数对小数点左右部分进行转换

AnsiString ChineseNumber(AnsiString num) {

num.Delete(num.Length()-2,1);//删除小数点

num.Insert(num.StringOfChar('0',8-num.Length()),1);

AnsiString retval="",CNum="零壹贰叁肆伍陆柒捌玖",CUnit="拾万仟佰拾元角分";

for(int p,i=1;i<9;i++) {

p=num.SubString(i,1).ToInt();

retval+=CNum.SubString(p*2+1,2)+CUnit.SubString(i*2-1,2); }

return retval;

例3 金额大小写转换 FUNCTION UPPERRMB PARAMETER RMB

PRIVATE UNIT, NUMBER, I, RETVAR

UNIT = '分角圆拾佰仟万拾佰仟亿拾佰仟万拾佰仟' NUMBER = '零壹贰叁肆伍陆柒捌玖' RMB = INT(RMB*100+0.5) RETVAR = '' DO WHILE RMB>0

RETVAR = SUBSTR(NUMBER,2*(MOD(RMB,10))+1,2)+LEFT(UNIT,2)+RETVAR RMB = INT(RMB/10) UNIT = SUBSTR(UNIT,3) ENDDO

RETVAR = STRTRAN(RETVAR,'零仟','零') RETVAR = STRTRAN(RETVAR,'零佰','零') RETVAR = STRTRAN(RETVAR,'零拾','零') RETVAR = STRTRAN(RETVAR,'零角','零') DO WHILE '零零'$RETVAR

RETVAR = STRTRAN(RETVAR,'零零','零') ENDDO

RETVAR = STRTRAN(RETVAR,'零亿','亿') RETVAR = STRTRAN(RETVAR,'零万','万') RETVAR = STRTRAN(RETVAR,'亿万','亿零') RETVAR = STRTRAN(RETVAR,'零零','零') RETVAR = STRTRAN(RETVAR,'零圆','圆') RETVAR = STRTRAN(RETVAR,'零分','整') RETVAR = IIF(LEN(RETVAR)=0,'零圆整',RETVAR) RETURN RETVAR 例4

//改编 inRm inrm@263.net function NumToChar( n:Real): wideString; //可以到万亿,并可随便扩大

const cNum:WideString=‘零壹贰叁肆伍陆柒捌玖-万仟佰拾亿仟佰拾万仟佰拾元角分‘; cCha:array[0..1, 0..11]of string = (( ‘零仟‘,‘零佰‘,‘零拾‘,‘零零零‘,‘零零‘, ‘零亿‘,‘零万‘,‘零元‘,‘亿万‘,‘零角‘,‘零分‘

,‘零整‘), ( ‘零‘,‘零‘,‘零‘,‘零‘,‘零‘,‘亿‘,‘万‘,‘元‘,‘亿‘,‘零‘,‘整‘,‘整‘)); var i :Integer;

sNum :WideString; begin result := ‘‘; sNum := FormatFloat(‘0‘,n*100); for i := 1 to Length(sNum) do result := result + cNum[ord(sNum[i])-47] + cNum[26-Length(s Num)+i];

for i:= 0 to 11 do //去掉多余的零

result := StringReplace(result, cCha[0,i], cCha[1,i], [rfReplaceAll]); end;

例5. JAVA算法

package amountchange;

import java.math.BigDecimal;

import org.omg.CORBA.TRANSIENT; public class AmountChange2RMB {

private static String bigLetter[] = { "零", "壹", "贰", "叁", "肆", "伍", "陆",

"柒", "捌", "玖" }; private static String unit[] = { "元", "拾", "佰", "仟", "万", "拾", "佰", "仟", "亿", "拾", "佰", "仟", "万" };

private static String unitSmall[] = { "分", "角" }; public static void main(String[] args) {

String[] testStrs = { "1234567888888.100"/* 大十进制数 */,

"1001"/* 没有小数，且含相邻的两个零 */, "101005.1"/*零在单位所处的位置*/, "1010"/*零在元位*/ }; System.out.println(new BigDecimal(testStrs[2]).toString()); System.out.println(trans(testStrs[2])); }

public static String trans(String str) { BigDecimal dec = check2BigDecimal(str); if (dec == null) return null;

str = dec.toPlainString();

String[] sArr = str.split("\\\\."); String intOnly = sArr[0];

String smallOnly = ""; if (sArr.length == 2) smallOnly = sArr[1];

if (smallOnly.length() > 2) {

smallOnly = smallOnly.substring(0, 2); }

return transInt(intOnly) + transSmall(smallOnly); }

public static String transInt(String str) { if ("0".equals(str)) return "";

StringBuffer newS = new StringBuffer(); char[] cArr = str.toCharArray();

for (int i = 0; i < cArr.length; i++) { String u = unit[cArr.length - i - 1];

int position = "元万亿".indexOf(u);

// 遇到零，特殊处理

if (cArr[i] == '0') {

// 如果零在特殊位置上：比如个位，万位，亿位 if (position >= 0) {

// 如果零在个位：需要加上单位“元” if (position == 0) {

newS.append(unit[cArr.length - i - 1]); continue;

} else {// 如果零不在个位

// 零不在个位，且这个位后，紧跟着一个零：只需要加上单位 if (i < cArr.length - 1 && cArr[i + 1] == '0') { newS.append(unit[cArr.length - i - 1]); continue; }

else {// 零不在

个

位，且这个位后，没有紧跟着一个零：需要加上单位和大写数字(注意次序：单位在前，大写数字在后)

newS.append(unit[cArr.length - i - 1]); newS.append(bigLetter[cArr[i] - 48]); continue; } } }

else {// 零不在特殊位置上

// 零不在特殊位置上，且这个位后，紧跟着一个零：忽略这个零

if (i < cArr.length - 1 && cArr[i + 1] == '0') { continue; } // 零不在特殊位置上，且这个位后，没有紧跟着一个零：需要加上大写数字 newS.append(bigLetter[cArr[i] - 48]); continue; } }

// 不是零，常规处理

newS.append(bigLetter[cArr[i] - 48]); newS.append(unit[cArr.length - i - 1]); }

return newS.toString(); }

public static String transSmall(String str) {

//因为最多精确到分，所有str的长度最多位2 if (str == null || "".equals(str))

return "";

char[] cArr = str.toCharArray();

if (str.indexOf("0") == -1) {//不含有零，常规处理 StringBuffer newS = new StringBuffer(); for (int i = 0; i < cArr.length; i++) { newS.append(bigLetter[cArr[i] - 48]);

newS.append(unitSmall[cArr.length - i - 1]); }

return newS.toString(); }

else {//含有零，分情况考虑

if (cArr[0] == '0' && cArr[cArr.length == 2 ? 1 : 0] == '0') //两个都为零 return "";

if (cArr[0] == '0' && cArr.length == 2 && cArr[1] != '0')

//角位为零，分位不为零

return bigLetter[0] + bigLetter[cArr[1] - 48] + unitSmall[0];

if (cArr[0] != '0' && cArr.length == 2 && cArr[1] == '0')

//分位为零，角位不为零

return bigLetter[cArr[0] - 48] + unitSmall[1]; }

return ""; }

public static BigDecimal check2BigDecimal(String str) { try {

double f = Double.valueOf(str);// 0.0 0.1 -5 "" if (f < 0)

System.out.println("输入数据小于0，请检查！"); return new BigDecimal(f); }

catch (NumberFormatException e) { e.printStackTrace(); }

return null; } }

public class NumToChinese {

public static String NumberToChinese(String input){ String s1="零壹贰叁肆伍陆柒捌玖";

String s4="分角整元拾佰仟万拾佰仟亿拾佰仟"; String temp="";

String result="";

if (input==null) return "输入的字串不是数字串只能包括以下字符（'0'~'9','.'),输入字串最大只能精确到仟亿，小数点只能两位！"; temp=input.trim(); float f; try{

f=Float.parseFloat(temp); }catch(Exception e){

return "输入的字串不是数字串只能包括以下字符（'0'~&#

39;9

','.'),输入字串最大只能精确到仟亿，小数点只能两位！"; }

int len=0;

if(temp.indexOf(".")==-1) len=temp.length(); else len=temp.indexOf( ".");

if(len>s4.length()-3) return("输入字串最大只能精确到仟亿，小数点只能两位！"); int n1=0;

String num=""; String unit="";

for(int i=0;i<temp.length();i++){ if(i>len+2){break;} if(i==len) {continue;}

n1=Integer.parseInt(String.valueOf(temp.charAt(i))); num=s1.substring(n1,n1+1); n1=len-i+2;

unit=s4.substring(n1,n1+1);

result=result.concat(num).concat(unit); }

if((len==temp.length())||(len==temp.length()-1)) result=result.concat("整"); if(len==temp.length()-2) result=result.concat("零分"); return result; } }

例6 JAVA算法

public class NumToChinese {

public static String NumberToChinese(String input){ String s1="零壹贰叁肆伍陆柒捌玖";

String s4="分角整元拾佰仟万拾佰仟亿拾佰仟";

String temp=""; String result="";

if (input==null) return "输入的字串不是数字串只能包括以下字符（'0'~'9','.'),输入字串最大只能精确到仟亿，小数点只能两位！"; temp=input.trim(); float f; try{

f=Float.parseFloat(temp); }catch(Exception e){

return "输入的字串不是数字串只能包括以下字符（'0'~'9','.'),输入字串最大只能精确到仟亿，小数点只能两位！"; }

int len=0;

if(temp.indexOf(".")==-1) len=temp.length(); else len=temp.indexOf(".");

if(len>s4.length()-3) return("输入字串最大只能精确到仟亿，小数点只能两位！"); int n1=0;

String num=""; String unit="";

for(int i=0;i<temp.length();i++){ if(i>len+2){break;} if(i==len) {continue;}

n1=Integer.parseInt(String.valueOf(temp.charAt(i))); num=s1.substring(n1,n1+1); n1=len-i+2;

unit=s4.substring(n1,n1+1);

result=result.concat(num).concat(unit); }

if((len==temp.length())||(len==temp.length()-1)) result=result.concat("整"); if(len==temp.length()-2) result=result.concat("零分"); return result; } } 例7

import java.text.DecimalFormat; public class helloworld {

public static void main(String[] args) { // TODO 自动生成方法存根

double inputvalue = 1234567890123.312030; if(inputvalue == 0) {

System.out.print( "零 ");

return; }

String stringvalue,sintvalue,sdecvalue;

DecimalFormat ss = new DecimalFormat( "0.00 "); stringvalue = ss.format(inputvalue); int decbit;

decbit = stringvalue.indexOf( ". "); if(decbit == 0){

sintvalue = stringvalue; sdecvalue

= " "; }

else{

sintvalue = stringvalue.substring(0,decbit);

sdecvalue = stringvalue.substring(decbit + 1); }

String chesenumunit[] = { " ", "壹 ", "贰 ", "叁 ", "肆 ", "伍 ", "陆 ", "柒 ", "捌 ", "玖 "};

helloworld hwtochn = new helloworld(); //处理整数

String schar,sreversed,schnintvalue= " ",schndecvalue= " "; int ibit;

StringBuffer s=new StringBuffer(sintvalue); sreversed = s.reverse().toString();

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

schar = sreversed.substring(i, i+1); ibit = Integer.parseInt(schar);

schnintvalue = chesenumunit[ibit] + hwtochn.GetUnit(i) +schnintvalue; }

//清除多余的单位

String slist = "拾佰仟万亿 "; for(int i= schnintvalue.length()-1;i> =0;i--) {

schar = schnintvalue.substring(i, i+1); if(slist.indexOf(schar)> =0) {

for(int j = i-1;j> =0;j--)

{

String shighchar;

shighchar = schnintvalue.substring(j, j+1); if(slist.indexOf(shighchar) <0) {

break; }

else if(slist.indexOf(shighchar,slist.indexOf(schar)+1)> =0) {

schnintvalue = schnintvalue.substring(0,i)+schnintvalue.substring(i+1); break;

} } } }

schnintvalue = schnintvalue + "圆 "; //处理小数

ibit = Integer.parseInt(sdecvalue.substring(0,1)); if (ibit > 0)

schndecvalue = chesenumunit[ibit] + "角 "; ibit = Integer.parseInt(sdecvalue.substring(1,2)); if (ibit > 0)

schndecvalue = schndecvalue + chesenumunit[ibit] + "分 "; String schnnum;

schnnum = schnintvalue + schndecvalue+ "整 "; System.out.print(stringvalue+schnnum); }

public String GetUnit(int num) { //取单位非零数字按位数取单位 int level;

level = num%4; switch(level) {

case 0: if(num == 0) return " "; else if(num%8 == 0) return "亿 ";

else return "万 "; case 1: return "拾 "; case 2: return "佰 "; case 3: return "仟 "; default: return " "; } } }

例8 jsp页面调用applet实现人民币的大小写转换实现方法一

applet实现页面是rmb.jsp，此页面是通过applet来实现人民币小写转换成大写的。此页面有三个变量需要在载入classes的时候进行初始化：

<applet type="applet" id="myApplet" codebase = "." name="TestApplet"

align="middle" code="lqh.rmb.Applicate.Rmb.class" width="560" height="25">

<param name="RGB_Back" value="241|247|251" > &

lt;param name="RGB_Fore" value="255|0|0"/> <param name="WIGTH" value="560"/> </applet>

变量RGB_Back是初始化背景色的，修改次变量可以使applet的背景色跟自己页面的风格一样；变量RGB_Fore是初始化字体的颜色; WIGTH要和applet的宽度一样，这个变量是保证显示的转换信息在中间显示。

此种方法不能传递值给页面trans.jsp，只能显示并且不能copy。页面代码如下： <html>

<head>人民币小写转换成大写</head>

<%@ page contenttype="text/html;charset=gb2312" %> <SCRIPT language=JavaScript> function trans(){ //取变量的值

var aaa=document.rmb. rmb_test.value; //给applet赋变量的值 document.myApplet.set RMB(aaa);

document.myApplet.repaint(); return true; }

</SCRIPT>

<body>

输入金额：<input type=”text” name=”rmb_test” onkeyup=”trans()”><br><hr>

<%@ include file="../rmb.jsp" %> </form> </body> </html> 实现方法二

applet实现页面是rmb.jsp，此页面是通过applet来实现人民币小写转换成大写的。此页面不需要变量进行初始化，在页面上不显示applet画的图像;而可以把转换的值传递给页面变量：

<applet type="applet" id="myApplet" codebase = "."

name="TestApplet"

align="middle" code="lqh.rmb.Applicate.Rmb.class" width="0" height="0"> </applet>

页面trans.jsp代码如下： <html>

<head>人民币小写转换成大写</head>

<%@ page contenttype="text/html;charset=gb2312" %> <%@ include file="../rmb.jsp" %> <SCRIPT language=JavaScript> function trans(){

var aaa=document.rmb. rmb_test.value; //得到转换的值

var rmb = document.myApplet.getRMB(aaa); document.rmb. rmb_result.value = rmb; return true; }

</SCRIPT> <body>

<form name="rmb"> 输入金额：<input type=”text” name=”rmb_test” onkeyup=”trans()”><br> 转换结果：<input type=”text” name=”rmb_result” ><br> </form> </body> </html> 附录

1．applet代码：

package lqh.rmb.Applicate; import java.awt.*;

import java.awt.event.*; import java.applet.*; import lqh.rmb.*;

public class Rmb extends Applet { private boolean isStandalone = false;

private RMBConversion rmb=new RMBConversion(); private String var0 = ""; private String re_rmb=""; private String wigth ="0"; private String back_color; private String fore_color;

public String getParameter(String key, String def) { return isStandalone ? System.getProperty(key, def) : (getParameter(ke

y) != null ? getParameter(key) : def); }

public void paint(Graphics g) { if(wigth.equals("0")){ wigth = "560"; }

int i= Integer.parseInt(wigth); if(checkNum(var0)){

if(var0.endsWith(".")){

var0 = var0.substring(0,var0.length()-1); }

re_rmb= rmb.RMB(var0); }else{

re_rmb="输入错误："+var0; }

int middel =(i - re_rmb.length()*12)/2; this.setBackground(new Color(getColor(back_color)[0], getColor(back_color)[1], getColor(back_color)[2])); this.setForeground(new Color(getColor(fore_color)[0], getColor(fore_color)[1], getColor(fore_color)[2]));

g.drawString(re_rmb,middel,20); }

public void init() { try {

back_color = this.getParameter("RGB_Back", "241|247|251"); }catch(Exception e) {e.printStackTrace();} try {

fore_color = this.getParameter("RGB_Fore", "255|0|0"); }catch(Exception e) {e.printStackTrace();} try {

wigth = this.getParameter("WIGTH", "0"); }catch(Exception e) {e.printStackTrace();} try { jbInit();

}catch(Exception e) { e.printStackTrace(); } } priv

ate void jbInit() throws Exception { this.setBackground(new Color(getColor(back_color)[0], getColor(back_color)[1], getColor(back_color)[2]));

}

public void setRMB(String rmb_temp){ var0 = rmb_temp; }

public String getRMB(String rmb_temp){ if(checkNum(rmb_temp)){

if(rmb_temp.endsWith(".")){

rmb_temp = rmb_temp.substring(0,rmb_temp.length()-1); }

re_rmb= rmb.RMB(rmb_temp); }else{

re_rmb="输入错误："+rmb_temp; }

return re_rmb; }

public boolean checkNum(String str){

String numChar="0123456789."; boolean breakBoolean = false; for(int i=0;i<str.length();i++){

if(numChar.indexOf(str.substring(i,i+1))<0){ breakBoolean =true; }

if(breakBoolean) break; }

if(breakBoolean){ return false; } else{

if(str.startsWith(".")){ return false; } else{

return true; } } }

public String[][] getParameterInfo() { String[][] pinfo = {

{"RGB_Back", "String", ""}, {"RGB_Fore", "String", ""}, {"WIGTH", "String", ""}, };

return pinfo;

}

private int[] getColor(String rgb){ int[] rgb_return = new int[3]; int index =0,nextIndex=0,len=0;

while((index =rgb.indexOf("|",nextIndex))>-1){ rgb_return[len]=getInt(rgb.substring(nextIndex,index)); nextIndex=index+1; len++; }

rgb_return[len]=getInt(rgb.substring(nextIndex)); return rgb_return; }

private int getInt(String str){ try{

return Integer.parseInt(str); }catch(Exception e){ return 0; } } } 例9

import java.math.BigDecimal; import java.text.DecimalFormat; import java.text.NumberFormat; import java.util.ArrayList; import java.util.HashMap; import java.util.List;

public class SimpleMoneyFormat { static boolean ISIGNORE = false; // 参数用来设置是否忽略

错误，true为忽略错误，默认为false

static List digits = new ArrayList(); static List setDigits = new ArrayList(); static {

digits.add("拾");// 0:拾 digits.add("佰");// 1:佰 digits.add("仟");// 2:仟 digits.add("萬");// ,3:萬 digits.add("拾");// 4:拾萬 digits.add("佰");// ,5:佰萬 digits.add("仟");// 6:仟萬 digits.add("亿");// ,7:亿

digits.add("拾");// 8:拾亿 digits.add("佰");// ,9:佰亿 digits.add("仟");// 10:仟亿 digits.add("兆");// 11:兆 digits.add("拾");// 12:拾兆 digits.add("佰");// ,13:佰兆 digits.add("仟");// 仟兆 // digits.add("京"); //.

// digits.add("拾");//12:拾京 // digits.add("佰");//,13:佰京 // digits.add("仟");//??? // .....

setDigits.add("萬"); setDigits.add("亿"); setDigits.add("兆"); // setDigits.add("京"); // // .....

// 百度搜索：个、十、百、千、万、十万、百万、千万、亿、兆（10的12次方）、京〔10的16次方）、垓、秭、穰、沟、涧、正、载、极（10的48次方）、恒河沙、阿僧示氏、（梵文译音、意思是无量）、那由他、不可思议（10的64次方）、无量数（∞）。 }

public String run(double moneyDb) throws Exception {

java.text.DecimalFormat fmt = new java.text.DecimalFormat(".00"); String moneyStr = fmt.format(moneyDb); if (moneyDb == 0) {

return "零圆整"; }

return ConvertData(moneyStr); }

// 转换RMB函数

String ConvertData(String moneyParam) throws Exception {

System.out.println("=====try to fmt:" + moneyParam); StringBuffer returnValue = new StringBuffer();

String[] strMoneys = java.util.regex.Pattern.compile("\\\\.").split( moneyParam);

int len = strMoneys[0].length();

if (strMoneys[0].startsWith("-")) { returnValue.append("负"); len--; }

strMoneys[0] = strMoneys[0].replaceFirst("-", ""); // 判断可不可以转

if (len > digits.size() + 1) {

if (this.ISIGNORE) { return moneyParam; }

throw new Exception("函数：RMB出错：数字太大或太小，无法换算."); }

// 转整数

for (int i = 0; i < strMoneys[0].length(); i++) {

String value = strMoneys[0].charAt(i) + "";

returnValue.append(Convert1Digit(value, strMoneys[0].length() - 2 - i)); }

String tmp = returnValue.toString(); // linlin..

java.util.regex.Pattern p = java.util.regex.Pattern.compile(".*零零.*");// ("零零 |零萬 |零亿");

java.util.regex.Matcher m = p.matcher(tmp); while (m.find()) {

tmp = tmp.replaceAll("零零", "零"); m = p.matcher(tmp); }

// lindigits

String preDigitsName = "", digitsName; for (int i = 0; i < setDigits.size(); i++) { digitsName = (String) setDigits.get(i);

tmp = tmp.replaceAll("零" + digitsName, digitsName); }

if (!setDigits.isEmpty()) {

preDigitsName = (String) setDigits.get(0); }

for (int i = 1; i < setDigits.size(); i++) {// tmp =

// tmp.replaceAll("亿萬","亿零"); digitsName = (String) setDigits.get(i);

if (tmp.matches(".*" + digitsName.concat(preDigitsName) + ".*")) { tmp = tmp.replaceAll(digitsName.concat(preDigitsName), digitsName);

if (digitsName != "" && !(digitsName.equals(""))) { tmp = tmp.replaceAll(digitsName, digitsName + "零"); tmp = tmp.replaceAll("零零", "零"); // System.out.println("===138");

} }

例10小写金额转成大写算法我用C++写过一个,代码不在身边.

不过可以提示一下,将金额4位一分,比如1234567可以拆分为1234和567.另外,数字中间有零的话必须写零,但要注意多个零的情况.详细的怎么写你可以问问做财务的人. 我以前写过说一下思路

先把数字分成整数小数

假如整数100909应该是十万零九百零九有数组

一个：零，一，二，三，四，五，六，七，八，九一个：元，角，分，厘

一个：元，十，百，千，万，十，百，千，亿然后依次去取就可以了 100909 上面会拼出

一十零零九百零九元

你碰到万位补万，两个零变成一个有

个比较笨点的：

判断每个字符,然后条件if(c.equals("1")){.....} 依此类推。。。。

从CSDN上整理出五个方案，请参考： 1、（JAVA）

public static String numtochinese(String input){ String s1="零壹贰叁肆伍陆柒捌玖";

String s4="分角整元拾佰仟万拾佰仟亿拾佰仟"; String temp=""; String result="";

if (input==null) return "输入字串不是数字串只能包括以下字符（′0′～′9′，′.′)，输入字串最大只能精确到仟亿，小数点只能两位！"; temp=input.trim(); float f; try{

f=Float.parseFloat(temp);

}catch(Exception e){return "输入字串不是数字串只能包括以下字符（′0′～′9′，′.′)，输入字串最大只能精确到仟亿，小数点只能两位！";} int len=0;

if (temp.indexOf(".")==-1) len=temp.length(); else len=temp.indexOf(".");

if(len>s4.length()-3) return("输入字串最大只能精确到仟亿，小数点只能两位！"); int n1,n2=0;

String num=""; String unit="";

for(int i=0;i<temp.length();i++){ if(i>len+2){break;} if(i==len) {continue;}

n1=Integer.parseInt(String.valueOf(temp.charAt(i))); num=s1

.substring(n1,n1+1) ;

n1=len-i+2;

unit=s4.substring(n1,n1+1);

result=result.concat(num).concat(unit); }

if ((len==temp.length()) | |(len==temp.length()-1)) result=result.concat("整"); if (len==temp.length()-2) result=result.concat("零分"); return result; } 2、（JSP） <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=gb2312"> <meta name="GENERATOR" content="Microsoft FrontPage 4.0">

INPUT { BORDER-RIGHT: #c0d3dc 1px solid; BORDER-TOP: #c0d3dc 1px solid; BORDER-LEFT: #c0d3dc 1px solid; BORDER-BOTTOM: #c0d3dc 1px solid; font-family: verdana; HEIGHT: 19px}

BODY {font-family:arial,helvetica,Tahoma; font-size: 9pt; color:′094A82′} </STYLE>

<SCRIPT LANGUAGE="VBScript"> dim hj,hji

sub document_onkeypress() if window.event.srcelement.id="num" and window.event.keycode="13" then call retu_cn()

end if end sub

sub window_onload()

document.fmSubmit.t1.focus() end sub

SUB retu_cn()

dim n,m_hj,s,ch,ch2,ch3,num

num=Replace(trim(document.fmSubmit.t1.value),",","",1,-1,1) if num="" then

MsgBox "您还没有输入金额！" document.fmSubmit.t1.focus() exit sub End If

if IsNumeric(num)=False then

MsgBox "您输入的不是金额！" document.fmSubmit.t1.focus() exit sub End If

n=FormatNumber(num,2,-1) num=n

n=Replace(n,",","",1,-1,1) If len(n)>15 Then

MsgBox "金额必须小于千亿！" document.fmSubmit.t1.focus() exit sub End If

hj=space(0)

s="840"

ch="壹贰叁肆伍陆柒捌玖" ch2="仟佰拾 " ch3="亿万元" for x=1 to 3

m=cstr(int(n/10^FormatNumber(mid(s,x,1),0,-1))) m=space(4 -len(m))+m m_hj=space(0)

if m<>" 0" then for y=1 to 4

if mid(m,y,1)<>space(1) and mid(m,y,1)<>"0" then m_hj=trim(m_hj+mid(ch,FormatNumber(mid(m,y,1),0,-1),1)+mid(ch2,y,1)) else

if mid(m,y,1)=space(1) or mid(m,y,1)="0" then m_hj=m_hj

if right(m_hj,1)="零" then

m_hj=m_hj+space(0) else

m_hj=m_hj+"零" end if else

m_hj=m_hj end if end if next

if right(m_hj,1)="零" then

m_hj=mid(m_hj,1,len(m_hj)-1)+mid(ch3,x,1) if x=3 then

m_hj=m_hj+space(0) else

m_hj=m_hj+"零" end if else

m_hj=m_hj+mid(ch3,x,1) end if

if right(hj,1)="零" and mid(m_hj,1,1)="零" then hj=hj+mid(m_hj,2,len(m_hj)-1) else

hj=hj+m_hj end if else

if x=3 then if rig

ht(hj,1)="零&qu ot; then

if trim(hj)="零" then hj=hj+space(0) else

hj=mid(hj,1,len(hj)-1)+"元" end if else

if trim(hj)="零" then hj=hj+space(0) else

hj=hj+"元" end if end if

else

if right(hj,1)="零" then hj=hj+space(0) else

hj=hj+"零" end if end if end if

if n-int(n)=0 then

n=n-int(FormatNumber(m,0,-1))*10^int(FormatNumber(mid(s,x,1),0,-1)) else

tt=FormatNumber("0."+mid(cstr(n),Instr(1,n,".")+1,2),2) n=int(n)

n=n-int(FormatNumber(m,0,-1))*10^int(FormatNumber(mid(s,x,1),0,-1)) n=n+tt end if next

m=mid(cstr(n),2,2)

if trim(len(m))<>2 then m=m+"0" end if

if n*100=0 then

if left(hj,1)="零" then if right(hj,1)="零" then hj=hj+"元整" else

hj=mid(hj,2,len(hj)-1)+"整" end if else

if right(hj,1)="零" then hj=mid(hj,1,len(hj)-1)+"整" else

hj=hj+"整" end if end if else

if right(hj,1)="零" then hj=mid(hj,1,len(hj)-1) else hj=hj end if

if mid(m,1,1)="0" or mid(m,1,1)=space(1) then hj=hj+"零" else

hj=hj+mid(ch,FormatNumber(mid(m,1,1),0,-1),1)+"角" end if

if mid(hj,1,1)="零" then hj=mid(hj,2,len(hj)-1) else hj=hj end if

if mid(m,2,1)="0" then hj=hj+"整" else

hj=hj+mid(ch,FormatNumber(mid(m,2,1),0,-1),1)+"分" end if end if

if num=".00" then

document.fmSubmit.t1.value="0.00" else

document.fmSubmit.t1.value=num end if

document.fmSubmit.t2.value="" hji=1

call read() End Sub SUB read()

MyVar=mid(hj,hji,1)

document.fmSubmit.t2.value=document.fmSubmit.t2.value+MyVar Select Case MyVar Case "零" document.all("bgsoundone").src="http://go.163.com/yjsj/wav/0.wav" Case "壹" document.all("bgsoundone").src="http://go.163.com/yjsj/wav/1.wav" Case "贰" document.all("bgsoundone").src="http://go.163.com/yjsj/wav/2.wav" Case "叁" document.all("bgsoundone").src="http://go.163.com/yjsj/wav/3.wav" Case "肆" document.all("bgsoundone").src="http://go.163.com/yjsj/wav/4.wav" Case "伍" document.all("bgsoundone").src="http://go.163.com/yjsj/wav/5.wav"

Case "陆" document.all("bgsoundone").src="http://go.163.com/yjsj/wav/6.wav" Case "柒" document.all("bgsoundone").src="http://go.163.com/yjsj/wav/7.wav" Case "捌" document.all("bgsoundone").src="http://go.163.com/yjsj/wav/8.wav"

Case "玖" document

.all("bgsoundone").src="http://go.163.com/yjsj/wav/9.wav"

Case "拾" docu

ment.all("bgsoundone").src="http://go.163.com/yjsj/wav/10.wav" Case "佰" document.all("bgsoundone").src="http://go.163.com/yjsj/wav/b.wav"

Case "仟" document.all("bgsoundone").src 例11

public class NumberToChinese {

private static final String[] hanzi = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};

private static String fourToHanZi(String digit) { int value = 0; int exponent = 0;

boolean hasZero = false;

StringBuffer chineseDigit = new StringBuffer(); value = Integer.parseInt(digit);

for(exponent = 4; exponent>=0; exponent--) {

String[] unit = {"", "拾", "佰", "仟"}; int divisor = (int)Math.pow(10, exponent); int result = value / divisor; if(result != 0) {

chineseDigit.append(hanzi[result]); chineseDigit.append(unit[exponent]); hasZero = false;

} else if(result == 0 && !hasZero) { chineseDigit.append(hanzi[0]); hasZero = true; }

else { }

value = value % divisor; }

if(chineseDigit.substring(0,1).equals("零")) { return chineseDigit.deleteCharAt(0).toString(); } else{ return chineseDigit.toString(); } }

public static String fourToHanZiBig(String digit) {

String[] unit = {"圆", "万", "亿"}; String chineseDigitWan = new String(); //存储万位数字 String chineseDigitYi = new String(); //存储亿位数字 StringBuffer chineseDigit = new StringBuffer(); if(digit.length() <= 5 ) { return fourToHanZi(digit); }

else{

if(digit.length() <= 8 ) { chineseDigitWan = digit.substring(0,digit.length() - 4 ); chineseDigit.append(fourToHanZi(chineseDigitWan)+unit[1]+fourToHanZi(digit.substring(digit.length() - 4,digit.length()))); } else {

chineseDigitYi = digit.substring(0,digit.length() - 8 ); chineseDigit.append(fourToHanZi(chineseDigitYi)+unit[2]+fourToHanZi(digit.substring(digit.length()-8,digit.length() - 4))+unit[1]+fourToHanZi(digit.substring(digit.length() - 4,digit.length()))+unit[0]); } }

return chineseDigit.toString(); }

public static void main(String args[]) {

System.out.println(fourToHanZiBig("19814834802")); } } 例12

Java实现数字金额到中文大写字符的转换

最近用到了数值转成大写人民币的功能，在网上找了一下只有C＋＋版的，好容易找到一个java版的竟然收费！！没办法就自己弄一个出来，想必用到该功能的人肯定少，就拿出来与大家共享！！ * *类名：money

* *函数：String PositiveIntegerToHanStr(String NumStr) 负责小数点前面的数转换为大写中文

* *函数:?String NumToRMBStr(double val) 负责把输入的double型的数转换为

大写中文

* *注意java程序转换的范围是：小数点前面15位（已测试通过），C＋＋程序是24位（我没有测试） import java.lang.Math; public class money{ //调试时用m ain函数

public static void main(String args[]){ money mon=new money(); System.out.println(-99999999999999.999+mon.NumToRMBStr(-99999999999999.999)); System.out.println(99999999999999.999+mon.NumToRMBStr(99999999999999.999)); System.out.println(mon.NumToRMBStr(100000000.00)); System.out.println(mon.NumToRMBStr(100000001.00)); }

String HanDigiStr[] = new String[]{"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};

String HanDiviStr[] = new String[]{"","拾","佰","仟","万","拾","佰","仟","亿","拾","佰","仟","万","拾","佰","仟","亿","拾","佰","仟","万","拾","佰","仟" };

String PositiveIntegerToHanStr(String NumStr) {

// 输入字符串必须正整数，只允许前导空格(必须右对齐)，不宜有前导零 String RMBStr = ""; boolean lastzero = false;

boolean hasvalue= false; // 亿、万进位前有数值标记 int len,n;

len = NumStr.length();

if( len > 15 ) return "数值过大!"; for(int i=len-1;i>=0;i--) {

if( NumStr.charAt(len-i-1)==' ' ) continue; n = NumStr.charAt(len-i-1) - '0'; if( n<0 || n>9 )

return "输入含非数字字符!"; if( n!=0 ) {

if( lastzero ) RMBStr += HanDigiStr[0]; // 若干零后若跟非零值，只显示一个零 // 除了亿万前的零不带到后面

//if( !( n==1 && (i%4)==1 && (lastzero || i==len-1) ) )

// 如十进位前有零也不发壹音用此行

if( !( n==1 && (i%4)==1 && i==len-1 ) ) // 十进位处于第一位不发壹音 RMBStr += HanDigiStr[n];

RMBStr += HanDiviStr[i]; // 非零值后加进位，个位为空

hasvalue = true; // 置万进位前有值标记 }else {

if( (i%8)==0 || ((i%8)==4 && hasvalue) ) // 亿万之间必须有非零值方显示万 RMBStr += HanDiviStr[i]; // “亿”或“万” }

if( i%8==0 ) hasvalue = false ; // 万进位前有值标记逢亿复位

lastzero = (n==0) && (i%4!=0); }

if( RMBStr.length()==0 ) return HanDigiStr[0]; // 输入空字符或"0"，返回"零" return RMBStr; }

String NumToRMBStr(double val) {

String SignStr ="" ; String TailStr =""; long fraction, integer; int jiao,fen;

if( val<0 ) { val = -val;

SignStr = "负"; }

if(val > 99999999

999999.999 || val <-99999999999999.999 ) return "数值位数过大!"; // 四舍五入到分

long temp = Math.round(val*100); integer = temp/100; fraction = temp0; jiao = (int)fraction/10;

fen = (int)fraction;

if( jiao==0 && fen==0 ) { TailStr = "整"; } else {

TailStr = HanDigiStr[jiao]; if( jiao!=0 )

TailStr += "角";

if( integer==0 && jiao==0 ) // 零元后不写零几分 TailStr = ""; if( fen!=0 )

TailStr += HanDigiStr[fen] + "分"; }

// 下一行可用于非正规金融场合，0.0 3只显示“叁分”而不是“零元叁分”

// if( !integer ) return SignStr+TailStr;

return "￥"+SignStr+PositiveIntegerToHanStr(String.valueOf(integer) )+"元"+TailStr; } }

//END public class money

#include <vcl.h> // must define AnsiString before rmb.h #pragma hdrstop // only for C++ Builder #include <math.h>

#include "rmb.h"

// 常量字符串定义，如修改也可变为转换普通汉字函数（如：一二三，十百千）

const char *HanDigiStr[] = {"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};

const char *HanDiviStr[] = { "","拾","佰","仟","万","拾","佰","仟","亿",

"拾","佰","仟","万","拾","佰","仟","亿",

"拾","佰","仟","万","拾","佰","仟" };

AnsiString PositiveIntegerToHanStr(const AnsiString &NumStr) {

// 输入字符串必须正整数，只允许前导空格(必须右对齐)，不宜有前导零 AnsiString RMBStr; int len,n,lastzero=0; int hasvalue=0;

// 亿、万进位前有数值标记

len = NumStr.Length();

if( len > 24 ) return "数值过大!"; for(int i=len-1;i>=0;i--) {

if( NumStr[len-i]==' ' ) continue; // AnsiString[] base is 1

n = NumStr[len-i] - '0';

if( n<0 || n>9 ) return "输入含非数字字符!"; if( n!=0 ) {

if( lastzero ) RMBStr += HanDigiStr[0]; // 若干零后若跟非零值，只显示一个零 // 除了亿万前的零不带到后面

// if( !( n==1 && (i%4)==1 && (lastzero || i==len-1) ) ) // 如十进位前有零也不发壹音用此行

// if( !( n==1 && (i%4)==1 && i==len-1 ) ) // 十进位处于第一位不发壹音 RMBStr += HanDigiStr[n]; RMBStr += HanDiviStr[i];

// 非零值后加进位，个位为空

hasvalue = 1; // 置万进位前有值标

记 } else {

if( (i%8)==0 || ((i%8)==4 && hasvalue) ) // 亿万之间必

须有非零值方显示万 RMBStr += HanDiviStr[i]; // “亿”或“万” }

if( i%8==0 ) hasvalue = 0; // 万进位前有值标记逢亿复位

lastzero = (n==0) && (i%4!=0); // 亿万前有零后不加零，如：拾万贰仟 }

if( RMBStr.Length()==0 ) return HanDigiStr[0]; // 输入空字符或"0"，返回"零" return RMBStr; }

AnsiString NumToRMBStr(double val) {

AnsiString SignStr,TailStr;

double fraction, integer; int jiao,fen; if( val<0 ) { val = -val;

SignStr = "负"; }

fraction = modf(val+0.005, &integer); // 四舍五入到分 jiao = int(fraction*10);

fen = int(fraction*100)-jiao*10; if( jiao==0 && fen==0 ) { TailStr = "整"; } else {

TailStr = HanDigiStr[jiao]; if( jiao!=0 )

TailStr += "角";

if( integer==0 && jiao==0 ) // 零元后不写零几分 TailStr = ""; if( fen!=0 )

TailStr += HanDigiStr[fen] + AnsiString("分"); }

// 下一行可用于非

正规金融场合，0.03只显示“叁分”而不是“零元叁分” // if( integer==0 ) return SignStr+TailStr;

return SignStr+PositiveIntegerToHanStr( AnsiString(integer) )+"元"+TailStr; }

//下面是rmb.h #ifndef rmbH #define rmbH

// for AnsiString def // #include <vcl.h> // 数值转大写人民币函数

AnsiString NumToRMBStr(double val);

// 正整数字符串转汉字函数，不建议单独使用

// 输入字符串必须正整数，只允许前导空格(必须右对齐)，不宜有前导零 // AnsiString PositiveIntegerToHanStr(const AnsiString &NumStr); #endif

// 基本考虑

// 人民币大写单位银行规定用“元” // 无零头金额后跟“整”，有则不跟 // 角为零时不写角（如：零叁分） // 四舍五入到分

// 为减少判读疑惑（一般对大写金额预期较高）和

// 体现人民币基本单位为元，金额低于壹圆前仍加“零元” // 整数转换

// 若干零后若跟非零值，只显示一个零，否则不显示 // 万(亿)前有零后不加零，因亿、万为一完整单位， // （如：拾万贰仟比拾万零贰仟更顺些）

// 亿为汉语计数最大单位，只要进位到总是显示（如：壹亿亿） // 万为次最大单位，亿万之间必须有非零值方显示万 // （如“壹亿”不可显示为“壹亿万”） //

// 为减少被窜改的可能性，十进位总发壹音，这和下面的习惯读法不一样 // （十进位处于第一位不发壹音，如“拾元”非“壹拾元”， // 十进位处前有零是否不发壹音不太确定， // 如“叁仟零壹拾元”还是“叁仟零拾元”？） // 用“拾万”不用“壹拾万”，因为每个整数进位后都

有进位单位（拾佰仟万亿） // 这样即使金额前没有附防窜改的前缀如“人民币”字样也难窜改些

// 因为至少要加添两个汉字并且改动后数字必须进位才能窜改成 // （如“拾万”可改成“叁拾万”，而“壹拾万”至少要改成“壹佰壹拾万”） // 此函数为Borland C++ Builder编写，已充分考虑到跨平台兼容性 // 如需转换到其它场合，

// 只需修改字符串类型从AnsiString到对应的类型、功能及函数 // （注意两个char*型字符串不可以直接相加，需有一个先转换） // public domain freeware by 例13

* 程序目的：

* 从命令行接收一个数，并将其转化为中文金额的大写方式 * 例如 123.45 --> 壹佰贰拾叁元肆角伍分 * @author LovinChan *

* 看到网上有很多这样的例子程序，不过觉得很不满意。有些程序我从命名上就觉得 * 实在是不符合规范，程序里面的算法没有让人明白得很清楚的注释，读上去觉得有 * 点难度，可读性不强。而且很多程序还存在不少bug，随便一测就测出来了。 * 所以本人还是决定重新写一下这个程序，并且尽量做到消除不必要的bug。这个程 * 序我没有用什么很精妙的算法，不过用了一些Java类库中的类，像是正则表达式之类 * 的东西。由于本人对算法不怎么在行，在做转换操作的时候用的是很笨的方法。望各位

* 大虾海涵，呵呵。 *

* 程序的注释我尽量写得详细一点，如果觉得这个程序哪里有问题或者是哪里有改进的

* 地方欢迎随时跟我交流。

* 我的msn:egg.chenlw@gmail.com

* QQ:372133556(注上为什么加我就可以了) * 我的blog:http://hi.http://www.wodefanwen.com//egg_chen * 欢迎交流 */

public class Trans2RMB {

public static void main(String[] args) {

System.out.println("\\n--------将数字转换成中文金额的大写形式------------\\n"); Trans2RMB t2r = new Trans2RMB();

String s = t2r.cleanZero(t2r.splitNum(t2r.roundString(t2r.getNum()))); // 如果转换过后是一个空串，则不输出屏幕 if(!"".equals(s)) {

System.out.println("转换成中文后为：" + s);; }

System.out.println("\\n---------------------------------------------"); }

/**

* 从命令行接收一个数，在其中调用 checkNum() 方法对其进行 * 验证，并返回相应的值

* @return 如果输入合法，返回输入的这个数 */

private String getNum() { String s = null;

System.out.println("请输入一个数字（精确到小数点后两位）："); // 从命令行输入这个浮点数

java.util.Scanner scanner = new java.util.Scanner(System.in); s = scanner.next(); // 关闭这个Scanner scanner.close(); //

判断用户输入是否合法 // 若合法，返回这个值；若非法返回 "0 "

if(this.checkNum(s)) { return s; } else {

return "";

} }

/**

* 判断用户输入的数据是否合法，用户只能输入大于零的数字，不能输入其它字符 * @param s String

* @return 如果用户输入数据合法，返回 true，否则返回 false */

private boolean checkNum(String s) {

// 如果用户输入的数里有非数字字符，则视为非法数据，返回 false try {

float f = Float.valueOf(s);

// 如果这个数小于零则视为非法数据，返回 false if(f < 0) {

System.out.println("非法数据，请检查！"); return false; }else {

return true; }

} catch (NumberFormatException e) {

System.out.println("非法数据，请检查！"); return false; } }

/**

* 把用户输入的数以小数点为界分割开来，并调用 numFormat() 方法 * 进行相应的中文金额大写形式的转换

* 注：传入的这个数应该是经过 roundString() 方法进行了四舍五入操作的 * @param s String

* @return 转换好的中文金额大写形式的字符串 */

private String splitNum(String s) {

// 如果传入的是空串则继续返回空串 if("".equals(s)) { return ""; }

// 以小数点为界分割这个字符串 int index = s.indexOf("."); // 截取并转换这个数的整数部分 String intOnly = s.substring(0, index);

String part1 = this.numFormat(1, intOnly); // 截取并转换这个数的小数部分

String smallOnly = s.substring(index + 1); String part2 = this.numFormat(2, smallOnly);

// 把转换好了的整数部分和小数部分重新拼凑一个新的字符串 String newS = part1 + part2; return newS; }

/**

* 对传入的数进行四舍五入操作

* @param s String 从命令行输入的那个数 * @return 四舍五入后的新值 */

private String roundString(String s) { // 如果传入的是空串则继续返回空串 if("".equals(s)) { return ""; }

// 将这个数转换成 double 类型，并对其进行四舍五入操作 double d = Double.parseDouble(s); // 此操作作用在小数点后两位上 d = (d * 100 + 0.5) / 100; // 将 d 进行格式化

s = new java.text.DecimalFormat("##0.000").format(d); // 以小数点为界分割这个字符串 int index = s.indexOf("."); // 这个数的整数部分

String intOnly = s.substring(0, index);

// 规定数值的最大长度只能到万亿单位，否则返回 "0" if(intOnly.length() > 13) {

System.out.println("输入数据过大！（整数部分最多13位！）"); return ""; }

// 这个数的小数部分

String smallOnly = s.substring(index + 1); // 如

果小数部分大于两位，只截取小数点后两位 if(smallOnly.length() > 2) {

String roundSmall = smallOnly.substring(0, 2);

// 把整数部分和新截取的小数部分重新拼凑这个字符串 s = intOnly + "." + roundSmall;

}

return s; }

/**

* 把传入的数转换为中文金额大写形式

* @param flag int 标志位，1 表示转换整数部分，0 表示转换小数部分 * @param s String 要转换的字符串 * @return 转换好的带单位的中文金额大写形式 */

private String numFormat(int flag, String s) { int sLength = s.length(); // 货币大写形式

String bigLetter[] = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"}; // 货币单位

String unit[] = {"元", "拾", "佰", "仟", "万",

// 拾万位到仟万位

"拾", "佰", "仟", // 亿位到万亿位

"亿", "拾", "佰", "仟", "万"}; String small[] = {"分", "角"}; // 用来存放转换后的新字符串 String newS = ""; // 逐位替换为中文大写形式 for(int i = 0; i < sLength; i ++) { if(flag == 1) {

// 转换整数部分为中文大写形式（带单位）

newS = newS + bigLetter[s.charAt(i) - 48] + unit[sLength - i - 1]; } else if(flag == 2) {

// 转换小数部分（带单位）

newS = newS + bigLetter[s.charAt(i) - 48] + small[sLength - i - 1]; } }

return newS; }

/**

* 把已经转换好的中文金额大写形式加以改进，清理这个字 * 符串里面多余的零，让这个字符串变得更加可观

* 注：传入的这个数应该是经过 splitNum() 方法进行处理，这个字

* 符串应该已经是用中文金额大写形式表示的 * @param s String 已经转换好的字符串 * @return 改进后的字符串 */

private String cleanZero(String s) {

// 如果传入的是空串则继续返回空串 if("".equals(s)) { return ""; }

// 如果用户开始输入了很多 0 去掉字符串前面多余的'零'，使其看上去更符合习惯

while(s.charAt(0) == '零') {

// 将字符串中的 "零" 和它对应的单位去掉 s = s.substring(2);

// 如果用户当初输入的时候只输入了 0，则只返回一个 "零" if(s.length() == 0) {

return "零"; } }

// 字符串中存在多个'零'在一起的时候只读出一个'零'，并省略多余的单位

/* 由于本人对算法的

研究太菜了，只能用4个正则表达式去转换了，各位大虾别介意哈... */

String regex1[] = {"零仟", "零佰", "零拾"}; String regex2[] = {"零亿", "零万", "零元"}; String regex3[] = {"亿", "万", "元"}; String regex4[] = {"零角", "零分"};

// 第一轮转换把 "零仟", 零佰","零拾"等字符串替换成一个"零"

for(int i = 0; i < 3; i ++) {

s = s.replaceAll(regex1[i], "零"); }

// 第二轮转换考虑 "零亿","零万","零元"等情况 // "亿","万","元"这些单位有些情况是不能省的，需要保留下来 for(

int i = 0; i < 3; i ++) {

// 当第一轮转换过后有可能有很多个零叠在一起 // 要把很多个重复的零变成一个零

s = s.replaceAll("零零零", "零"); s = s.replaceAll("零零", "零"); s = s.replaceAll(regex2[i], regex3[i]); }

// 第三轮转换把"零角","零分"字符串省略 for(int i = 0; i < 2; i ++) {

s = s.replaceAll(regex4[i], ""); }

// 当"万"到"亿"之间全部是"零"的时候，忽略"亿万"单位，只保留一个"亿"

s = s.replaceAll("亿万", "亿"); return s; } }

例14 你的人民币金额大写数字规范吗

我们在编程的过程中，特别是开发和财务相关的应用程序的时候，几乎都会遇到要将阿拉伯数字(一般是货币金额)转换为中文大写的要求。也有一些转换程序，但大都不符合财务实际要求，比如最简单的： function xd(xx:currency):string; var dx,ws:string; i,cd:integer; int:currency; begin

int:=trunc((abs(xx)+0.005)*100); {在“厘”上4舍5入后去掉小数点} cd:=length(currtostr(int));

{取得数字的长度，跟据此长度即可判断位数} dx:='零壹贰叁肆伍陆柒捌玖';

ws:='分角元拾佰仟万拾佰仟亿拾佰仟'; {位数}

Result:= ' '; i:=1;

while i<=cd do begin

Result:=Result+copy(dx,strtoint(copy(currtostr(int),i,1))*2+1,2); {取数字的大写}

Result:=Result+copy(ws,(cd-i)*2+1,2); {加上数字的位数} i:=i+1; end end

在这里输入xd(1234567.89)，返回“壹佰贰拾叁万肆仟伍佰陆拾柒元捌角玖分”，但它并不完美，例如xd(100)，返回的却是：壹佰零拾零元零角零分（应是壹佰元整），显然这不符合财务工作的实

际要求。

中文大写的特殊性关键在对“0”的处理上，我们编程的

思路也是如此，程序中遇到0的时候并不能简单地用大写“零”来代替，要进行如下判断：是否是第一个零（即它的左边是否不为零）？如是第一个零，还要判断，它的后面是否全为零（这要分段判断：亿以上，万以上亿以下，元以上万以下，分以上元以下）？如不是，才能以大写零来代替；如果是就直接写上位数如万（例如：100000，就应是壹拾万，而不是壹拾零万）。另一方面如果它的后面不全为零，却有连续的零，也要注意（例如：1001，就应是壹仟零壹元，而不是壹仟零零壹元）。

以下就是根据这一思路给出的程序（此程序最大可转换至千亿位，在实际工作中也应该足够了）：

while i<=cd do begin

if copy(currtostr(int),i,1)<> '0' then begin

Result:=Result+copy(dx,st rtoint(copy(currtostr(int),i,1))*2+1,2);

Result:=Result+copy(ws,(cd-i)*2+1,2); ling:=false; i:=i+1; end

else if ling=false and (copy(currtostr(int),i,1)= '0' ) then {遇到第一个0} begin

if cd-i+1>10 then {判断是否是亿以上} begin w:=0;

for q:=11 to cd-i+1 do begin

w:=w+strtoint(copy(currtostr(int),cd-q+1,1)); end ; if w=0 then

{整亿，即亿位有0或连续的0} begin

Result:=Result+'亿'; i:=cd-9; end else

{非整亿，即亿位无0} begin