java实战1——浮点数转人民币读法

来源：互联网发布：淘宝c店保证金编辑：程序博客网时间：2024/06/06 05:47

为了学习安卓，现在开始从C++角度来学习Java，现在看到了《疯狂java讲义》的第四章，里面有个字符串转人民币的例子，书上没做完，于是把其补充完善。其中最难的部分就是根据零在不同位置，具有不同行为。按照中文读法，有些零要读出，有些零不需要读出。下面将按照两部分进行讲解，首先举一个例子来说明思路，其次给出Java的源代码供参考，并且进行测试。这个问题主要利用字符串数组来解决。我们假定要转换的浮点数整数部分不超过12位。

(1) 思路

1.1 分割整数和小数部分

对于一个浮点数，先来看个简单点，不加零。比如12312341234.12。按照中文人民币的读法，四位一读，所以其应该读做“一百二十三亿一千二百三十四万一千二百三十四元一角二分”。首先将浮点数分为两个部分，整数部分(IntPart)和小数(FloatPart)部分。如何分割呢？就是将该浮点数直接强制取整得到整数部分，如： IntPart =(int)12312341234.12=12312341234，然后用原浮点数减去整数部分后再乘以100(因为中文读法最多为角分，为两位)，再进行强制转为整数。这样就得到了小数部分。如 12312341234.12-IntPart = 0.12，FloatPart =(int)(0.12*100) = 12。然后分别将小数部分(这时也是个整形)和整形部分在将其变为字符串，然后进行第二步，处理整数部分读法和小数部分读法。

1.2 整数部分转中文字符串

前面已经将浮点数分割为两个部分了，首先先处理整数部分转中文字符串。将字符串逐一变为汉字，首先要建立一个汉字库（利用数组实现）。可以这样 String[] ChineseArr ={“零”,”一”，”二”…}

然后通过逐一扫描整数字符串，将其映射到汉字数组中，也就是利用每个数字本身的算术值，进行索引数组，做映射。比如 1.其数字为1，那么就映射到汉字数组中ChineseArr[1]正好就是汉字“一“。然后将其加入到结果字符串中。对于单位的处理，也是利用一个单位数组来进行映射。String[] UnitArr ={“千”,”百”,”十”}。个位不需要单位。如何确保单位的正确匹配呢？这里就要按照整数部分 4位一划分：123 1234 1234。这样就分为3个部分，然后在逐一处理每个部分，每个部分的处理都可以抽象出来，写成一个子函数，这个函数专门用来处理4位数字变成汉字。比如123 1234 1234将其分为3个部分，”123“，”1234“，”1234“,然后分别调用同一个方法后，再进行扫尾处理。

比如“1234“如何变为汉字串呢？首先逐一扫描字符串，将该字符变为数字，然后映射到汉子数组和单位数组中。

下面为该函数的完整的实现：

[java] view plaincopyprint?

public String NumStr2ChineseStr_IntPartCore(String NumStr)
{
String rst = ""; //保存结果初始化为空
int len = NumStr.length(); //获取NumStr的长度
//补零操作
if(len < 4) //位数小于4位就前补位
{
String[] AddZeroStr = {"0","00","000"};
NumStr = AddZeroStr[4-len-1] + NumStr;
}
len = NumStr.length(); //更新长度其实 len==4
//扫描至第一个不为0的字符
int i=0;
while(i < len && NumStr.charAt(i)-'0'==0)
++i;
if(i==len) //四个数都为零，就直接输出一个零并返回
{
rst += "零";
return rst;
}
//四个数不都为0的情况
for(;i < len; ++i)
{
int num = NumStr.charAt(i) - '0';
if( i != len-1 && num != 0)//不是末尾且不为0
{
rst += ChineseArr[num] + UnitArr[i] ;//直接映射汉字和单位
}
else
{
//若当前结果字符串中最后一位不是“零”，且数字串最后一位不是数字0 这样对中间2个零的只添加一个“零”如1003
if( rst.length()>0 && rst.charAt(rst.length()-1) != '零' && NumStr.charAt(len-1)-'0'!= 0)
{ //四位中第二，三位至少有一个为0且最后一位数字不为0 如1003 则为一千零三
if((i==1||i==2) && num == 0)
rst += "零";
}
if( i== len - 1 && num !=0)//是最后一位，且数字不为0 不加单位
{
rst += ChineseArr[num];
}
}
}
return rst; //返回结果字符串
}

