java金额大写

‘壹’ java金额大小写转化中的问题

private static final Pattern AMOUNT_PATTERN=Pattern.compile("^(0|[1-9]\\d{0,11})\\.(\\d\\d)$");//不考虑分隔符正确性
就是java的正则表达式，^(0|[1-9]\\d{0,11})\\.(\\d\\d)$
这个翻译过来就是^开头是 $结尾时 |或 \d 数字0-9 两个反斜线是转义
整体就是匹配 以0或1-9开头 后面跟0到11个数字 然后跟一个点，然后以两位小数结尾的一个数
Pattern类的用法可以查API
=========================================
public final class Patternextends Objectimplements Serializable正则表达式的编译表示形式。

指定为字符串的正则表达式必须首先被编译为此类的实例。然后，可将得到的模式用于创建 Matcher 对象，依照正则表达式，该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中，所以多个匹配器可以共享同一模式。

因此，典型的调用顺序是

Pattern p = Pattern.compile("a*b");
Matcher m = p.matcher("aaaaab");
boolean b = m.matches();在仅使用一次正则表达式时，可以方便地通过此类定义 matches 方法。此方法编译表达式并在单个调用中将输入序列与其匹配。语句

boolean b = Pattern.matches("a*b", "aaaaab");等效于上面的三个语句，尽管对于重复的匹配而言它效率不高，因为它不允许重用已编译的模式。
此类的实例是不可变的，可供多个并发线程安全使用。Matcher 类的实例用于此目的则不安全。

‘贰’ java简单题：一组金额数据，用人民币大写显示出来

