求一个程序，面试，但是没有写出来！ 虽然在网上很多 我看了十来个 都稀乱 ！
将一个字符串转换为我们中国人读的方式！要求：
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(八百九十万零五百四十二点七八)；
[最优解释]
有个疑问 这样的一般怎么读？
十亿九千万 or 十亿零九千万？
三十万八千 or 三十万零八千？
[其他解释]
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());
}
}
}
一亿点一二
一千万零一点四五
二百四十万零一点零一
四千五百九十七万四千六百二十三点八零
八百九十万零五百四十二点七八
零点九九二
二十万零三千二百点九九二
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;
}
}
package com.zf.test;
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()
[其他解释]
具体思路如下：
从小数点分开两半：
一、整数部分 ------------------------
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
[其他解释]
先mark，等下再看
[其他解释]
零$)", "");
return text;
}
}六百九十二亿一千三百四十三万四千六百三十一
二亿一千三百四十三万四千六百三十一
二亿零一百四十三万四千六百三十一
二亿
二亿零一百万零一百
二亿零一百
三百四十三万四千六百三十一
五千零三十二
五千零二
五千
一百
一百零二
五百五十二
五十
五十二
五
------其他解决方案--------------------
该回复于2012-11-09 02:48:01被管理员删除
[其他解释]
Jdbc查询问题 希望有能帮帮小妹的。
http://bbs.csdn.net/topics/390275427?page=1#post-392867820
[其他解释]学习了
[其他解释]
零万
[其他解释]
感觉你可以参照转换人民币的那个、。
[其他解释]
看楼上各位大侠替换0的思路很好。
我根据前面几个大侠的代码，写了一个直接在循环里处理0的方式
看半天都是java代码，仔细一看是java的版块，不好意思，我用C#写的
program.cs
using 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.cs
using 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;
}
}
}
[其他解释]
删除代码中70行的<SPAN style="COLOR: #ff6600"> 和77 行的</SPAN>后程序可直接运行。
[其他解释]
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))));
}
}
[其他解释]
[quote=引用:]
貌似这段代码有问题。。如果是704这种情况，中间的零就会变成十。这样下来就是七百零十四。。
[其他解释]
如果可以的话 邮箱 851840653 @ qq。com
[其他解释]
感觉还行吧。先用正则表达式判断一下，如果合法的话继续运行。
然后转换成字符串，用str.splie分成数组对象，
然后对str[1]判断位数，8位以上或以下。然后判断万位。
当然，中间添加千百十什么的确实挺麻烦的。
我记得我以前没事的时候写过，不过找不到了。明天上班的时候再试着写写看
[其他解释]
str.split(".")
用环境换习惯了，自己敲的时候总是敲错
[其他解释]
不懂呢 boolean b=true;
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);
[其他解释]
}
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）
从后向前解析
//...... 语言表达能力有限。。。 不解释了。
}
小数点之后的内容
}
package com.tur.demo;
public class Hello {
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("(零十
[其他解释]
零百
[其他解释]
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));
}
}
}
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("(零十
[其他解释]
我觉得这种字符串的解析其实很简单的，两个枚举再加上String的charAt很容易就出来了
对于split等方式我觉得在效率和资源上可能会有问题，我更倾向于使用charAt
对于14楼提到的，我觉得直接读数字就可以了！123直接读作一二三
[其他解释]
零亿)", "零");
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
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;
}
}
[其他解释]
public class Test5
{
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
[其他解释]
1.该字符串只能含数字和小数点（要检测是否含有其他非法字符或为空）;->用正则表达式可以判断
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(八百九十万零五百四十二点七八)；
[其他解释]
如果搞过ACM的话..这个题感觉很水水的样子
[其他解释]
初学JAVA。学习一下！
[其他解释]
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', "九");
}
}
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'
[其他解释]
我最近也在研究这个
import java.math.BigDecimal;
public class MoneyToChineseUitl {
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
[其他解释]
无意中看到的，用C#实现，请见谅
using System;
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 markZero = 0;//标记0连续的个数
int j = 0;//for循环后到达的数量级 个、十、百...
int markw = 0;//标记万
int marky = 0;//标记亿
//整数部分
for (int i = arr1.Length - 1; i >= 0; i--)
{
string num = word[arr1[i].ToString()];
if (num == "零")
markZero++;
else
{
if (markZero > 0)
{
if (j > 0)
sb.Append("零");
j += markZero;
markZero = 0;
}
markw = IsHasWY(j, markw, 4, 7, "万", sb);
marky = IsHasWY(j, marky, 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 mark,int minNum, int maxNum, string word,StringBuilder sb)
{
if (num >= minNum && num <= maxNum)
{
if (mark == 0)
{
sb.Append(word);
mark++;
}
}
else
mark=0;
return mark;
}
}
}
结果：
[其他解释]
小数点后的很简单，小数点前的见我的blog：
http://www.cnblogs.com/codejar/archive/2012/02/15/2352606.html
[其他解释]
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'));