现在分析上述代码，该函数只处理4位的数字串，不足四位的补为4位进行处理。"1234","123",1023","1002","1000",”123”,”3”经过该函数后依次为“一千二百三十四”,"一百二十三"，“一千零二十三”，“一千零二”，“一千“，”一百二十三”,”三”。该函数的主要功能是将4位的数字串变为汉字串，函数从第一位不是0的字符开始扫描并映射，由于数字串最末位不单位，所以将4位的数字串分为两部分，前3位加单位，最后一位不加单位。而对于汉字的读法，对于4位数字串中中间两位可能为0的情况，又要加“零”。比如前面的例子中，“1002”，“1023”都读法中要加“零”。

所以将前3位处理的第一部分中，进行0的处理。详细实现见代码注释。但是通过该函数，只能将数字字符串化为可读的汉字串，而对于多部分的4位连接情况中的零则没有完成，比如一个数字串的整数部分为“12301230123”，则分解3部分后，“123”，“0123”，“0123”，在逐一经过上述函数后，变为“一百二十三”，“一百二十三“，”一百二十三“。必须在链接过程中，进行”亿“，”“万”，“元”单位的连接和零的连接。上述例子：最后应读成“一百二十三亿零一百二十三万零一百二十三元”。整数部分完整处理代码如下。

[java] view plaincopyprint?

/*将12位整数部分数字转为汉字字符串
*/
public String NumStr2ChineseStr_IntPart(String NumStr)
{
int len = NumStr.length(); //获取字符串总长度
int partNum = (len%4==0) ? (len/4) : (len/4)+1;//将12位内数字分为几部分
String Str_yi="",Str_wan="",Str_yuan=""; //分别定义亿，万，元字符串
String FirstStr,SecondStr,ThirdStr; //12位内至多分为三部分
int tmp_len; //用于计算临时有效字符串长度（去除0）
boolean FourValidBit_yuan = false ; //判断第三部分是否为4位
switch(partNum)
{
case 1: //只有1部分，就是xxx元
{
Str_yuan += NumStr2ChineseStr_IntPartCore(NumStr);
break;
}
case 2: //有2部分，就是 xxx万xxx元
{//注意 String.substring(beginindex,endindex)中endindex不包含
int endindex = len - 4 ;
FirstStr = NumStr.substring(0,endindex);
Str_wan += NumStr2ChineseStr_IntPartCore(FirstStr)+"万";
SecondStr = NumStr.substring(endindex,len);
Str_yuan += NumStr2ChineseStr_IntPartCore(SecondStr);
tmp_len = GetVaildStrLen(SecondStr);
if(0 <tmp_len && tmp_len < 4 )
Str_yuan = "零"+ Str_yuan;
break;
}
case 3://有3部分，就是 xxx亿xxx万xxx元
{
int endindex2 = len - 4;
int endindex1 = endindex2 - 4;
FirstStr = NumStr.substring(0,endindex1);
Str_yi += NumStr2ChineseStr_IntPartCore(FirstStr)+"亿";
SecondStr = NumStr.substring(endindex1,endindex2);
Str_wan += NumStr2ChineseStr_IntPartCore(SecondStr)+"万";
tmp_len = GetVaildStrLen(SecondStr);
if(0< tmp_len && tmp_len<4 ) //中间过程进行补零
Str_wan = "零"+Str_wan;
ThirdStr = NumStr.substring(endindex2,len);
Str_yuan += NumStr2ChineseStr_IntPartCore(ThirdStr) ;
tmp_len = GetVaildStrLen(ThirdStr);
if(0 <tmp_len && tmp_len < 4 )
Str_yuan = "零"+ Str_yuan;
else
{
if( tmp_len == 4)
FourValidBit_yuan = true;
}
break;
}
}
//对结果进行判断，如果万位和元位都为0 ，
if(Str_wan.equals("零万")) //java中时不能直接比较 Str_wan =="零"
{
if(FourValidBit_yuan )//Str_wan为"零万"且元部分为4位。如12300001234中间需读出"零"
Str_wan = "零";
else //否则就不添加
Str_wan = "";
}
if( Str_yuan.equals("零"))
Str_yuan = "";
return Str_yi+Str_wan+Str_yuan+"元";
}

分析：该函数将整数部分分为3段分别处理并且加上单位（亿，万）,然后最后通过三个结果串的链接处理，返回结果。关键还是0的处理。在函数中，分别处理后，有一步是计算有效长度的（非0位的个数），来确定是否要添加“零”。比如“12301230123”中间的“0123”在处理完后，就需要加“零”。具体实现间上源码。

1.3 小数部分转中文字符串