/**
*程序目的：
*从命令行接收一个数，并将其转化为中文金额的大写方式
*例如123.45-->壹佰贰拾叁元肆角伍分
*@authorgdb
*
*实在是不符合规范，程序里面的算法没有让人明白得很清楚的注释，读上去觉得有
*点难度，可读性不强。而且很多程序还存在不少bug，随便一测就测出来了。
*所以本人还是决定重新写一下这个程序，并且尽量做到消除不必要的bug。这个程
*序我没有用什么很精妙的算法，不过用了一些Java类库中的类，像是正则表达式之类
*
*/
publicclassTrans2RMB{

	/**
	*测试程序的可行性
	*@paramargs
	*/
	publicstaticvoidmain(String[]args){
		System.out.println("
--------将数字转换成中文金额的大写形式------------
");
		Trans2RMBt2r=newTrans2RMB();
		Strings=t2r.cleanZero(t2r.splitNum(t2r.roundString(t2r.getNum())));
		//如果转换过后是一个空串，则不输出屏幕
		if(!"".equals(s)){
			System.out.println("转换成中文后为："+s);;
		}
		System.out.println("
---------------------------------------------");
	}
	
	/**
	*从命令行接收一个数，在其中调用checkNum()方法对其进行
	*验证，并返回相应的值
	*@return如果输入合法，返回输入的这个数
	*/
	privateStringgetNum(){
		Strings=null;
		System.out.println("请输入一个数字（精确到小数点后两位）：");
		//从命令行输入这个浮点数
		java.util.Scannerscanner=newjava.util.Scanner(System.in);
		s=scanner.next();
		//关闭这个Scanner
		scanner.close();
		//判断用户输入是否合法
		//若合法，返回这个值；若非法返回"0"
		if(this.checkNum(s)){
			returns;
		}else{
			return"";
		}
	}
	
	/**
	*判断用户输入的数据是否合法，用户只能输入大于零的数字，不能输入其它字符
	*@paramsString
	*@return如果用户输入数据合法，返回true，否则返回false
	*/
	privatebooleancheckNum(Strings){
		//如果用户输入的数里有非数字字符，则视为非法数据，返回false
		try{
			floatf=Float.valueOf(s);
			//如果这个数小于零则视为非法数据，返回false
			if(f<0){
				System.out.println("非法数据，请检查！");
				returnfalse;
			}else{
				returntrue;
			}
		}catch(NumberFormatExceptione){
			System.out.println("非法数据，请检查！");
			returnfalse;
		}	
	}
	
	/**
	*把用户输入的数以小数点为界分割开来，并调用numFormat()方法
	*进行相应的中文金额大写形式的转换
	*注：传入的这个数应该是经过roundString()方法进行了四舍五入操作的
	*@paramsString
	*@return转换好的中文金额大写形式的字符串
	*/
	privateStringsplitNum(Strings){
		//如果传入的是空串则继续返回空串
		if("".equals(s)){
			return"";
		}
		//以小数点为界分割这个字符串
		intindex=s.indexOf(".");
		//截取并转换这个数的整数部分
		StringintOnly=s.substring(0,index);
		Stringpart1=this.numFormat(1,intOnly);
		//截取并转换这个数的小数部分
		StringsmallOnly=s.substring(index+1);
		Stringpart2=this.numFormat(2,smallOnly);
		//把转换好了的整数部分和小数部分重新拼凑一个新的字符串
		StringnewS=part1+part2;
		returnnewS;
	}
		
	/**
	*对传入的数进行四舍五入操作
	*@paramsString从命令行输入的那个数
	*@return四舍五入后的新值
	*/
	privateStringroundString(Strings){
		//如果传入的是空串则继续返回空串
		if("".equals(s)){
			return"";
		}
		//将这个数转换成double类型，并对其进行四舍五入操作
		doubled=Double.parseDouble(s);
		//此操作作用在小数点后两位上
		d=(d*100+0.5)/100;
		//将d进行格式化
		s=newjava.text.DecimalFormat("##0.000").format(d);
		//以小数点为界分割这个字符串
		intindex=s.indexOf(".");
		//这个数的整数部分
		StringintOnly=s.substring(0,index);
		//规定数值的最大长度只能到万亿单位，否则返回"0"
		if(intOnly.length()>13){
			System.out.println("输入数据过大！（整数部分最多13位！）");
			return"";
		}
		//这个数的小数部分
		StringsmallOnly=s.substring(index+1);
		//如果小数部分大于两位，只截取小数点后两位
		if(smallOnly.length()>2){
			StringroundSmall=smallOnly.substring(0,2);
			//把整数部分和新截取的小数部分重新拼凑这个字符串
			s=intOnly+"."+roundSmall;
		}
		returns;
	}
	
	/**
	*把传入的数转换为中文金额大写形式
	*@paramflagint标志位，1表示转换整数部分，0表示转换小数部分
	*@paramsString要转换的字符串
	*@return转换好的带单位的中文金额大写形式
	*/
	privateStringnumFormat(intflag,Strings){
		intsLength=s.length();
		//货币大写形式
		StringbigLetter[]={"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};
		//货币单位
		Stringunit[]={"元","拾","佰","仟","万",
				//拾万位到仟万位
				"拾","佰","仟",
				//亿位到万亿位
				"亿","拾","佰","仟","万"};
		Stringsmall[]={"分","角"};
		//用来存放转换后的新字符串
		StringnewS="";
		//逐位替换为中文大写形式
		for(inti=0;i<sLength;i++){
			if(flag==1){
				//转换整数部分为中文大写形式（带单位）
				newS=newS+bigLetter[s.charAt(i)-48]+unit[sLength-i-1];
			}elseif(flag==2){
				//转换小数部分（带单位）
				newS=newS+bigLetter[s.charAt(i)-48]+small[sLength-i-1];
			}
		}
		returnnewS;
	}
	
	/**
	*把已经转换好的中文金额大写形式加以改进，清理这个字
	*符串里面多余的零，让这个字符串变得更加可观
	*注：传入的这个数应该是经过splitNum()方法进行处理，这个字
	*符串应该已经是用中文金额大写形式表示的
	*@paramsString已经转换好的字符串
	*@return改进后的字符串
	*/
	privateStringcleanZero(Strings){
		//如果传入的是空串则继续返回空串
		if("".equals(s)){
			return"";
		}
		//如果用户开始输入了很多0去掉字符串前面多余的'零'，使其看上去更符合习惯
		while(s.charAt(0)=='零'){
			//将字符串中的"零"和它对应的单位去掉
			s=s.substring(2);
			//如果用户当初输入的时候只输入了0，则只返回一个"零"
			if(s.length()==0){
				return"零";
			}
		}
		//字符串中存在多个'零'在一起的时候只读出一个'零'，并省略多余的单位
		/*由于本人对算法的研究太菜了，只能用4个正则表达式去转换了，各位大虾别介意哈...*/
		Stringregex1[]={"零仟","零佰","零拾"};
		Stringregex2[]={"零亿","零万","零元"};
		Stringregex3[]={"亿","万","元"};
		Stringregex4[]={"零角","零分"};
		//第一轮转换把"零仟",零佰","零拾"等字符串替换成一个"零"
		for(inti=0;i<3;i++){
			s=s.replaceAll(regex1[i],"零");
		}
		//第二轮转换考虑"零亿","零万","零元"等情况
		//"亿","万","元"这些单位有些情况是不能省的，需要保留下来
		for(inti=0;i<3;i++){
			//当第一轮转换过后有可能有很多个零叠在一起
			//要把很多个重复的零变成一个零
			s=s.replaceAll("零零零","零");
			s=s.replaceAll("零零","零");
			s=s.replaceAll(regex2[i],regex3[i]);
		}
		//第三轮转换把"零角","零分"字符串省略
		for(inti=0;i<2;i++){
			s=s.replaceAll(regex4[i],"");
		}
		//当"万"到"亿"之间全部是"零"的时候，忽略"亿万"单位，只保留一个"亿"
		s=s.replaceAll("亿万","亿");
		returns;
	}
}

‘叁’ 用JAVA如何把小写数字变成大写

我以前用的人名币大小写转换，你改改应该就可以了：
public class Test6 {
static final String zhnum_0 = "零壹贰叁肆伍陆柒捌玖";

static final String zhnum = "零一二三四五六七八九";

static final String[] zhnum1 = { "", "十", "百", "千" };

static final String[] zhnum1_0 = { "", "拾", "佰", "仟" };

static final String[] zhnum2 = { "", "万", "亿", "万亿", "亿亿" };

public Test6() {
}

private static String numberToZH4(String s, boolean fan) {
StringBuffer sb = new StringBuffer();
if (s.length() != 4)
return null;
for (int i = 0; i < 4; i++) {
char c1 = s.charAt(i);
if (c1 == '0' && i > 1 && s.charAt(i - 1) == '0')
continue;
if (c1 != '0' && i > 1 && s.charAt(i - 1) == '0')
sb.append('零');
if (c1 != '0') {
if (fan) {
sb.append(zhnum_0.charAt(c1 - 48));
sb.append(zhnum1_0[4 - i - 1]);
} else {
sb.append(zhnum.charAt(c1 - 48));
sb.append(zhnum1[4 - i - 1]);
}
}
}
return new String(sb);
}

public static String numberToZH(long n, boolean fan) {
StringBuffer sb = new StringBuffer();
String strN = "000" + n;
int strN_L = strN.length() / 4;
strN = strN.substring(strN.length() - strN_L * 4);
for (int i = 0; i < strN_L; i++) {
String s1 = strN.substring(i * 4, i * 4 + 4);
String s2 = numberToZH4(s1, fan);
sb.append(s2);
if (s2.length() != 0)
sb.append(zhnum2[strN_L - i - 1]);
}
String s = new String(sb);
if (s.length() != 0 && s.startsWith("零"))
s = s.substring(1);
return s;
}

public static String numberToZH(double d, boolean fan) {
return numberToZH("" + d, fan);
}

public static String numberToZH(String str, boolean fan) {
StringBuffer sb = new StringBuffer();
int dot = str.indexOf(".");
if (dot < 0)
dot = str.length();

String zhengshu = str.substring(0, dot);
sb.append(numberToZH(Long.parseLong(zhengshu), fan));
if (dot != str.length()) {
sb.append("点");
String xiaoshu = str.substring(dot + 1);
for (int i = 0; i < xiaoshu.length(); i++) {
if (fan) {
sb.append(zhnum_0.charAt(Integer.parseInt(xiaoshu
.substring(i, i + 1))));
} else {
sb.append(zhnum.charAt(Integer.parseInt(xiaoshu.substring(
i, i + 1))));
}
}
}
String s = new String(sb);
if (s.startsWith("零"))
s = s.substring(1);
if (s.startsWith("一十"))
s = s.substring(1);
while (s.endsWith("零")) {
s = s.substring(0, s.length() - 1);
}
if (s.endsWith("点"))
s = s.substring(0, s.length() - 1);
return s;
}

public static String numberToRMB(double rmb) {
String strRMB = "" + rmb;
DecimalFormat nf = new DecimalFormat("#.#");
nf.setMaximumFractionDigits(2);
strRMB = nf.format(rmb).toString();
strRMB = numberToZH(strRMB, true);
if (strRMB.indexOf("点") >= 0) {
strRMB = strRMB + "零";
strRMB = strRMB.replaceAll("点", "圆");
String s1 = strRMB.substring(0, strRMB.indexOf("圆") + 1);
String s2 = strRMB.substring(strRMB.indexOf("圆") + 1);
strRMB = s1 + s2.charAt(0) + "角" + s2.charAt(1) + "分整";
} else {
strRMB = strRMB + "圆整";
}
return "人民币(大写):" + strRMB;
}

public static void main(String[] args) {
System.out.println(numberToRMB(342345.96));
System.out.println(numberToRMB(123));
}
}

‘肆’ JAVA练习题 金额的中文大写

//我自己写的
//把String 换成了StringBuilder 因为后者只要新建后，无论如何变化，都是同一个字符串，
//而String 是不可变的， 每改变一次，就要新建一个变量
//也可以用StringBuffer ， 和StringBuilder用法一样， 不过是线程安全的
public class SmallToBig {
/**
* @param args
* 把数字换成大写的中文货币字符 123456789 换成
* 零,壹,贰,叁,肆,伍,陆,柒,捌,玖
* "元","十","佰","仟","万","十","佰","仟","亿","十","佰","仟"," ","","","" 太大的就没写了， 直接输出大写数字
*/
public static void main(String[] args) {
StringBuilder sb = new StringBuilder();
sb.append("3789341.512");
System.out.print( getFloatBigCn(sb));
}
public static StringBuilder getFloatBigCn(StringBuilder sb){
String [] big={"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};
String [] fUnit ={"角","分","","",""};
StringBuilder floatStr=new StringBuilder();
if(sb.indexOf(".")>-1){ //是否存在小数点
StringBuilder intPart = new StringBuilder(sb.substring(0, sb.indexOf(".")));//取得整数部分
StringBuilder flPart = new StringBuilder(sb.substring(sb.indexOf(".")+1, sb.length()));//取得小数部分
//整数部分处理
floatStr.append(getIntBigCn(intPart));//整数部分给整数方法处理
//小数点后处理
if(flPart.length()>2)
flPart = flPart.delete(2, flPart.length()); //小数点后只取到分 ，注意，此部会把2位后的数值删除掉
for (int i = 0; i <= flPart.length()-1; i++) {
int t = Integer.parseInt(flPart.substring(i, i+1));
floatStr.append(big[t]+fUnit[i]); // 数值加单位
}
}else //如果没有小数点， 直接给处理整数的方法处理
floatStr.append(getIntBigCn(sb));
return floatStr;
}
public static StringBuilder getIntBigCn(StringBuilder sb){
String[] big={"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};
String [] iUnit ={"元","十","佰","仟","万","十","佰","仟","亿",
"十","佰","仟"," ","","","","","","","",""};//中国人太有钱。。。超出单位所能承受
StringBuilder intStr=new StringBuilder();
int cnt=0;//换单位
for(int i=sb.length();i>0 ; i--){ //倒取的值
int m = Integer.parseInt(sb.substring(i-1,i));
intStr.insert(0,big[m]+iUnit[cnt]);//从前面插入
cnt++;
}
return intStr;
}
}

‘伍’ JAVA 编程 输出金额的中文大写形式

public class Text {

/**

* 测试程序的可行性

* @param args

*/

public static void main(String[] args) {

System.out.println("--------将数字转换成中文金额的大写形式------------\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();

// 判断用户输入是否合法

// 若合法，返回这个值；若非法返回 "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 args) {

System.out.println("--------将数字转换成中文金额的大写形式------------\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();

// 判断用户输入是否合法

// 若合法，返回这个值；若非法返回 "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;

}

}

‘陆’ java如何将数字转为中文大写

import org.apache.commons.lang3.StringUtils;

/**
* @Title: ConvertUpMoney
* @Description: 将数字金额转换为大写中文金额
* @date: 2019年6月18日 下午10:52:27
*/
public class ConvertUpMoney {

// 大写数字
private static final String[] NUMBERS = {"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};
// 整数部分的单位
private static final String[] IUNIT = {"元","拾","佰","仟","万","拾","佰","仟","亿","拾","佰","仟","万","拾","佰","仟"};
// 小数部分的单位
private static final String[] DUNIT = {"角","分","厘"};

/**
* 转换为大写的中文金额
* @param str 字符串类型的 金额数字
* @return
*/
public static String toChinese(String str) {
// 判断输入的金额字符串是否符合要求
if (StringUtils.isBlank(str) || !str.matches("(-)?[\\d]*(.)?[\\d]*")) {
return "抱歉，请输入数字！";
}

if("0".equals(str) || "0.00".equals(str) || "0.0".equals(str)) {
return "零元";
}

// 判断金额数字中是否存在负号"-"
boolean flag = false;
if(str.startsWith("-")){
// 标志位，标志此金额数字为负数
flag = true;
str = str.replaceAll("-", "");
}

// 去掉金额数字中的逗号","
str = str.replaceAll(",", "");
String integerStr;//整数部分数字
String decimalStr;//小数部分数字

// 初始化：分离整数部分和小数部分
if(str.indexOf(".")>0) {
integerStr = str.substring(0,str.indexOf("."));
decimalStr = str.substring(str.indexOf(".") + 1);
}else if(str.indexOf(".")==0) {
integerStr = "";
decimalStr = str.substring(1);
}else {
integerStr = str;
decimalStr = "";
}

// beyond超出计算能力，直接返回
if(integerStr.length()>IUNIT.length) {
return "超出计算能力！";
}

// 整数部分数字
int[] integers = toIntArray(integerStr);
// 判断整数部分是否存在输入012的情况
if (integers.length>1 && integers[0] == 0) {
return "抱歉，输入数字不符合要求！";
}
// 设置万单位
boolean isWan = isWan5(integerStr);
// 小数部分数字
int[] decimals = toIntArray(decimalStr);
// 返回最终的大写金额
String result = getChineseInteger(integers, isWan) + getChineseDecimal(decimals);
if(flag){
// 如果是负数，加上"负"
return "负" + result;
}else{
return result;
}
}

/**
* 将字符串转为int数组
* @param number 数字
* @return
*/
private static int[] toIntArray(String number) {
int[] array = new int[number.length()];
for(int i = 0;i<number.length();i++) {
array[i] = Integer.parseInt(number.substring(i,i+1));
}
return array;
}

/**
* 将整数部分转为大写的金额
* @param integers 整数部分数字
* @param isWan 整数部分是否已经是达到【万】
* @return
*/
public static String getChineseInteger(int[] integers,boolean isWan) {
StringBuffer chineseInteger = new StringBuffer("");
int length = integers.length;
if (length == 1 && integers[0] == 0) {
return "";
}
for(int i=0; i<length; i++) {
String key = "";
if(integers[i] == 0) {
if((length - i) == 13)//万（亿）
key = IUNIT[4];
else if((length - i) == 9) {//亿
key = IUNIT[8];
}else if((length - i) == 5 && isWan) {//万
key = IUNIT[4];
}else if((length - i) == 1) {//元
key = IUNIT[0];
}
if((length - i)>1 && integers[i+1]!=0) {
key += NUMBERS[0];
}
}
chineseInteger.append(integers[i]==0?key:(NUMBERS[integers[i]]+IUNIT[length - i -1]));
}
return chineseInteger.toString();
}

/**
* 将小数部分转为大写的金额
* @param decimals 小数部分的数字
* @return
*/
private static String getChineseDecimal(int[] decimals) {
StringBuffer chineseDecimal = new StringBuffer("");
for(int i = 0;i<decimals.length;i++) {
if(i == 3) {
break;
}
chineseDecimal.append(decimals[i]==0?"":(NUMBERS[decimals[i]]+DUNIT[i]));
}
return chineseDecimal.toString();
}

/**
* 判断当前整数部分是否已经是达到【万】
* @param integerStr 整数部分数字
* @return
*/
private static boolean isWan5(String integerStr) {
int length = integerStr.length();
if(length > 4) {
String subInteger = "";
if(length > 8) {
subInteger = integerStr.substring(length- 8,length -4);
}else {
subInteger = integerStr.substring(0,length - 4);
}
return Integer.parseInt(subInteger) > 0;
}else {
return false;
}
}

// Test
public static void main(String[] args) {
String number = "12.56";
System.out.println(number+": "+ConvertUpMoney.toChinese(number));

number = "1234567890563886.123";
System.out.println(number+": "+ConvertUpMoney.toChinese(number));

number = "1600";
System.out.println(number+": "+ConvertUpMoney.toChinese(number));

number = "156,0";
System.out.println(number+": "+ConvertUpMoney.toChinese(number));

number = "-156,0";
System.out.println(number+": "+ConvertUpMoney.toChinese(number));

number = "0.12";
System.out.println(number+": "+ConvertUpMoney.toChinese(number));

number = "0.0";
System.out.println(number+": "+ConvertUpMoney.toChinese(number));

number = "01.12";
System.out.println(number+": "+ConvertUpMoney.toChinese(number));

number = "0125";
System.out.println(number+": "+ConvertUpMoney.toChinese(number));

number = "-0125";
System.out.println(number+": "+ConvertUpMoney.toChinese(number));

number = "sdw5655";
System.out.println(number+": "+ConvertUpMoney.toChinese(number));

System.out.println(null+": "+ConvertUpMoney.toChinese(null));
}
}

‘柒’ Java金额的中文大写方式

/**
* 金额小数转换成中文大写金额
* @author Neil Han
*
*/
public class ConvertMoneyToUppercase {

private static final String UNIT[] = { "万", "千", "佰", "拾", "亿", "千", "佰",
"拾", "万", "千", "佰", "拾", "元", "角", "分" };

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

private static final double MAX_VALUE = 9999999999999.99D;

/**
* 将金额小数转换成中文大写金额
* @param money
* @return result
*/
public static String convertMoney(double money) {
if (money < 0 || money > MAX_VALUE)
return "参数非法!";
long money1 = Math.round(money * 100); // 四舍五入到分
if (money1 == 0)
return "零元整";
String strMoney = String.valueOf(money1);
int numIndex = 0; // numIndex用于选择金额数值
int unitIndex = UNIT.length - strMoney.length(); // unitIndex用于选择金额单位
boolean isZero = false; // 用于判断当前为是否为零
String result = "";
for (; numIndex < strMoney.length(); numIndex++, unitIndex++) {
char num = strMoney.charAt(numIndex);
if (num == '0') {
isZero = true;
if (UNIT[unitIndex] == "亿" || UNIT[unitIndex] == "万"
|| UNIT[unitIndex] == "元") { // 如果当前位是亿、万、元，且数值为零
result = result + UNIT[unitIndex]; //补单位亿、万、元
isZero = false;
}
}else {
if (isZero) {
result = result + "零";
isZero = false;
}
result = result + NUM[Integer.parseInt(String.valueOf(num))] + UNIT[unitIndex];
}
}
//不是角分结尾就加"整"字
if (!result.endsWith("角")&&!result.endsWith("分")) {
result = result + "整";
}
//例如没有这行代码，数值"400000001101.2"，输出就是"肆千亿万壹千壹佰零壹元贰角"
result = result.replaceAll("亿万", "亿");
return result;
}

public static void main(String[] args) {
double value = Double.parseDouble("40330701101.2");
System.out.println("您输入的金额（小写）为：" + value);
System.out.println("您输入的金额（大写）为：" + convertMoney(value));
}

}

‘捌’ java如何把大写的金额改成小写

/**
* @(#)SimpleMoneyFormat.java
*
*金额转换，阿拉伯数字的金额转换为中国传统的形式输出
* @lpxuan
* @version 1.00 2010/7/31
*/

import java.text.NumberFormat;
import java.util.HashMap;
import java.lang.StringBuffer;

public class SimpleMoneyFormat {

public static final String EMPTY="";
public static final String ZERO="零";
public static final String ONE="壹";
public static final String TWO="贰";
public static final String THREE="叁";
public static final String FOUR="肆";
public static final String FIVE="伍";
public static final String SIX="陆";
public static final String SEVEN="柒";
public static final String EIGHT="捌";
public static final String NINE="玖";
public static final String TEN="拾";
public static final String HUNDRED="佰";
public static final String THOUSAND="仟";
public static final String TEN_THOUSAND="万";
public static final String HUNDRED_MILLION="亿";
public static final String YUAN="元";
public static final String JIAO="角";
public static final String FEN="分";
public static final String DOT=".";

private static SimpleMoneyFormat formatter=null;
private HashMap chineseNumberMap=new HashMap();
private HashMap chineseMoenyPattern=new HashMap();
private NumberFormat numberFormat=NumberFormat.getInstance();

//私有构造函数
private SimpleMoneyFormat() {
numberFormat.setMaximumFractionDigits(4);
numberFormat.setMinimumFractionDigits(2);
numberFormat.setGroupingUsed(false);

chineseNumberMap.put("0",ZERO);
chineseNumberMap.put("1",ONE);
chineseNumberMap.put("2",TWO);
chineseNumberMap.put("3",THREE);
chineseNumberMap.put("4",FOUR);
chineseNumberMap.put("5",FIVE);
chineseNumberMap.put("6",SIX);
chineseNumberMap.put("7",SEVEN);
chineseNumberMap.put("8",EIGHT);
chineseNumberMap.put("9",NINE);
chineseNumberMap.put(DOT,DOT);

chineseMoenyPattern.put("1",TEN);
chineseMoenyPattern.put("2",HUNDRED);
chineseMoenyPattern.put("3",THOUSAND);
chineseMoenyPattern.put("4",TEN_THOUSAND);
chineseMoenyPattern.put("5",TEN);
chineseMoenyPattern.put("6",HUNDRED);
chineseMoenyPattern.put("7",THOUSAND);
chineseMoenyPattern.put("8",HUNDRED_MILLION);
}

//单例模式
public static SimpleMoneyFormat getInstance(){
if(formatter==null)
formatter=new SimpleMoneyFormat();
return formatter;
}

public String format(String moneyStr){
checkPrecision(moneyStr);
String result;
result=convertToChineseNumber(moneyStr);
result=addUnitsToChineseMoenyString(result);
return result;
}

public String format(double moneyDouble){
return format(numberFormat.format(moneyDouble));
}

public String format(int moneyInt){
return format(numberFormat.format(moneyInt));
}

public String format(long moneyLong){
return format(numberFormat.format(moneyLong));
}

public String format(Number moneyNum){
return format(numberFormat.format(moneyNum));
}

private String convertToChineseNumber(String moneyStr){
String result;
StringBuffer cMoneyStringBuffer =new StringBuffer();
for(int i=0;i<moneyStr.length();i++){
cMoneyStringBuffer.append(chineseNumberMap.
get(moneyStr.substring(i,i+1)));
}

int indexOfDot=cMoneyStringBuffer.indexOf(DOT);
int moneyPatternCursor=1;
for(int i=indexOfDot-1;i>0;i--){
cMoneyStringBuffer.insert(i,
chineseMoenyPattern.get(EMPTY+moneyPatternCursor));
moneyPatternCursor=moneyPatternCursor==
8?1:moneyPatternCursor+1;
}

String fractionPart=cMoneyStringBuffer.substring(
cMoneyStringBuffer.indexOf("."));
cMoneyStringBuffer.delete(
cMoneyStringBuffer.indexOf("."),
cMoneyStringBuffer.length());
while(cMoneyStringBuffer.indexOf("零拾")!=-1){
cMoneyStringBuffer.replace(
cMoneyStringBuffer.indexOf("零拾"),
cMoneyStringBuffer.indexOf("零拾")+2,ZERO);
}
while(cMoneyStringBuffer.indexOf("零佰")!=-1){
cMoneyStringBuffer.replace(
cMoneyStringBuffer.indexOf("零佰"),
cMoneyStringBuffer.indexOf("零佰")+2,ZERO);
}
while(cMoneyStringBuffer.indexOf("零仟")!=-1){
cMoneyStringBuffer.replace(
cMoneyStringBuffer.indexOf("零仟"),
cMoneyStringBuffer.indexOf("零仟")+2,ZERO);
}
while(cMoneyStringBuffer.indexOf("零万")!=-1){
cMoneyStringBuffer.replace(
cMoneyStringBuffer.indexOf("零万"),
cMoneyStringBuffer.indexOf("零万")+2,TEN_THOUSAND);
}
while(cMoneyStringBuffer.indexOf("零亿")!=-1){
cMoneyStringBuffer.replace(
cMoneyStringBuffer.indexOf("零亿"),
cMoneyStringBuffer.indexOf("零亿")+2,HUNDRED_MILLION);
}
while(cMoneyStringBuffer.indexOf("零零")!=-1){
cMoneyStringBuffer.replace(
cMoneyStringBuffer.indexOf("零零"),
cMoneyStringBuffer.indexOf("零零")+2,ZERO);
}
if(cMoneyStringBuffer.lastIndexOf(ZERO)
==cMoneyStringBuffer.length()-1){
cMoneyStringBuffer.delete(
cMoneyStringBuffer.length()-1,
cMoneyStringBuffer.length());
}
cMoneyStringBuffer.append(fractionPart);
result=cMoneyStringBuffer.toString();
return result;
}

private String addUnitsToChineseMoenyString(String moneyStr){
String result;
StringBuffer cMoneyStringBuffer=new StringBuffer(moneyStr);

int indexOfDot=cMoneyStringBuffer.indexOf(DOT);
cMoneyStringBuffer.replace(indexOfDot,indexOfDot+1,YUAN);
cMoneyStringBuffer.insert(cMoneyStringBuffer.length()-1,JIAO);
cMoneyStringBuffer.insert(cMoneyStringBuffer.length(),FEN);

//拾佰仟万亿等都是汉字里面才有的单位，加上它们
if(cMoneyStringBuffer.indexOf("零角零分")!=-1)//去掉零头，加整
cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零角零分"),
cMoneyStringBuffer.length(),"整");
else if(cMoneyStringBuffer.indexOf("零分")!=-1)//去掉零分，加整
cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零分"),
cMoneyStringBuffer.length(),"整");
else if(cMoneyStringBuffer.indexOf("零角")!=-1)
cMoneyStringBuffer.delete(cMoneyStringBuffer.indexOf("零角"),
cMoneyStringBuffer.indexOf("零角")+2);
result=cMoneyStringBuffer.toString();
return result;
}

//检查精度的合法性
private void checkPrecision(String moneyStr){
int fractionDigits=moneyStr.length()-moneyStr.indexOf(DOT)-1;
if(fractionDigits>2)//精度不能比分低
throw new RuntimeException("金额"+moneyStr+"的小数位数多余两位.");
}

public static void main(String[] args){
System.out.println(getInstance().format(new Double(10010001.01)));
}

}

‘玖’ Java 关于中文大写金额与阿拉伯数字 互相转换的问题（eclipse版）

package test.format;import java.text.NumberFormat;import java.util.HashMap;public class SimpleMoneyFormat {
public static final String EMPTY = "";public static final String ZERO = "零";public static final String ONE = "壹";public static final String TWO = "贰";public static final String THREE = "叁";public static final String FOUR = "肆"; public static final String FIVE = "伍";public static final String SIX = "陆";public static final String SEVEN = "柒"; public static final String EIGHT = "捌"; public static final String NINE = "玖"; public static final String TEN = "拾"; public static final String HUNDRED = "佰"; public static final String THOUSAND = "仟"; public static final String TEN_THOUSAND = "万"; public static final String HUNDRED_MILLION = "亿"; public static final String YUAN = "元"; public static final String JIAO = "角"; public static final String FEN = "分"; public static final String DOT = "."; private static SimpleMoneyFormat formatter = null;private HashMap chineseNumberMap = new HashMap(); private HashMap chineseMoneyPattern = new HashMap(); private NumberFormat numberFormat = NumberFormat.getInstance(); private SimpleMoneyFormat() { numberFormat.setMaximumFractionDigits(4); numberFormat.setMinimumFractionDigits(2); numberFormat.setGroupingUsed(false); chineseNumberMap.put("0", ZERO); chineseNumberMap.put("1", ONE); chineseNumberMap.put("2", TWO); chineseNumberMap.put("3", THREE); chineseNumberMap.put("4", FOUR); chineseNumberMap.put("5", FIVE); chineseNumberMap.put("6", SIX); chineseNumberMap.put("7", SEVEN); chineseNumberMap.put("8", EIGHT); chineseNumberMap.put("9", NINE); chineseNumberMap.put(DOT, DOT); chineseMoneyPattern.put("1", TEN); chineseMoneyPattern.put("2", HUNDRED); chineseMoneyPattern.put("3", THOUSAND); chineseMoneyPattern.put("4", TEN_THOUSAND); chineseMoneyPattern.put("5", TEN); chineseMoneyPattern.put("6", HUNDRED); chineseMoneyPattern.put("7", THOUSAND); chineseMoneyPattern.put("8", HUNDRED_MILLION); }
public static SimpleMoneyFormat getInstance() { if (formatter == null) formatter = new SimpleMoneyFormat(); return formatter; }
public String format(String moneyStr) { checkPrecision(moneyStr); String result; result = convertToChineseNumber(moneyStr); result = addUnitsToChineseMoneyString(result); return result; } public String format(double moneyDouble) { return format(numberFormat.format(moneyDouble)); } public String format(int moneyInt) { return format(numberFormat.format(moneyInt));
} public String format(long moneyLong) { return format(numberFormat.format(moneyLong)); }
public String format(Number moneyNum) { return format(numberFormat.format(moneyNum)); }
private String convertToChineseNumber(String moneyStr) { String result; StringBuffer cMoneyStringBuffer = new StringBuffer(); for (int i = 0; i < moneyStr.length(); i++) { cMoneyStringBuffer.append(chineseNumberMap.get(moneyStr.substring(i, i + 1))); }
//拾佰仟万亿等都是汉字里面才有的单位，加上它们 int indexOfDot = cMoneyStringBuffer.indexOf(DOT); int moneyPatternCursor = 1; for (int i = indexOfDot - 1; i > 0; i--) { cMoneyStringBuffer.insert(i, chineseMoneyPattern.get(EMPTY + moneyPatternCursor)); moneyPatternCursor = moneyPatternCursor == 8 ? 1 : moneyPatternCursor + 1; } String fractionPart = cMoneyStringBuffer.substring(cMoneyStringBuffer.indexOf(".")); cMoneyStringBuffer.delete(cMoneyStringBuffer.indexOf("."), cMoneyStringBuffer.length()); while (cMoneyStringBuffer.indexOf("零拾") != -1) {
cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零拾"), cMoneyStringBuffer.indexOf("零拾") + 2, ZERO);
} while (cMoneyStringBuffer.indexOf("零佰") != -1) {
cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零佰"), cMoneyStringBuffer.indexOf("零佰") + 2, ZERO);
}while (cMoneyStringBuffer.indexOf("零仟") != -1) {
cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零仟"), cMoneyStringBuffer.indexOf("零仟") + 2, ZERO);
}while (cMoneyStringBuffer.indexOf("零万") != -1) {
cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零万"), cMoneyStringBuffer.indexOf("零万") + 2, TEN_THOUSAND);
} while (cMoneyStringBuffer.indexOf("零亿") != -1) {
cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零亿"), cMoneyStringBuffer.indexOf("零亿") + 2, HUNDRED_MILLION); } while (cMoneyStringBuffer.indexOf("零零") != -1) {
cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零零"), cMoneyStringBuffer.indexOf("零零") + 2, ZERO);
} if (cMoneyStringBuffer.lastIndexOf(ZERO) == cMoneyStringBuffer.length() - 1) cMoneyStringBuffer.delete(cMoneyStringBuffer.length() - 1, cMoneyStringBuffer.length()); cMoneyStringBuffer.append(fractionPart);
result = cMoneyStringBuffer.toString(); return result; }private String addUnitsToChineseMoneyString(String moneyStr) { String result; StringBuffer cMoneyStringBuffer = new StringBuffer(moneyStr); int indexOfDot = cMoneyStringBuffer.indexOf(DOT); cMoneyStringBuffer.replace(indexOfDot, indexOfDot + 1, YUAN); cMoneyStringBuffer.insert(cMoneyStringBuffer.length() - 1, JIAO); cMoneyStringBuffer.insert(cMoneyStringBuffer.length(), FEN); if (cMoneyStringBuffer.indexOf("零角零分") != -1)//没有零头，加整
cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零角零分"), cMoneyStringBuffer.length(), "整"); else if (cMoneyStringBuffer.indexOf("零分") != -1)//没有零分，加整 cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零分"), cMoneyStringBuffer.length(), "整");
else { if(cMoneyStringBuffer.indexOf("零角")!=-1)
cMoneyStringBuffer.delete(cMoneyStringBuffer.indexOf("零角"),cMoneyStringBuffer.indexOf("零角")+2);
tmpBuffer.append("整"); } result = cMoneyStringBuffer.toString(); return result; } private void checkPrecision(String moneyStr) {
int fractionDigits = moneyStr.length() - moneyStr.indexOf(DOT) - 1; if (fractionDigits > 2) throw new RuntimeException("金额" + moneyStr + "的小数位多于两位。"); //精度不能比分低 }public static void main(String args[]) { System.out.println(getInstance().format(new Double(10010001.01))); }}