将一个字符串转换为我们中国人读的方式！要求：
1.该字符串只能含数字和小数点（要检测是否含有其他非法字符或为空）;
2.要考虑到很多的情况(比如)：
a.100 000 000.12（一亿点一二）；
b.10 000 001.45（一千万零一点四五）；
c.2 400 001.01(二百四十万零一点零一)；
d.45 974 623.80（四千五百九十七万四千六百二十三点八零）；
e.8 900 542.78(八百九十万零五百四十二点七八)；
1.该字符串只能含数字和小数点（要检测是否含有其他非法字符或为空）;
2.要考虑到很多的情况(比如)：
a.100 000 000.12（一亿点一二）；
b.10 000 001.45（一千万零一点四五）；
c.2 400 001.01(二百四十万零一点零一)；
d.45 974 623.80（四千五百九十七万四千六百二十三点八零）；
e.8 900 542.78(八百九十万零五百四十二点七八)；
然后转换成字符串，用str.splie分成数组对象，
然后对str[1]判断位数，8位以上或以下。然后判断万位。
当然，中间添加千百十什么的确实挺麻烦的。
我记得我以前没事的时候写过，不过找不到了。明天上班的时候再试着写写看
用环境换习惯了，自己敲的时候总是敲错
char[] s1="12364035987.12".toCharArray();
for(int i=0;i<s1.length;i++)
{
if(!Character.isDigit(s1[i]))
{
if(s1[i]!='.')
{
b=false;
}
}
}
System.out.println(b);
第一次先判断是否除了.和数字之外的其它字符，如果存在，直接false.
然后判断一下是否只存在一个.，如果存在，
则进行下面的判断就行了。。
今天领导查岗比较勤快，没时间写，晚上给你发
package com.zf.test;import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;public class Test4 { private Map<String , String> e2c = new HashMap<String, String>();
{
e2c.put("0", "零");
e2c.put("1", "一");
e2c.put("2", "二");
e2c.put("3", "三");
e2c.put("4", "四");
e2c.put("5", "五");
e2c.put("6", "六");
e2c.put("7", "七");
e2c.put("8", "八");
e2c.put("9", "九");
} private String[] ws = new String[]{" " ,"十" , "百" ,"千" ,"万" , "十万" ,"百万" ,"千万" ,"亿" ,"十亿" ,"百亿" ,"千亿"}; private String str ; //要转换的字符串 private LinkedList<String> beforePoint ; //保存小数点之前的内容 private String afterPoint ; //保存小数点之后的内容 public Test4(String str){
this.str = str ;
String[] tmp = str.split("\\.");
beforePoint = new LinkedList<String>();
char[] cs = tmp[0].toCharArray();
for (Character c : cs) {
beforePoint.add(String.valueOf(c));
}
if(tmp.length > 1)
afterPoint = tmp[1] ;
} private String translate(){
int currentIndex = 0 ;
StringBuilder sb = new StringBuilder();
String lastNumber = "0";
String lastFh = " ";
while(!beforePoint.isEmpty()){
String s = beforePoint.removeLast();
String fh = ws[currentIndex] ;
if( lastNumber.equals("0") && s.equals("0")){
if(beforePoint.isEmpty())
sb.insert(0, e2c.get(s));
}else {
sb.insert(0, e2c.get(s));
if(!s.equals("0")){
if(lastFh.charAt(lastFh.length() - 1) == fh.charAt(fh.length() - 1))
fh = fh.substring(0 , fh.length() - 1);
sb.insert( 1, fh);
}
}
lastNumber = s;
lastFh = s.equals("0") ? " " : ws[currentIndex];
currentIndex++;
}
return sb.toString();
} private String format(){
String before = translate();
StringBuilder after = new StringBuilder();
if(afterPoint != null){
before += "点";
for (int i = 0; i < afterPoint.length() ; i++) {
after.append(e2c.get(String.valueOf(afterPoint.charAt(i))));
}
}
return before + after.toString();
} public static void main(String[] args) { String [] ss = new String[]{
"100000000.12"
,"10000001.45"
,"2400001.01"
,"45974623.80"
,"8900542.78"
,"0.992"
,"203200.992"
}; for (String s : ss) {
System.out.println(new Test4(s).format());
} }
}console一亿点一二
一千万零一点四五
二百四十万零一点零一
四千五百九十七万四千六百二十三点八零
八百九十万零五百四十二点七八
零点九九二
二十万零三千二百点九九二
package com.briup.test08;import java.util.Scanner;public class NumberTest {
public static void main(String[] args) {
String[] dates = null;
String[] bigzero;
String[] smallzero;
Scanner input=new Scanner(System.in);
String str=input.next();
//格式判断未添加，不用正则表达式的话写起来有点麻烦。上面给你了思路，你照着谢谢试试，写不出来回帖我在帮你弄
System.out.println("输入的字符串为:"+str);
if(str.contains(".")){
dates = str.split("\\.");//选择“.”对字符串进行分割，分割成数组,“.”比较特殊，必须用转义字符545
}
System.out.println(dates[0]);
bigzero=dates[0].split("");//把大于0的部分转换为字符集
smallzero=dates[1].split("");//把小于0的部分转换为字符集
int n=1;
int k=bigzero.length-1;//这里得到的长度比实际多一位，所以删除。第一位的值为null,不使用
while(n<bigzero.length){
int i=Integer.parseInt(bigzero[n]);
System.out.print(transNumber(i));
System.out.print(retWei(k));
n++;
k--;
}
}
public static String transNumber(int i){
String str = null;
switch (i) {
case 0:str="零";break;
case 1:str="一";break;
case 2:str="二";break;
case 3:str="三";break;
case 4:str="四";break;
case 5:str="五";break;
case 6:str="六";break;
case 7:str="七";break;
case 8:str="八";break;
case 9:str="九";break;
default:
break;
}
return str;
}
public static String retWei(int i){
String str = null;
switch (i) {
case 2:str="十";break;
case 3:str="百";break;
case 4:str="千";break;
case 5:str="万";break;
case 6:str="十";break;
case 7:str="百";break;
case 8:str="千";break;
case 9:str="亿";break;//这里只设置到亿位，后面的你自己设置，亿位以下的没问题。
default:str="";break;//其它情况下返回空
}
return str;
}
}
和楼上类似
刚弄完
14楼的老板！你58行 fh = fh.substring(0 , fh.length() - 1); 表示的什么意思了?为什么后面的endIndex 要用fh.length() - 1; 用fh.length()不是更好吗？
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
public class E2C {
public final static Map<String , String> e2c = new HashMap<String, String>();
{
e2c.put("0", "零");
e2c.put("1", "一");
e2c.put("2", "二");
e2c.put("3", "三");
e2c.put("4", "四");
e2c.put("5", "五");
e2c.put("6", "六");
e2c.put("7", "七");
e2c.put("8", "八");
e2c.put("9", "九");
}
public final static String [] symbols = new String[]{"" ,"十" ,"百" ,"千" ,"万" ,"万" , "万" ,"万" ,"亿" ,"亿" , "亿" ,"亿"};
public final static String [] amounts = new String[]{"" ,"" , "" , "" , "" , "十" , "百" , "千" , "" , "十" , "百" ,"千"};
public String format(String str){
String ba[] = str.split("\\.");
String before = ba[0];
String after = null ;
if(ba.length > 1)
after = ba[1];
return formatBefore(before) + formatAfter(after);
}
//转换小数点之后的字符串
public String formatAfter(String after){
if(after != null && after.length() > 0){
StringBuilder sb = new StringBuilder("点");
char[] schars = after.toCharArray();
for (int i = 0; i < schars.length; i++) {
sb.append(e2c.get(String.valueOf(schars[i])));
}
return sb.toString();
}
return "";
}
//转换小数点之前的字符串
public String formatBefore(String before){
LinkedList<Bit> list = new LinkedList<Bit>();
StringBuilder sb = new StringBuilder();
char[] schars = before.toCharArray();
for (int i = schars.length - 1 , j = 0; i >= 0; i-- , j++) { //将字符串集合从后向前遍历
Bit current = new Bit(String.valueOf(schars[i]), j) ; //将当前字符封装为Bit对象
Bit last = null ; //得到最后一个添加进集合的字符对象
if(!list.isEmpty())
last = list.getLast();
if(current.sourceStr.equals("0")){//当碰到0时特殊处理
if(list.isEmpty() || last.sourceStr.equals("0")){
if(i == 0){ //当字符串就为 "0" 的时候
sb.insert(0, current.resultStr);
}
}else{
sb.insert(0, current.resultStr);
}
}else{
if(last != null){
//当最后一个字符的 symbol 和当前的 symbol 一样 比如 最后一个为 （二 十 万） 现在的为 （三 百 万） 它们的symbol都为万
if(last.symbol.equals(current.symbol)){
if(last.sourceStr.equals("0")){
sb.insert(0, current.symbol);
}
sb.insert(0, current.amount);
}else{
sb.insert(0, current.symbol);
}
}
sb.insert(0, current.resultStr);
}
list.add(current);
}
return sb.toString();
}
public static void main(String[] args) {
E2C e = new E2C() ; String [] ss = new String[]{
"100000000.12"
,"10000001.45"
,"2400001.01"
,"45974623.80"
,"8900542.78"
,"0"
,"1010203200.992"
}; for (String s : ss) {
System.out.println(e.format(s));
}
}
}
//保存一位数的信息
class Bit{
public String sourceStr = ""; //转换前的字符串 （0 ~ 9）
public String resultStr = ""; //转换后的字符串（零 ~ 九）
public String symbol =""; //位的信息 （十 / 百 / 千 / 万 / 亿）
public String amount =""; //对位的数量修饰 (十 / 百 / 千)
public int index ; //当前这个字符 在源字符串里面是第几位（从后往前数）
public Bit(String sourceStr , int index){
this.sourceStr = sourceStr;
this.index = index ;
init();
}
//跟据 sourceStr 和 index 给其他几个属性赋值
public void init(){
resultStr = E2C.e2c.get(sourceStr); //将数字转换为 （零 ~ 九）
symbol = E2C.symbols[index];
amount = E2C.amounts[index];
}
} 一亿点一二
一千万零一点四五
二百四十万零一点零一
四千五百九十七万四千六百二十三点八零
八百九十万零五百四十二点七八
零
一十亿零一千万零二十万零三千二百点九九二
并说下思路。每一个字符串都分成两部分{
小数点之前的内容{
每一位数字用三部分组成
8900542
(八 百 万) (九 十 万)（零 null 万）（零 null 千）（五 null 百）（四 null 十）（二 null null）
从后向前解析
//...... 语言表达能力有限 不解释了。
} 小数点之后的内容
}
从小数点分开两半：
一、整数部分 ------------------------
1、每四位分开，按位数在后面加【亿/万】，如果为0怎跳过。
2、分开成四位后，按位数在后面加【十/百/千】，如果为0怎跳过。
3、每一位转换成对应中文汉字。
4、把整数首尾的0都过滤掉，因为不用输出。
5、把【零万零 / 零亿零】的情况替换成【万零 / 亿零】。
6、把多个零重叠的情况替换成一个零
7、把最高位为【一十】替换成【十】，如12应该读成十二，而不是一十二二、小数部分 ------------------------
比较简单，就不阐述了代码有点乱，楼主试试，看看有没有bug，: )
public class E2ChineseNum {
private static final int BIT_4 = 4;
private static final String DECIMAI_POINT = "\\u002E";
private static final String SPACE = " ";
private static final String[] CHINESE_NUM_NAME = {"零", "一", "二", "三", "四", "五", "六", "七", "八", "九"};
private static final String[] CHINESE_BIT_NAME = {"", "十", "百", "千"};
private static final String[] CHINESE_4_BIT_NAME = {"", "万", "亿"};
private String englishNum;
public String getChineseNum(String num) {
this.englishNum = num;
return toChineseNum();
}
private String pointBefore2ChineseNum(String strNum) { // 处理整数
List<String> chineseNumList = new LinkedList<String>();
int i = 0;
int end = strNum.length();
int begin = end - BIT_4;
do {
if (begin < 0) {
begin = 0;
}
String tempNum = strNum.substring(begin, end);
if (Integer.valueOf(tempNum) == 0) {
chineseNumList.add(0, getBit4Num(tempNum));
}
else {
chineseNumList.add(0, getBit4Num(tempNum) + CHINESE_4_BIT_NAME[i]);
}
i++;
end = begin;
begin = end - BIT_4;
}
while (end > 0);
String strRet = list2String(chineseNumList);
strRet = trimTailZero(strRet);
strRet = trimMidZero(strRet, CHINESE_4_BIT_NAME[1]);
strRet = trimMidZero(strRet, CHINESE_4_BIT_NAME[2]);
strRet = trimSameZero(strRet);
strRet = raplaceOneTen2Ten(strRet);
return strRet;
}
private String pointAfter2ChineseNum(String strNum) { // 处理小数
String strRet = "点";
for (char n : strNum.toCharArray()) {
strRet += getUnitName(Character.getNumericValue(n));
}
strRet = trimSameZero(strRet);
return strRet;
}
private String toChineseNum() { // 转换成中文数字
String[] nums = englishNum.split(DECIMAI_POINT);
String pointBefore = pointBefore2ChineseNum(nums[0]);
if (pointBefore == null || pointBefore.length() == 0) {
pointBefore = CHINESE_NUM_NAME[0];
}
String pointAfter = "";
if (nums.length > 1) {
pointAfter = pointAfter2ChineseNum(nums[1]);
}
return pointBefore + pointAfter;
}
public static String getUnitName(int n) { // 转换一个数字
if (n == 0) {
return SPACE;
}
else if (n > 0 && n <= 9) {
return CHINESE_NUM_NAME[n];
}
return "";
}
public static String trimMidZero(String strSrc, String replaceStr) { // 替换【零万零->万零】
strSrc = strSrc.replaceAll("\\s*" + replaceStr + "\\s+", replaceStr + CHINESE_NUM_NAME[0]);
strSrc = strSrc.replaceAll("\\s+" + replaceStr + "\\s*", replaceStr + CHINESE_NUM_NAME[0]);
return strSrc;
}
public String trimSameZero(String strSrc) { // 替换重复零
strSrc = strSrc.replaceAll("\\s+", CHINESE_NUM_NAME[0]);
return strSrc;
}
public static String trimTailZero(String strSrc) { // 过滤首尾的零
strSrc = strSrc.replaceAll("\\s*$", "");
strSrc = strSrc.replaceAll("^\\s*", "");
return strSrc;
}
public static String raplaceOneTen2Ten(String strSrc) { // 替换首位【一十 -> 十】
strSrc = strSrc.replaceAll("^一十", "十");
return strSrc;
}
public static String list2String(List<String> strlist) {
StringBuilder sb = new StringBuilder();
if (strlist == null || strlist.isEmpty()) {
return null;
}
ListIterator<String> itList = strlist.listIterator();
while (itList.hasNext()) {
sb.append(itList.next());
}
return sb.toString();
}
public static String getBit4Num(String strNum) { // 处理每4位数
List<String> retList = new LinkedList<String>();
for (int i = 0; i < strNum.length(); i++) {
char currentCh = strNum.charAt(strNum.length() - 1 - i);
int currentNum = Character.getNumericValue(currentCh);
if (currentNum == 0) {
retList.add(0, getUnitName(currentNum));
}
else {
retList.add(0, getUnitName(currentNum) + CHINESE_BIT_NAME[i]);
}
}
return list2String(retList);
}
public static void main(String[] args) {
E2ChineseNum e = new E2ChineseNum();
String [] ss = new String[]{
"100000000.12"
,"10000001.45"
,"2400001.01"
,"45974623.80"
,"8900542.78"
,"0.992"
,"0"
,"203200.992"
};
for (String s : ss) {
System.out.println(e.getChineseNum(s));
}
}
}
public static char[] numberTable = {'零', '一', '二', '三', '四', '五', '六', '七', '八', '九'}; public static void main(String[] args) {
System.out.println(numberToString(69213434631L));
System.out.println(numberToString(213434631));
System.out.println(numberToString(201434631));
System.out.println(numberToString(200000000));
System.out.println(numberToString(201000100));
System.out.println(numberToString(200000100));
System.out.println(numberToString(3434631));
System.out.println(numberToString(5032));
System.out.println(numberToString(5002));
System.out.println(numberToString(5000));
System.out.println(numberToString(100));
System.out.println(numberToString(102));
System.out.println(numberToString(552));
System.out.println(numberToString(50));
System.out.println(numberToString(52));
System.out.println(numberToString(5));
} /**
* 10000亿以下的整数的表示
* @param n 是一个10000亿以下的整数
* @return
*/
public static String numberToString(long n) {
if (n < 10000) {
return thousandToString(n);
} else {
String y = thousandToString(n / 100000000) + "亿"; String w = thousandToString(n % 100000000 / 10000) + "万";
w = (w.length() < 7 ? "零" : "") + w; String q = thousandToString(n % 10000);
q = (q.length() < 7 ? "零" : "") + q; return normalize(y + w + q);
}
} /**
* 10000以下的整数的中文表示
* @param thousand 是一个10000以下的整数
* @return
*/
public static String thousandToString(long thousand) {
if (thousand == 0) { return "零"; }
String result = ""
+ numberTable[(int)(thousand / 1000)] + "千"
+ numberTable[(int)(thousand % 1000 / 100)] + "百"
+ numberTable[(int)(thousand % 100 / 10)] + "十"
+ numberTable[(int)(thousand % 10)];
return normalize(result);
} /**
* 把整数表示中不合适的部分过滤掉，
* 例如: 零千零百零十二亿零千一百零十零万零千一百零十零
* 应为: 二亿零一百万零一百
* @param text
* @return
*/
public static String normalize(String text) {
text = text.replaceAll("(零十|零百|零千|零万|零亿)", "零");
text = text.replaceAll("零+", "零");
text = text.replaceAll("(^零|零$)", ""); return text;
}
}六百九十二亿一千三百四十三万四千六百三十一
二亿一千三百四十三万四千六百三十一
二亿零一百四十三万四千六百三十一
二亿
二亿零一百万零一百
二亿零一百
三百四十三万四千六百三十一
五千零三十二
五千零二
五千
一百
一百零二
五百五十二
五十
五十二
五
http://bbs.csdn.net/topics/390275427?page=1#post-392867820
package com.tur.demo;import java.util.Stack;public class Hello {
public static char[] numberTable = {'零', '一', '二', '三', '四', '五', '六', '七', '八', '九'};
public static char[] unitTable = {' ', '万', '亿'};
public static boolean debug = true; public static void main(String[] args) {
System.out.println(chineseNumber(6001343463100001L));
System.out.println(chineseNumber(6001040000346311L));
System.out.println(chineseNumber(6001003463100031L));
System.out.println(chineseNumber(69213434631L));
System.out.println(chineseNumber(213434631));
System.out.println(chineseNumber(201434631));
System.out.println(chineseNumber(200000000));
System.out.println(chineseNumber(201000100));
System.out.println(chineseNumber(200000100));
System.out.println(chineseNumber(3434631));
System.out.println(chineseNumber(5032));
System.out.println(chineseNumber(5002));
System.out.println(chineseNumber(5000));
System.out.println(chineseNumber(100));
System.out.println(chineseNumber(102));
System.out.println(chineseNumber(552));
System.out.println(chineseNumber(50));
System.out.println(chineseNumber(52));
System.out.println(chineseNumber(5)); System.out.println(chineseNumber(999990));
System.out.println(chineseNumber(6001343463100009L));
System.out.println(chineseNumber(6001003463100031L));
System.out.println(chineseNumber(9999999999999999L));
System.out.println(chineseNumber(9000000000101009L));
System.out.println(chineseNumber(9000000000009888L));
} /**
* 9999万亿以下的整数的表示
* @param n 是一个9999万亿亿以下的整数
* @return
*/
public static String chineseNumber(long n) {
int unit = 0;
Stack<String> stack = new Stack<String>(); do {
// 从后向前，每4位数字转换一次
int thousand = (int) (n % 10000);
n /= 10000; stack.push((thousand < 1000 ? "零" : "")
+ thousandToString(thousand)
+ unitTable[unit]); // 决定是以万还是以亿结尾
unit = (unit + 1) % unitTable.length;
unit = (unit == 0) ? ++unit : unit;
} while (n > 0); String result = "";
while (!stack.isEmpty()) {
result += stack.pop();
} trace("\n" + result);
return normalize(result);
} /**
* 10000以下的整数的中文表示
* @param thousand 是一个10000以下的整数
* @return
*/
public static String thousandToString(int thousand) {
if (thousand == 0) { return "零"; }
String result = ""
+ numberTable[thousand / 1000] + "千"
+ numberTable[thousand % 1000 / 100] + "百"
+ numberTable[thousand % 100 / 10] + "十"
+ numberTable[thousand % 10];
return normalize(result);
} /**
* 把整数表示中不合适的部分过滤掉，
* 例如: 零千零百零十二亿零千一百零十零万零千一百零十零
* 应为: 二亿零一百万零一百
* @param text
* @return
*/
public static String normalize(String text) {
text = text.replaceAll("\\s+", "");
text = text.replaceAll("零+亿", "亿"); // 亿是最大的单位
text = text.replaceAll("(零十|零百|零千|零万|零亿)", "零");
text = text.replaceAll("零+", "零");
text = text.replaceAll("(^零|零$)", ""); return text;
} public static void trace(String text) {
if (debug) {
System.out.println(text);
}
}
}/System/Library/Java/JavaVirtualMachines/1.6.0.jdk/Contents/Home/bin/java -Didea.launcher.port=7543 "-Didea.launcher.bin.path=/Applications/IntelliJ IDEA 11 CE.app/bin" -Dfile.encoding=UTF-8 -classpath "/System/Library/Java/JavaVirtualMachines/1.6.0.jdk/Contents/Home/lib/deploy.jar:/System/Library/Java/JavaVirtualMachines/1.6.0.jdk/Contents/Home/lib/dt.jar:/System/Library/Java/JavaVirtualMachines/1.6.0.jdk/Contents/Home/lib/javaws.jar:/System/Library/Java/JavaVirtualMachines/1.6.0.jdk/Contents/Home/lib/jce.jar:/System/Library/Java/JavaVirtualMachines/1.6.0.jdk/Contents/Home/lib/jconsole.jar:/System/Library/Java/JavaVirtualMachines/1.6.0.jdk/Contents/Home/lib/management-agent.jar:/System/Library/Java/JavaVirtualMachines/1.6.0.jdk/Contents/Home/lib/plugin.jar:/System/Library/Java/JavaVirtualMachines/1.6.0.jdk/Contents/Home/lib/sa-jdi.jar:/System/Library/Java/JavaVirtualMachines/1.6.0.jdk/Contents/Classes/charsets.jar:/System/Library/Java/JavaVirtualMachines/1.6.0.jdk/Contents/Classes/classes.jar:/System/Library/Java/JavaVirtualMachines/1.6.0.jdk/Contents/Classes/jsse.jar:/System/Library/Java/JavaVirtualMachines/1.6.0.jdk/Contents/Classes/ui.jar:/System/Library/Java/JavaVirtualMachines/1.6.0.jdk/Contents/Home/lib/ext/apple_provider.jar:/System/Library/Java/JavaVirtualMachines/1.6.0.jdk/Contents/Home/lib/ext/dnsns.jar:/System/Library/Java/JavaVirtualMachines/1.6.0.jdk/Contents/Home/lib/ext/localedata.jar:/System/Library/Java/JavaVirtualMachines/1.6.0.jdk/Contents/Home/lib/ext/sunjce_provider.jar:/System/Library/Java/JavaVirtualMachines/1.6.0.jdk/Contents/Home/lib/ext/sunpkcs11.jar:/Users/Biao/Documents/workspace/Intellij/Hello/target/classes:/Users/Biao/.m2/repository/tablelayout/TableLayout/20050920/TableLayout-20050920.jar:/Users/Biao/.m2/repository/org/mybatis/mybatis/3.1.1/mybatis-3.1.1.jar:/Users/Biao/.m2/repository/mysql/mysql-connector-java/5.1.21/mysql-connector-java-5.1.21.jar:/Users/Biao/.m2/repository/dom4j/dom4j/1.6.1/dom4j-1.6.1.jar:/Users/Biao/.m2/repository/xml-apis/xml-apis/1.0.b2/xml-apis-1.0.b2.jar:/Users/Biao/.m2/repository/jaxen/jaxen/1.1.4/jaxen-1.1.4.jar:/Users/Biao/.m2/repository/org/apache/mina/mina-core/2.0.5/mina-core-2.0.5.jar:/Users/Biao/.m2/repository/org/slf4j/slf4j-api/1.7.1/slf4j-api-1.7.1.jar:/Users/Biao/.m2/repository/org/apache/mina/mina-filter-compression/2.0.5/mina-filter-compression-2.0.5.jar:/Users/Biao/.m2/repository/com/jcraft/jzlib/1.1.1/jzlib-1.1.1.jar:/Users/Biao/.m2/repository/org/apache/mina/mina-transport-apr/2.0.5/mina-transport-apr-2.0.5.jar:/Users/Biao/.m2/repository/tomcat/tomcat-apr/5.5.23/tomcat-apr-5.5.23.jar:/Users/Biao/.m2/repository/org/apache/mina/mina-transport-serial/2.0.5/mina-transport-serial-2.0.5.jar:/Users/Biao/.m2/repository/org/apache/mina/mina-example/2.0.5/mina-example-2.0.5.jar:/Users/Biao/.m2/repository/ognl/ognl/3.0.5/ognl-3.0.5.jar:/Users/Biao/.m2/repository/javassist/javassist/3.11.0.GA/javassist-3.11.0.GA.jar:/Users/Biao/.m2/repository/jboss/javassist/3.7.ga/javassist-3.7.ga.jar:/Users/Biao/.m2/repository/commons-lang/commons-lang/2.6/commons-lang-2.6.jar:/Users/Biao/.m2/repository/org/springframework/spring/2.5.6.SEC03/spring-2.5.6.SEC03.jar:/Users/Biao/.m2/repository/org/slf4j/jcl-over-slf4j/1.6.6/jcl-over-slf4j-1.6.6.jar:/Users/Biao/.m2/repository/org/slf4j/slf4j-log4j12/1.7.1/slf4j-log4j12-1.7.1.jar:/Users/Biao/.m2/repository/log4j/log4j/1.2.17/log4j-1.2.17.jar:/Applications/IntelliJ IDEA 11 CE.app/lib/idea_rt.jar" com.intellij.rt.execution.application.AppMain com.tur.demo.Hello六千零一万三千四百三十四亿六千三百一十万零一
六千零一万三千四百三十四亿六千三百一十万零一六千零一万零四百亿零三十四万六千三百一十一
六千零一万零四百亿零三十四万六千三百一十一六千零一万零三十四亿六千三百一十万零三十一
六千零一万零三十四亿六千三百一十万零三十一零六百九十二亿一千三百四十三万四千六百三十一
六百九十二亿一千三百四十三万四千六百三十一零二亿一千三百四十三万四千六百三十一
二亿一千三百四十三万四千六百三十一零二亿零一百四十三万四千六百三十一
二亿零一百四十三万四千六百三十一零二亿零零万零零
二亿零二亿零一百万零一百
二亿零一百万零一百零二亿零零万零一百
二亿零一百零三百四十三万四千六百三十一
三百四十三万四千六百三十一五千零三十二
五千零三十二五千零二
五千零二五千
五千零一百
一百零一百零二
一百零二零五百五十二
五百五十二零五十
五十零五十二
五十二零五
五零九十九万九千九百九十
九十九万九千九百九十六千零一万三千四百三十四亿六千三百一十万零九
六千零一万三千四百三十四亿六千三百一十万零九六千零一万零三十四亿六千三百一十万零三十一
六千零一万零三十四亿六千三百一十万零三十一九千九百九十九万九千九百九十九亿九千九百九十九万九千九百九十九
九千九百九十九万九千九百九十九亿九千九百九十九万九千九百九十九九千万零零亿零一十万一千零九
九千万亿零一十万一千零九九千万零零亿零零万九千八百八十八
九千万亿零九千八百八十八Process finished with exit code 0
我根据前面几个大侠的代码，写了一个直接在循环里处理0的方式
看半天都是java代码，仔细一看是java的版块，不好意思，我用C#写的program.csusing System;
using System.Collections.Generic;
using System.Linq;
using System.Text;namespace TransNumber
{
class Program
{
static void Main(string[] args)
{
string[] s = new string[] { "11111.23453",
"1324409090000000",
"300000012",
"1.34340434",
"100000000.32",
"12",
"110002",
"8000000000000000",
"9999999999999999"
};
for (int i = 0; i < s.Length; i++)
{
Console.WriteLine(s[i]);
Console.WriteLine(TransNumber.format(s[i]));
}
Console.Read();
}
}
}TransNumber.csusing System;
using System.Collections.Generic;
using System.Linq;
using System.Text;namespace TransNumber
{
public class TransNumber
{
/// <summary>
/// 最高16位 即 千万亿
/// </summary>
/// <param name="num"></param>
/// <returns></returns>
public static string format(string num)
{
if (num.Contains("."))//带小数点
{
string[] ns = num.Split(new char[] { '.' });
return formatBefore(ns[0]) + formatAfter(ns[1]);
}
else//不带小数点
{
return formatBefore(num);
}
}
/// <summary>
/// 小数点前
/// </summary>
/// <param name="before"></param>
/// <returns></returns>
static string formatBefore(string before)
{
string retStr = "";
//for (int i = 0; i < before.Length; i++)
//{
// string b = before.Substring(i, 1);
// retStr += transNumber(b) + retWei(before.Length - i);
//} bool bZero = false;//前驱是否有0标识
for (int i = 0; i < before.Length; i++)
{
string b = before.Substring(i, 1);
if (b == "0")//数字0的处理
{
if (i == before.Length - 1)//个位数不处理
{ }
else//非个位数处理
{
if (i == before.Length - 5)//当前位是万位
{
if (before.Length >= 9 && before.Substring(before.Length - 8, 3) == "000")
{ }//亿和万之间全0 不补万
else
retStr += "万";
}
if (i == before.Length - 13)//万亿补万
{
retStr += "万";
}
if (i == before.Length - 9)//亿补亿
{
retStr += "亿";
}
bZero = true;
}
}
else//非零数字处理
{
if (bZero)//前驱有数补0
retStr += "零" + transNumber(b) + retWei(before.Length - i);
else
retStr += transNumber(b) + retWei(before.Length - i);
bZero = false;
}
} return retStr;
}
/// <summary>
/// 小数点后
/// </summary>
/// <param name="after"></param>
/// <returns></returns>
static string formatAfter(string after)
{
string retStr = "点";
for (int i = 0; i < after.Length; i++)
{
string b = after.Substring(i, 1);
retStr += transNumber(b);
}
return retStr;
} static string transNumber(string i)
{
string str = null;
switch (i)
{
case "0": str = "零"; break;
case "1": str = "一"; break;
case "2": str = "二"; break;
case "3": str = "三"; break;
case "4": str = "四"; break;
case "5": str = "五"; break;
case "6": str = "六"; break;
case "7": str = "七"; break;
case "8": str = "八"; break;
case "9": str = "九"; break;
default:
break;
}
return str;
}
static string retWei(int i)
{
string str = null;
switch (i)
{
case 1: str = ""; break;
case 2: str = "十"; break;
case 3: str = "百"; break;
case 4: str = "千"; break;
case 5: str = "万"; break;
case 6: str = "十"; break;
case 7: str = "百"; break;
case 8: str = "千"; break;
case 9: str = "亿"; break;
case 10: str = "十"; break;
case 11: str = "百"; break;
case 12: str = "千"; break;
case 13: str = "万"; break;
case 14: str = "十"; break;
case 15: str = "百"; break;
case 16: str = "千"; break;
default: str = ""; break;//其它情况下返回空
}
return str;
}
}
}
十亿九千万 or 十亿零九千万？
三十万八千 or 三十万零八千？
2.要考虑到很多的情况(比如)：
a.100 000 000.12（一亿点一二）； -> 小数点这边 可以先分割获取两数组一小数 一个数
b.10 000 001.45（一千万零一点四五）；->一千万零一点 难点在于这个零加上还是不加 这个可以用取余的方法来判断
c.2 400 001.01(二百四十万零一点零一)；->小数点的0都加零咯，简单了
d.45 974 623.80（四千五百九十七万四千六百二十三点八零);
e.8 900 542.78(八百九十万零五百四十二点七八)；
{ private static final String[] NUMBER = { "零", "壹", "贰", "叁", "肆", "伍", "陆",
"柒", "捌", "玖" };
private static final String[] UNIT = { "圆", "拾", "百", "千", "万", "拾", "百",
"千", "亿", "拾", "百", "千" };
private static final String[] UNIT2 = { "分", "角" }; public static void main(String[] args)
{
System.out.println(numChangeMoney("890342000303.34"));
} /**
* 转换数字到中文大写金额
*/
public static String numChangeMoney(String s)
{
String money = "";
String intPartNum = ""; // 保存字符串的整数部分
String decimalPartNum = ""; // 保存字符串的小数部分
int pointIndex = 0; // 小数点的索引位置 pointIndex = s.indexOf("."); // 查找小数点的index值 /**
* 判断是否是小数,如果是小数，就拆分s字符串分别赋值给整数部分和小数部分的变量, 否则说明是整数，直接把s的值赋值给整数部分的变量
*/
if (pointIndex != -1)
{
intPartNum = s.substring(0, pointIndex);
decimalPartNum = s.substring(pointIndex + 1);
}
else
{
intPartNum = s;
} if (intPartNum.length() > 12 || decimalPartNum.length() > 2)
{
return "数字大小或者精度超出转换访问，不能转换！(最大转换数字为千亿位，小数点精度是两位！例如：333333.33)";
} // 合并整数部分和小数部分的转换后的金额字符串
money = intChange(intPartNum)
+ (decimalChange(decimalPartNum).length() == 0 ? "整"
: decimalChange(decimalPartNum)); return money;
} /**
* 处理整数部分的数字转金额
*/
private static String intChange(String s)
{
String money = ""; for (int i = 0; i < s.length(); i++)
{
money = money + NUMBER[Integer.parseInt(s.substring(i, i + 1))]; // 数字转换
money = money + UNIT[s.length() - i - 1]; // 单位转换
} // 处理带零的字符串金额
money = money.replace("壹拾", "拾");
money = money.replace("零拾", "零");
money = money.replace("零百", "零");
money = money.replace("零千", "零"); money = money.replace("零零零", "零");
money = money.replace("零零", "零"); money = money.replace("零亿", "亿");
money = money.replace("零万", "万");
money = money.replace("零圆", "圆"); return money;
} /**
* 处理小数部分的数字转金额
*/
private static String decimalChange(String s)
{
String money = ""; for (int i = 0; i < s.length(); i++)
{
money = money + NUMBER[Integer.parseInt(s.substring(i, i + 1))]; // 数字转换
money = money + UNIT2[s.length() - i - 1]; // 单位转换
} // 处理带零的字符串金额
money = money.replace("零角", "");
money = money.replace("零分", ""); return money;
}
}
这个程序可以处理任意长度的数字，按照万 亿 亿亿 亿亿亿 进行划分。
package lwj.csdn;import java.util.*;public class Digit2Chinese {
private Stack<String> stack ;//存储转换后的字符串
private HashMap<Character, String > map = new HashMap<Character, String>();
public Digit2Chinese(){
init();
}
public static void main(String[] args) {
Digit2Chinese d2c = new Digit2Chinese();
String str = d2c.transfer("100001121.37834");
System.out.println( str ) ;
}
public String transfer( String str )
{
String[] beforeTransfer = str.trim().split("\\.") ; //分割要转换的字符串
// 处理小数部分 ***************************************************************
for(int i = beforeTransfer[1].length()-1 ; i >= 0; i--)
{
char ch = beforeTransfer[1].charAt(i);
stack.push( map.get(ch));
}
stack.push("点");
// 处理整数部分 ****************************************************
// 去除整数字符串部分前面的0， 这里省略，欢迎大家补充这部分
StringBuilder builder = new StringBuilder( beforeTransfer[0]) ;
// for 循环将整数部分字符串四位四位分组
String[] splitstr = new String[ builder.length()/4+1];
for( int i = 0 ; i < splitstr.length ; i++ ) {
if( builder.length()> 4){
splitstr[i] = builder.substring(builder.length() -4) ;
builder.delete(builder.length() -4, builder.length() );
}
else
{
splitstr[i]= builder.toString() ;
}
}
// ******************************************
// 标记每个4位分组是否为全0
boolean[] splitflag = new boolean[ splitstr.length ] ;
for( int j = 0 ; j < splitflag.length ; j++) {
if( splitstr[j].equals("0000")) {
splitflag[j] = true ;
}else
splitflag[j] = false ;
}
//********************************************
// 逐个分组进行处理并入栈，处理顺序为从低位分组到高位分组
for( int k = 0 ; k < splitstr.length ; k++){
// 处理分组为全0的情况.这部分最费脑筋了！
if(splitflag[k]){
if( k -1>= 0){
stack.pop() ;
if(stack.peek() !="零"&&stack.peek().charAt(0)!='零')
stack.push("零") ;
}
}// 处理分组的四位数字中不全为0的情况
else{
switch( splitstr[k].length()){
case 4 : parse4Str( splitstr[k]) ;
break ;
case 3 : parse3Str( splitstr[k]) ;
break ;
case 2 : parse2Str( splitstr[k]) ;
break ;
case 1 : parse1Str( splitstr[k]) ;
break ;
default:
break ;
}
}
// 加上进制单位
if( k == 0&&k != splitstr.length-1){
stack.push("万");
}
if( k>0 && k != splitstr.length -1){
String unit = "";
for( int i = 0 ; i < k ; i++)
unit +="亿" ;
stack.push(unit);
}
}//结束 处理各个分组的 for循环
// 获得最终的字符串
String resultstr="";
while( !stack.empty()){
resultstr += stack.pop() ;
}
return resultstr ;
}//结束 transfer 方法
private void parse4Str( String str ) {
String str4 = str ;
StringBuilder builder4 = new StringBuilder();
if( str4.charAt(0) == '0'){
builder4.append("零");
}
else
{
builder4.append( map.get(str4.charAt(0))) ;
builder4.append("千");
}
if( str4.charAt(1) == '0'){
if ( str4.charAt(0) !='0'&&(str4.charAt(2)!='0'||str4.charAt(3)!='0'))
builder4.append("零");
}
else
{
builder4.append( map.get(str4.charAt(1))) ;
builder4.append("百");
}
if( str4.charAt(2) == '0'){
if( str4.charAt(1)!='0'&&str4.charAt(3)!='0')
builder4.append("零");
}
else
{
builder4.append( map.get(str4.charAt(2))) ;
builder4.append("十");
}
if( str4.charAt(3) != '0'){
builder4.append( map.get(str4.charAt(3))) ;
} stack.push(builder4.toString());
}
private void parse3Str( String str) {
String builder = str ;
StringBuilder builder3 = new StringBuilder();
builder3.append(map.get(builder.charAt(0)));
builder3.append("百");
if( builder.charAt(1) == '0'){
if( builder.charAt(2)!='0')
builder3.append("零");
}else
{
builder3.append(map.get(builder.charAt(1)));
builder3.append("十");
}
if( builder.charAt(2)!='0')
builder3.append( map.get(builder.charAt(2)));
stack.push(builder3.toString());
}
private void parse2Str( String str ) {
String builder = str ;
StringBuilder builder2 = new StringBuilder();
builder2.append(map.get(builder.charAt(0)));
builder2.append("十");
if( builder.charAt(1) != '0'){
builder2.append(map.get(builder.charAt(1)));
}
stack.push(builder2.toString());
}
private void parse1Str( String str ) {
stack.push( map.get(str.charAt(0)));
}
private void init()
{
stack = new Stack<String>();
map.put('0', "零") ;
map.put('1', "一");
map.put('2', "二");
map.put('3', "三");
map.put('4', "四");
map.put('5', "五") ;
map.put('6', "六");
map.put('7', "七");
map.put('8', "八");
map.put('9', "九");
}
}
using System.Collections.Generic;
using System.Linq;
using System.Text;namespace CSDN
{
class Program
{
static void Main(string[] args)
{
Dictionary<string, string> word = new Dictionary<string, string>();
word.Add("0", "零");
word.Add("1","一");
word.Add("2", "二");
word.Add("3", "三");
word.Add("4", "四");
word.Add("5", "五");
word.Add("6", "六");
word.Add("7", "七");
word.Add("8", "八");
word.Add("9", "九");
string[] ws = { "", "十", "百", "千"};
Calc(word, ws, "100000000.12");
Calc(word, ws, "10000001.45");
Calc(word, ws, "2400001.01");
Calc(word, ws, "45974623.80");
Calc(word, ws, "8900542.78");
Calc(word, ws, "0010002005.0050");
Calc(word, ws, "1000000");
Console.ReadKey();
} private static void Calc(Dictionary<string, string> word, string[] ws, string str)
{
string[] arrs = str.Split('.');
char[] arr1 = arrs[0].ToCharArray();
StringBuilder sb = new StringBuilder();
int Zero = 0;//标记0连续的个数
int j = 0;//for循环后到达的数量级 个、十、百...
int w = 0;//标记万
int y = 0;//标记亿
//整数部分
for (int i = arr1.Length - 1; i >= 0; i--)
{
string num = word[arr1[i].ToString()];
if (num == "零")
Zero++;
else
{
if (Zero > 0)
{
if (j > 0)
sb.Append("零");
j += Zero;
Zero = 0;
}
w = IsHasWY(j, w, 4, 7, "万", sb);
y = IsHasWY(j, y, 8, 11, "亿", sb);
sb.Append(ws[j%4]);
sb.Append(num);
j++;
}
}
string strEnd = "";
char[] c = sb.ToString().ToArray();
Array.Reverse(c);
strEnd = new string(c);
sb.Clear();
//小数部分
if(str.Contains("."))
{
char[] arr2 = arrs[1].ToCharArray();
if (arr2.Length > 0)
{
sb.Append("点");
for (int i = 0; i < arr2.Length; i++)
{
sb.Append(word[arr2[i].ToString()]);
}
}
}
Console.WriteLine(strEnd + sb.ToString());
} /// <summary>
/// 判断是否要添加"万"、"亿"
/// </summary>
/// <param name="num">要判断的位数</param>
/// <param name="minNum">标记</param>
/// <param name="minNum">最小位数</param>
/// <param name="maxNum">最大位数</param>
/// <param name="word">要加入的字</param>
/// <param name="list">加入到的地方</param>
private static int IsHasWY(int num,int ,int minNum, int maxNum, string word,StringBuilder sb)
{
if (num >= minNum && num <= maxNum)
{
if ( == 0)
{
sb.Append(word);
++;
}
}
else
=0;
return ;
}
}
}结果：
测试：
import java.util.Arrays;
import java.util.List;
/**
*
* @date 29/10/2012
*/
public class NumberTextTest {
public static void main(String[] args) {
List<String> numbers = Arrays.asList(
"100 000 000.12",
"10 000 001.45",
"2 400 001.01",
"45 974 623.80",
"8 900 542.78"
);
NumberText nt = NumberText.getInstance(NumberText.Lang.ChineseSimplified);
for(String number : numbers) {
String[] tokens = number.replaceAll(" ", "").split("\\.");
System.out.print(nt.getText(Long.parseLong(tokens[0])));
if( tokens.length > 1 ) {
System.out.print("点");
for(int i=0; i<tokens[1].length(); i++)
System.out.print(nt.getText(tokens[1].charAt(i) - '0'));
}
System.out.println();
}
}
}
运行结果：run:
一亿点一二
一千万零一点四五
二百四十万零一点零一
四千五百九十七万四千六百二十三点八零
八百九十万零五百四十二点七八
BUILD SUCCESSFUL (total time: 0 seconds)
private static final String[] pattern = { "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖" };
private static final String[] cPattern = { "", "拾", "佰", "仟", "万", "拾", "佰", "仟", "亿" };
private static final String[] cfPattern = { "毫", "角", "分" };
private static final String ZEOR = "零"; public static String format(String moneyString) {
int dotPoint = moneyString.indexOf("."); // 判断是否为小数
String moneyStr;
if (dotPoint != -1) {
moneyStr = moneyString.substring(0, moneyString.indexOf("."));
} else {
moneyStr = moneyString;
}
StringBuffer fraction = null; // 小数部分的处理,以及最后的yuan.
StringBuffer ms = new StringBuffer();
for (int i = 0; i < moneyStr.length(); i++) {
ms.append(pattern[moneyStr.charAt(i) - 48]); // 按数组的编号加入对应大写汉字
}
int cpCursor = 1;
for (int j = moneyStr.length() - 1; j > 0; j--) {
ms.insert(j, cPattern[cpCursor]); // 在j之后加字符,不影响j对原字符串的相对位置
// 只是moneyStr.length()不断增加
// insert(j,"string")就在j位置处插入,j=0时为第一位
cpCursor = cpCursor == 8 ? 1 : cpCursor + 1; // 亿位之后重新循环
}
while (ms.indexOf("零拾") != -1) { // 当十位为零时用一个"零"代替"零拾"
// replace的起始于终止位置
ms.replace(ms.indexOf("零拾"), ms.indexOf("零拾") + 2, ZEOR);
}
while (ms.indexOf("零佰") != -1) { // 当百位为零时,同理
ms.replace(ms.indexOf("零佰"), ms.indexOf("零佰") + 2, ZEOR);
}
while (ms.indexOf("零仟") != -1) { // 同理
ms.replace(ms.indexOf("零仟"), ms.indexOf("零仟") + 2, ZEOR);
}
while (ms.indexOf("零万") != -1) { // 万需保留，中文习惯
ms.replace(ms.indexOf("零万"), ms.indexOf("零万") + 2, "万");
}
while (ms.indexOf("零亿") != -1) { // 同上
ms.replace(ms.indexOf("零亿"), ms.indexOf("零亿") + 2, "亿");
}
while (ms.indexOf("零零") != -1) {// 有连续数位出现零，即有以下情况，此时根据习惯保留一个零即可
ms.replace(ms.indexOf("零零"), ms.indexOf("零零") + 2, ZEOR);
}
while (ms.indexOf("亿万") != -1) { // 特殊情况，如:100000000,根据习惯保留高位
ms.replace(ms.indexOf("亿万"), ms.indexOf("亿万") + 2, "亿");
}
while (ms.length() > 1 && ms.lastIndexOf("零") == ms.length() - 1) { // 当结尾为零j，不必显示,经过处理也只可能出现一个零
ms.delete(ms.lastIndexOf("零"), ms.lastIndexOf("零") + 1);
}
int end;
if ((dotPoint = moneyString.indexOf(".")) != -1) { // 是小数的进入
String fs = moneyString.substring(dotPoint + 1, moneyString
.length());
if (fs.indexOf("00") == -1 || fs.indexOf("00") >= 2) {// 若前两位小数全为零，则跳过操作
end = fs.length() > 2 ? 2 : fs.length(); // 仅保留两位小数
boolean isInt = false;
if (end == 1 && fs.toString().endsWith("0")) {
end = 0;
isInt = true;
}
fraction = new StringBuffer(fs.substring(0, end));
for (int j = 0; j < fraction.length(); j++) {
fraction
.replace(j, j + 1, pattern[fraction.charAt(j) - 48]); // 替换大写汉字
}
for (int i = fraction.length(); i > 0; i--) { // 插入中文标识
fraction.insert(i, cfPattern[i]);
}
if (isInt)
fraction = new StringBuffer("元");
else
fraction.insert(0, "元"); // 为整数部分添加标识
} else {
fraction = new StringBuffer("元");
}
} else {
fraction = new StringBuffer("元");
} ms.append(fraction); // 加入小数部分
return ms.toString();
} public static String format_Wan(String moneyString) { try {
double monNumber = Double.parseDouble(moneyString) / 10000;
moneyString = String.valueOf(monNumber);
int dotPoint = moneyString.indexOf("."); // 判断是否为小数
String moneyStr;
if (dotPoint != -1) {
moneyStr = moneyString.substring(0, dotPoint);
} else {
moneyStr = moneyString;
}
StringBuffer fraction = null; // 小数部分的处理,以及最后的元.
StringBuffer ms = new StringBuffer();
for (int i = 0; i < moneyStr.length(); i++) {
ms.append(pattern[moneyStr.charAt(i) - 48]); // 按数组的编号加入对应大写汉字
} int cpCursor = 1;
for (int j = moneyStr.length() - 1; j > 0; j--) {
ms.insert(j, cPattern[cpCursor]); // 在j之后加字符,不影响j对原字符串的相对位置
// 只是moneyStr.length()不断增加
// insert(j,"string")就在j位置处插入,j=0时为第一位
cpCursor = cpCursor == 8 ? 1 : cpCursor + 1; // 亿位之后重新循环
} while (ms.indexOf("零拾") != -1) { // 当十位为零时用一个"零"代替"零拾"
// replace的起始于终止位置
ms.replace(ms.indexOf("零拾"), ms.indexOf("零拾") + 2, ZEOR);
}
while (ms.indexOf("零佰") != -1) { // 当百位为零时,同理
ms.replace(ms.indexOf("零佰"), ms.indexOf("零佰") + 2, ZEOR);
}
while (ms.indexOf("零仟") != -1) { // 同理
ms.replace(ms.indexOf("零仟"), ms.indexOf("零仟") + 2, ZEOR);
}
while (ms.indexOf("零万") != -1) { // 万需保留，中文习惯
ms.replace(ms.indexOf("零万"), ms.indexOf("零万") + 2, "万");
}
while (ms.indexOf("零亿") != -1) { // 同上
ms.replace(ms.indexOf("零亿"), ms.indexOf("零亿") + 2, "亿");
}
while (ms.indexOf("零零") != -1) {// 有连续数位出现零，即有以下情况，此时根据习惯保留一个零即可
ms.replace(ms.indexOf("零零"), ms.indexOf("零零") + 2, ZEOR);
}
while (ms.indexOf("亿万") != -1) { // 特殊情况，如:100000000,根据习惯保留高位
ms.replace(ms.indexOf("亿万"), ms.indexOf("亿万") + 2, "亿");
}
while (ms.length() > 1 && ms.lastIndexOf("零") == ms.length() - 1) { // 当结尾为零，不必显示,经过处理也只可能出现一个零
ms.delete(ms.lastIndexOf("零"), ms.lastIndexOf("零") + 1);
} int end;
if ((dotPoint = moneyString.indexOf(".")) != -1) { // 是小数的进入
String fs = moneyString.substring(dotPoint + 1, moneyString
.length());
if (!fs.startsWith("00")) {// 如果前两位小数位不是00
end = fs.length() > 2 ? 2 : fs.length(); // 仅保留两位小数
fraction = new StringBuffer(fs.substring(0, end));
for (int j = 0; j < fraction.length(); j++) {
fraction.replace(j, j + 1,
pattern[fraction.charAt(j) - 48]); // 替换大写汉字
}
}
} // 加入小数部分
if (fraction != null) { if (fraction.length() >= 0) {
if (!fraction.toString().equals("零"))
ms.append("点" + fraction);
}
}
while (ms.length() > 1 && ms.toString().endsWith("零")) {
ms.delete(ms.lastIndexOf("零"), ms.lastIndexOf("零") + 1);
}
return ms.toString() + "万元";
} catch (Exception e) {
return moneyString + "万元";
}
} public static double myRound(double num) {
BigDecimal b = new BigDecimal(num);
num = b.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
return num;
} public static void main(String args[]) {
//System.out.println(format("12345678.12"));
System.out.println(format(String.valueOf(String.format("%10.5", 0.12*10000))));
}
}
import java.util.Scanner;public class Math {
private static final String[] pattern = { "零", "壹", "贰", "叁", "肆", "伍",
"陆", "柒", "捌", "玖" };
private static final String[] bPattern= { "万","拾","佰","仟","亿","拾","佰","仟"};
private static final String ZEOR = "零";
public static void main(String[] args){
while(true){
Scanner console=new Scanner(System.in);
System.out.println("请输入要转化的数字:");
String math=new String(console.nextLine());
StringBuffer ms=new StringBuffer();
if(math.indexOf(".")==-1){
ms=toWan(math);
}else{
ms=toWan(math.substring(0,math.indexOf(".")));
String sf=math.substring(math.indexOf(".")+1,math.length());
ms.insert(ms.length()-1, "点");
for(int i=0;i<sf.length();i++){
ms.insert(ms.length()-1,pattern[sf.charAt(i)-48]);
}
while (ms.length() > 1 && ms.lastIndexOf("零") == ms.length() - 2) {
ms.delete(ms.lastIndexOf("零"), ms.lastIndexOf("零") + 1);
}
}
System.out.println(ms);
}
}
public static StringBuffer toWan(String str){
StringBuffer math=new StringBuffer(str);
StringBuffer ms=new StringBuffer();
math=math.reverse();
for(int i=0;i<math.length();i++){
ms.append(pattern[math.charAt(i)-48]);
ms.append(bPattern[i%8]);
}
ms=ms.reverse();
for(int j=0;j<ms.length()/2;j++){
String t=ms.substring(2*j+1, 2*(j+1));
t+=ms.substring(2*j, 2*j+1);
ms.replace(2*j, 2*(j+1), t);
}
while (ms.indexOf("零拾") != -1) {
// replace的起始于终止位置
ms.replace(ms.indexOf("零拾"), ms.indexOf("零拾") + 2, ZEOR);
}
while (ms.indexOf("零佰") != -1) {
ms.replace(ms.indexOf("零佰"), ms.indexOf("零佰") + 2, ZEOR);
}
while (ms.indexOf("零仟") != -1) {
ms.replace(ms.indexOf("零仟"), ms.indexOf("零仟") + 2, ZEOR);
}
while (ms.indexOf("零万") != -1) {
ms.replace(ms.indexOf("零万"), ms.indexOf("零万") + 2, "万");
}
while (ms.indexOf("零亿") != -1) {
ms.replace(ms.indexOf("零亿"), ms.indexOf("零亿") + 2, "亿");
}
while (ms.indexOf("零零") != -1) {
ms.replace(ms.indexOf("零零"), ms.indexOf("零零") + 2, ZEOR);
}
return ms;
}
}
转化为万元，从最低位开始算起
import java.util.List;
import java.util.Scanner;public class MathDemo {
private static final String[] pattern = { "零", "壹", "贰", "叁", "肆", "伍",
"陆", "柒", "捌", "玖" };
private static final String[] bPattern= { "万","拾","佰","仟","亿","拾","佰","仟"};
private static final String ZEOR = "零";
public static void main(String[] args) {
while(true){
System.out.println("请输入要转化的数字");
Scanner console=new Scanner(System.in);
String math=new String(console.nextLine());
StringBuffer ms=new StringBuffer();
if(math.indexOf(".")==-1){
ms=toWan(math);
}else{
ms=toWan(math.substring(0,math.indexOf(".")));
String sf=math.substring(math.indexOf(".")+1,math.length());
ms.insert(ms.length()-1, "点");
for(int i=0;i<sf.length();i++){
ms.insert(ms.length()-1,pattern[sf.charAt(i)-48]);
}
while (ms.length() > 1 && ms.lastIndexOf("零") == ms.length() - 2) {
ms.delete(ms.lastIndexOf("零"), ms.lastIndexOf("零") + 1);
}
}
//System.out.println(ms);
wantonumber(ms.toString());
}
}
public static StringBuffer toWan(String str){
StringBuffer ms=new StringBuffer();
List<String> list=new ArrayList<String>();
int k=str.length()-1;
for(int i=k;i>=0;i--){
String st=pattern[str.charAt(i)-48];
st+=bPattern[(k-i)%8];
list.add(st);
}
for(int j=list.size()-1;j>=0;j--){
ms.append(list.get(j));
}
return ms;
}
}
转换为万元 从最低开始 比上面简单些
楼主可以试试 中文转行为数字 以元和万元为单位
sysout("test");
}
可能思路有点乱，欢迎指正
public class test
{
public static void main(String[] args)
{
output("100000000.12");
}
public static void output(String ch)
{
String[] num = ch.split("\\.");
if(num.length>2) //是否有多个小数点
{
System.out.println("error");
System.exit(0);
}
boolean isnum = num[0].matches("[0-9]+") & num[1].matches("[0-9]+"); //正则表达式判断是否为数字串
if(!isnum) System.exit(0); //不是数字串则退出程序
//处理小数点前面的部分num[0]
String[] a = num[0].split(""); //分隔小数点前的部分，0号单元为空
String[] b = num[1].split(""); //分隔小数点后的部分
exchange(a); //输出前半部分
System.out.print("点");
//输出后半部分
for(int i=1;i<b.length;++i)
System.out.print(change(b[i]));
}
public static void exchange(String[] ch)
{
String[] name = {"","万","亿"};
int length = ch.length-1;
int p,i,j;
p=(length%4==0)?length/4:(length/4)+1; //将数字按四位分段
j=p-1; //根据段数分配name的下标
for(i=-1;i<p-1;++i)
{
if(length==1&&ch[1].equals("0")){System.out.print("零");break;} //若小数点前面部分为0
//开始分析
if(i==-1&&length%4!=0)
{
if(getname(ch,1,length%4)==0)
System.out.print(name[j--]);
}
else if(i==-1&&length%4==0)
{
if(getname(ch,1,4)==0)
System.out.print(name[j--]);
}
else if(length%4!=0)
{
if(getname(ch,i*4+length%4+1,(i+1)*4+length%4)==0)
System.out.print(name[j--]);
}
else if(length%4==0)
{
if(getname(ch,(i+1)*4+1,(i+2)*4)==0)
System.out.print(name[j--]);
}
}
}
public static int getname(String[] ch,int start,int end) //四位处理函数
{
String[] name = {"","十","百","千"};
int j=end-start,i;
while(ch[end].equals("0")){--end;} //此处处理后面几位都为0的情况，如：2460,3400,1000
if(end<start) return 1;
for(i=start;i<=end;++i)
{
if(ch[i].equals("0")&&ch[i+1].equals("0")&&i!=end){--j;continue;}
else if(ch[i].equals("0"))
{
System.out.print(change(ch[i]));
--j;
}
else System.out.print(change(ch[i]) + name[j--]);
}
return 0;
}
public static String change(String a)
{
switch(a)
{
case "0":return "零";
case "1":return "一";
case "2":return "二";
case "3":return "三";
case "4":return "四";
case "5":return "五";
case "6":return "六";
case "7":return "七";
case "8":return "八";
case "9":return "九";
default:return "error";
}
}
}
public class ReadChinaNum {
static final String[] chinaNum={"零","壹","貮","叁","肆","伍","陆","柒","捌","染","拾"};
static final String[] chinaUnit={"","十","百","千","万","十","百","千","亿","十","百","千","万亿"};
public static void main(String[] args) {
Scanner scan=new Scanner(new InputStreamReader(System.in));
String input=scan.nextLine();
String[] num=input.split("\\."); //分为小数点前和后的数据
//暂未做正则判断
StringBuilder readChina=new StringBuilder(); //结果
String currentnum,nextnum; //当前数和下一位数
int number,nextone; //转为了整型
for(int i=0;i<num[0].length();i++)
{
String temp=num[0].substring(i);
currentnum=temp.substring(0,1);
number=Integer.parseInt(currentnum);
if(number==0)
{ int t=temp.length();
if(t%4==1) //刚好在大单位分段数
{
if(t!=1) //不是个位数
{readChina.append(ReadChinaNum.chinaUnit[temp.length()-1]);
}
} else
{
nextnum=temp.substring(1,2);
nextone=Integer.parseInt(nextnum);
if(nextone != 0) //不是大单位，而且后面不是零
{
readChina.append("零");
}
}
}else
{
readChina.append(ReadChinaNum.chinaNum[number]).append(ReadChinaNum.chinaUnit[temp.length()-1]);
}
}
if(num[1]!=null)
{ readChina.append("点");
for(int i=0;i<num[1].length();i++)
{
String temp=num[1].substring(i,i+1);
number=Integer.parseInt(temp);
readChina.append(ReadChinaNum.chinaNum[number]);
}
}
System.out.println(readChina.toString());
}}
import java.io.InputStreamReader;
import java.util.Scanner;public class ReadChinaNum {
static final String[] chinaNum={"零","壹","貮","叁","肆","伍","陆","柒","捌","染","拾"};
static final String[] chinaUnit={"","十","百","千","万","十","百","千","亿","十","百","千","万亿"};
/**
* 读出小数点后的数。
* @param str
* @return
*/
static private String readDotAfter(String str)
{ StringBuilder read=new StringBuilder();
read.append("点");
for(int i=0;i<str.length();i++)
{
String temp=str.substring(i,i+1); //取得当前位的值
int number=Integer.parseInt(temp);
read.append(ReadChinaNum.chinaNum[number]);
}
return read.toString();
}
/**
* 读出小数点前的数
* @param str
* @return
*/
static private String readDotBefore(String str)
{ //只有一位数，是唯一一种需要读出个位上的零这个数的。
if(str.length()==1)
{
int number=Integer.parseInt(str);
return ReadChinaNum.chinaNum[number];
}
//以下是不止一位数的情况
StringBuilder readChina=new StringBuilder();
String currentnum,nextnum; //当前数和下一位数
int number,nextone; //转为了整型
for(int i=0;i<str.length();i++)
{
String temp=str.substring(i); //从高位开始处理，每处理一位数即抛弃已处理的数
currentnum=temp.substring(0,1); //当前处理的最高位数
number=Integer.parseInt(currentnum);
if(number==0) //当前位为0
{ int t=temp.length();
if(t%4==1) //刚好在大单位分段处
{
if(t!=1) //不是个位数
{readChina.append(ReadChinaNum.chinaUnit[temp.length()-1]);
}
} else //不是在大单位分段处，显然也不是在个位数，后面至少还会有一位。
{
nextnum=temp.substring(1,2);
nextone=Integer.parseInt(nextnum);
if(nextone != 0) //不是大单位，而且后面不是零
{
readChina.append("零");
}
}
}else //当前位不为0
{
readChina.append(ReadChinaNum.chinaNum[number]).append(ReadChinaNum.chinaUnit[temp.length()-1]);
}
}
return readChina.toString();
}
public static void main(String[] args) {
Scanner scan=new Scanner(new InputStreamReader(System.in));
String input=scan.nextLine();
String[] num=input.split("\\."); //分为小数点前和后的数据
//暂未做正则判断
String result=ReadChinaNum.readDotBefore(num[0]);//读小数点前数
if(num.length==2)//读小数点后的数
{result+=ReadChinaNum.readDotAfter(num[1]);}
System.out.println(result);
}}
public static void ss2(int c){
switch(c){
case 0:System.out.print("零");
break;
case 1:System.out.print("一");
break;
case 2:System.out.print("二");
break;
case 3:System.out.print("三");
break;
case 4:System.out.print("四");
break;
case 5:System.out.print("五");
break;
case 6:System.out.print("六");
break;
case 7:System.out.print("七");
break;
case 8:System.out.print("八");
break;
case 9:System.out.print("九");
break;
}
}
public static void ss(int c){
switch(c){
case 1:System.out.print("亿");
break;
case 2:System.out.print("千万");
break;
case 3:System.out.print("百万");
break;
case 4:System.out.print("十万");
break;
case 5:System.out.print("万");
break;
case 6:System.out.print("千");
break;
case 7:System.out.print("佰");
break;
case 8:System.out.print("十");
break;
}
}
public static void main(String args[]){
String a="10000001.045";
int d=100000000;
int temp=0;
String[] b=a.split("\\.");
int c1=Integer.parseInt(b[0]);
int i=1;
while(d>0){
temp=c1/d;
if(0<temp&&temp<10){
ss2(temp);
ss(i);
}
i++;
c1=c1-(temp*d);
d=d/10;
}
if(b.length>1){
System.out.print("点");
int c=b[1].length();
d=(int)Math.pow(10,c-1);
int c2=Integer.parseInt(b[1]);
while(d>0){
temp=c2/d;
if(temp>=0&&temp<10){
ss2(temp);
}
i++;
c2=c2-(temp*d);
d=d/10;
}
}
}
}