小数部分的实现和整数部分类似，由于小数部分最多有2位。也存在首位是否为0的，是否需要填“零”的问题。具体见下面完整代码实现和注释。

(2)完整实现

[java] view plaincopyprint?

import java.util.* ;
public class Sample
{
private String[] ChineseArr = new String[]{"零","一","二","三","四","五","六","七","八","九"};
private String[] UnitArr = new String[]{"千","百","十"};
/*四位数的字符串转汉字读法
* 如果输入NumStr 不够4位就前补零，变为4位
*/
public String NumStr2ChineseStr_IntPartCore(String NumStr)
{
String rst = ""; //保存结果初始化为空
int len = NumStr.length(); //获取NumStr的长度
//补零操作
if(len < 4) //位数小于4位就前补位
{
String[] AddZeroStr = {"0","00","000"};
NumStr = AddZeroStr[4-len-1] + NumStr;
}
len = NumStr.length(); //更新长度其实 len==4
//扫描至第一个不为0的字符
int i=0;
while(i < len && NumStr.charAt(i)-'0'==0)
++i;
if(i==len) //四个数都为零，就直接输出一个零并返回
{
rst += "零";
return rst;
}
//四个数不都为0的情况
for(;i < len; ++i)
{
int num = NumStr.charAt(i) - '0';
if( i != len-1 && num != 0)//不是末尾且不为0
{
rst += ChineseArr[num] + UnitArr[i] ;//直接映射汉字和单位
}
else
{
//若当前结果字符串中最后一位不是“零”，且数字串最后一位不是数字0 这样对中间2个零的只添加一个“零”如1003
if( rst.length()>0 && rst.charAt(rst.length()-1) != '零' && NumStr.charAt(len-1)-'0'!= 0)
{ //四位中第二，三位至少有一个为0且最后一位数字不为0 如1003 则为一千零三
if((i==1||i==2) && num == 0)
rst += "零";
}
if( i== len - 1 && num !=0)//是最后一位，且数字不为0 不加单位
{
rst += ChineseArr[num];
}
}
}
return rst; //返回结果字符串
}
/* 获取数字字符串的有效位（不是0的位数）
*/
public int GetVaildStrLen(String str)
{
int start = 0;
int len = str.length();
while(start < len && str.charAt(start) =='0')
++ start ;
return 4 - start;
}
/*将12位整数部分数字转为汉字字符串
*/
public String NumStr2ChineseStr_IntPart(String NumStr)
{
int len = NumStr.length(); //获取字符串总长度
int partNum = (len%4==0) ? (len/4) : (len/4)+1;//将12位内数字分为几部分
String Str_yi="",Str_wan="",Str_yuan=""; //分别定义亿，万，元字符串
String FirstStr,SecondStr,ThirdStr; //12位内至多分为三部分
int tmp_len; //用于计算临时有效字符串长度（去除0）
boolean FourValidBit_yuan = false ; //判断第三部分是否为4位
switch(partNum)
{
case 1: //只有1部分，就是xxx元
{
Str_yuan += NumStr2ChineseStr_IntPartCore(NumStr);
break;
}
case 2: //有2部分，就是 xxx万xxx元
{//注意 String.substring(beginindex,endindex)中endindex不包含
int endindex = len - 4 ;
FirstStr = NumStr.substring(0,endindex);
Str_wan += NumStr2ChineseStr_IntPartCore(FirstStr)+"万";
SecondStr = NumStr.substring(endindex,len);
Str_yuan += NumStr2ChineseStr_IntPartCore(SecondStr);
tmp_len = GetVaildStrLen(SecondStr);
if(0 <tmp_len && tmp_len < 4 )
Str_yuan = "零"+ Str_yuan;
break;
}
case 3://有3部分，就是 xxx亿xxx万xxx元
{
int endindex2 = len - 4;
int endindex1 = endindex2 - 4;
FirstStr = NumStr.substring(0,endindex1);
Str_yi += NumStr2ChineseStr_IntPartCore(FirstStr)+"亿";
SecondStr = NumStr.substring(endindex1,endindex2);
Str_wan += NumStr2ChineseStr_IntPartCore(SecondStr)+"万";
tmp_len = GetVaildStrLen(SecondStr);
if(0< tmp_len && tmp_len<4 ) //中间过程进行补零
Str_wan = "零"+Str_wan;
ThirdStr = NumStr.substring(endindex2,len);
Str_yuan += NumStr2ChineseStr_IntPartCore(ThirdStr) ;
tmp_len = GetVaildStrLen(ThirdStr);
if(0 <tmp_len && tmp_len < 4 )
Str_yuan = "零"+ Str_yuan;
else
{
if( tmp_len == 4)
FourValidBit_yuan = true;
}
break;
}
}
//对结果进行判断，如果万位和元位都为0 ，
if(Str_wan.equals("零万")) //java中时不能直接比较 Str_wan =="零"
{
if(FourValidBit_yuan )//Str_wan为"零万"且元部分为4位。如12300001234中间需读出"零"
Str_wan = "零";
else //否则就不添加
Str_wan = "";
}
if( Str_yuan.equals("零"))
Str_yuan = "";
return Str_yi+Str_wan+Str_yuan+"元";
}
//处理小数字符串部分最多两位
public String NumStr2ChineseStr_FloatPart(String floatStr)
{
String rst_jiao = "",rst_fen = "";
int len = floatStr.length();
//补零操作
if(len < 2) //位数小于2位就前补位
{
String[] AddZeroStr = {"0","00"};
floatStr = AddZeroStr[2-len-1] + floatStr;
}
for(int i=0 ; i < 2 ; ++i) //2 表示就是两位因为只有角分而已
{
int num = floatStr.charAt(i) - '0';
if( i == 0)
{
rst_jiao += ChineseArr[num] ;
if( num != 0)
rst_jiao += "角";
}
else
{
if(num !=0)
rst_fen += ChineseArr[num]+"分";
}
}
if( rst_fen.equals("") && (rst_jiao.equals("零")||rst_jiao.equals("零角")))
rst_jiao = "";
return rst_jiao + rst_fen;
}
/* 将一个有效为15位内的浮点数变成人民币中文读法
*/
public String NumStr2ChineseStr(double Num)
{
long IntPart = (long)Num;
long floatPart = Math.round((Num - IntPart)*100);
return NumStr2ChineseStr_IntPart(""+IntPart)+ NumStr2ChineseStr_FloatPart(""+floatPart);
}
/* 静态测试方法
*/
public static void Test(String rst, String except)
{
if(rst.equals(except))
System.out.print("test passed\n");
else
System.out.println("test failed\n");
}
//入口函数
public static void main(String[] args)
{
Sample SampleOj = new Sample(); //方法要么为静态方法或者直接创建对象调用其方法
//测试第一部分
System.out.print("测试1部分：\n");
Test(SampleOj.NumStr2ChineseStr(1023.12),"一千零二十三元一角二分");
Test(SampleOj.NumStr2ChineseStr(1003.02),"一千零三元零二分");
Test(SampleOj.NumStr2ChineseStr(123.3),"一百二十三元三角");
Test(SampleOj.NumStr2ChineseStr(123),"一百二十三元");
Test(SampleOj.NumStr2ChineseStr(1234),"一千二百三十四元");
//测试第二部分
System.out.print("\n测试2部分：\n");
Test(SampleOj.NumStr2ChineseStr(1231234.12),"一百二十三万一千二百三十四元一角二分");
Test(SampleOj.NumStr2ChineseStr(1230234.1),"一百二十三万零二百三十四元一角");
Test(SampleOj.NumStr2ChineseStr(1230034.02),"一百二十三万零三十四元零二分");
Test(SampleOj.NumStr2ChineseStr(1230004),"一百二十三万零四元");
Test(SampleOj.NumStr2ChineseStr(1230000.01),"一百二十三万元零一分");
//测试第三部分
System.out.print("\n测试3部分：\n");
Test(SampleOj.NumStr2ChineseStr(12312341234.1),"一百二十三亿一千二百三十四万一千二百三十四元一角");
Test(SampleOj.NumStr2ChineseStr(12301231234.02),"一百二十三亿零一百二十三万一千二百三十四元零二分");
Test(SampleOj.NumStr2ChineseStr(12300230034.02),"一百二十三亿零二十三万零三十四元零二分");
Test(SampleOj.NumStr2ChineseStr(12300001234.02),"一百二十三亿零一千二百三十四元零二分");
Test(SampleOj.NumStr2ChineseStr(12300000234.12),"一百二十三亿零二百三十四元一角二分");
Test(SampleOj.NumStr2ChineseStr(12300000000.02),"一百二十三亿元零二分");
}
}

总结：首先将数字字符串分为两个部分，整数和小数部分，分开处理，在整数处理部分，又按4位4位来分，先写测试用例分析，哪些地方需要加零，先实现基本功能，在从特殊测试用例角度打补丁。

0 0