decimals,SQL中的小数点后的输入位数.

decimals,SQL中的小数点后的输入位数.详细介绍

本文目录一览： 小数用英语怎么表达方法

decimals n. [数] 小数（decimal的复数形式）；位数 例句： Why all the decimals? 为什么是小数？ Decimals are more precise but not as standard. 小数更为准确，但不标准。 扩展资料 　　I'll deal with decimals in the next lesson.

　　下一堂课我要讲小数。
　　Recognizee finite decimals and infinite decimals.
　　认识有限小数和无限小数。
　　Increased number of decimals in Touchstone export.
　　出口数量增加小数的试金石。

decimal 的意思

Decimal
Decimal 数据类型
Decimal 变量存储为 96 位（12 个字节）无符号的整型形式，并除以一个 10 的幂数。这个变比因子决定了小数点右面的数字位数，其范围从 0 到 28。变比因子为 0（没有小数位）的情形下，最大的可能值为 +/-79,228,162,514,264,337,593,543,950,335。而在有 28 个小数位的情况下，最大值为 +/-7.9228138007593543950335，而最小的非零值为 +/-0.0000000000000000000000000001。注意 此时，Decimal 数据类型只能在 Variant中使用，也就是说，不能声明一变量为 Decimal 的类型。不过可用 Cdec 函数，创建一个子类型为 Decimal 的Variant。
词典解释：
http://www.baidu.com/s?ie=gb2312&bs=decimal&sr=&z=&cl=3&f=8&wd=decimal&ct=1048576
这样可以么？
decimal 英['des?ml] 美[?d?s?m?l]
adj. 十进位的，小数的
n. 小数
名词复数:decimals
[例句]Atomic clocks measure time using the oscillations of a single atom and are accurate to 17 decimal places.
原子钟是通过一个原子的振动来计时，精确度可达小数点后17位。
更多示例用法>>

decimal怎么记忆

decimal的英音是/?des?ml/，美音是/?des?ml/。
decimal的意思是：十进制的；小数的；十进位的；小数。decimal的复数是：decimals。
含有decimal的双语例句
1、The period is also used as a decimal point.
句号也可用作十进制的小数点。
2、The number is correct to three decimal places.
这个数目精确到小数点后三位数。
3、The computer performs calculations in binary and converts the results to decimal.
计算机以二进制数进行计算，而后把计算结果转换为十进制数。
4、We needed to do decimals to round up and round down numbers.
我们得把小数四舍五入成整数。
5、The students had a grasp of decimals, percentages and fractions.
学生们掌握了小数、百分数和分数。

英语as a deciamal number怎么翻译？

as a deciamal number：作为十进制数
关键词语：
decimal：英 [?des?m(?)l] 美 [?des?ml]
adj. 十进位的，小数的
n. 小数；十进制
[ 复数 decimals ]
相关短语：
decimal system [数] 十进制 ; 十进位制 ; 十进位 ; 十进制数
decimal fraction 纯小数 ; 十进小数
双语例句：
In 1783 he secured the adoption of the decimal coinage in Congress.
1783年他促使国会采纳了十进位币制。
The computer performs calculations in binary and converts the results to decimal.
计算机以二进制数进行计算，而后把计算结果转换为十进制数。
英语as a decimal number翻译成中文意思是“十进制数”。
重点词汇：decimal
一、单词音标
decimal单词发音：英 ['des?ml] 美 ['des?ml]。
二、单词释义
adj. 小数的；十进位的
n. 小数
三、词形变化
复数: decimals
四、短语搭配
circulating decimal 循环小数
recurring decimal 循环小数
the decimal system 十进制
the decimal system 十进制
五、近义词
number 号码
fraction 小部分
unit 单元
denary 十进制的
六、双语例句
In 1971, the 1p and 2p decimal coins were introduced in Britain.
英国于1971年开始使用十进制的1便士和2便士硬币。
The number is correct to three decimal places.
这个数目精确到小数点后三位数。
The figure is accurate to two decimal places.
这个数精确到小数点后两位。
The computer performs calculations in binary and converts the results to decimal.
计算机以二进制数进行计算，而后把计算结果转换为十进制数。
The recurring decimal 3.999 … is also described as 3.9 recurring.
循环小数3.999...亦作3.9循环。
as a deciamal number
作为十进制数
number
初中高中四级六级考研
英 [?n?mb?]
美 [?n?mb?r]
n.
数；数值；号码；编号；数量；一期；几个；数个；几次
v.
总计；包含；标号；编号；包括；列入；点…的数目；估计…大小
复数： numbers
第三人称单数： numbers
现在分词： numbering
过去式： numbered
过去分词： numbered
短语搭配
a number of
一些, 许多, 数个
in number
总共, 一共, 数量
by the numbers
严格遵循规则；一板一眼
by numbers
按照指示机械地, 死板地
numbers game
数字游戏(即只注重参与的人数、达成了几项结果等, 而不考虑参与者是谁、结果是什么)
your number is up
劫数已到, 死期已至
a cushy number
轻松的工作；美差；令人羡慕的轻松状态
number one
自己；头号人物；头等大事；小便；尿；中尉；舰务官；最热销的唱片；最热销的书
serial number
序列号
telephone number
电话号码；大数目
any number of
任意数量；许多；很多
number plate
(车辆的) 牌照
whole number
整数；自然数
ordinal number
序数
cardinal number
基数；纯数
opposite number
对应的人
box number
信箱号码
square number
平方数
mixed number
带分数
number two
第二号人物；二把手；粪便；排名第二的人
双语例句
Larger females have the potential to oviposit on a greater number of hosts.
体型更大的雌虫有能力在数量更多的宿主上产卵。
牛津词典
Failure of a fire to draw properly can have a number of causes.
火炉通风不好可以有很多原因。
牛津词典
Profits from his single were to be divided between a number of charities.
他单曲唱片的利润将分给几个慈善机构。
牛津词典
as a deciamal number，翻译成中文意思是，作为十进制数。
重点词汇释义
number：数字; 数; 数量; 编号; 序数; 号码。
英语as a deciamal number翻译为:十进制数。deciamal的意思有:十进位的；小数的
as a deciamal number——作为十进制数
重点词汇：decimal
发音:英 [?des?ml]美 [?des?ml]
翻译：
adj.
十进制的；十进位的
n.
小数；十进小数；十进制
复数： decimals
短语搭配
decimal point
小数点
recurring decimal
循环小数
repeating decimal
循环小数
decimal place
小数位；十分位
binary coded decimal
二进制编码的十进制；二—十进制；二— 十进制数字
双语例句
Calculate the ratios to one decimal place.
比率计算至小数点后第一位。
Three fifths expressed as decimal is 0.6.
五分之三用小数表示就是0.6。
D is replaced by the remote IP address, as a long decimal number.
以“＼D”置换访问者的以十进制表达的ip地址。
The SI Prefixes Used to Form Decimal Multiples and Submultiples of SI Units.
用于构成十进倍数和分数单位的SI词头.
The decimal system is based on the number 10 and is universally adopted.
十进位制基于数字10,在全球被广泛地采用.

excel 如何省略小数点

在“a1*b1”前加个函数“round() ”变成“C1=ROUND(A1*B1,2)”就可以取小数后两位计算。
如果加“ROUNDDOWN()”就变成“C1=ROUNDDOWN(A1*B1,0)”,这样就不会有“四舍五入”，直接调用整数了。
在C列设置小数点位数就可以了，工具上就有增加和减少小数点位数。
你只需要在C1中输入=ROUND(A1*B1,2)你试试看
C1=round(a1*b1,2)
如果只是不显示小数点后的数字，可以通过修改单元格格式中的小数位数来实现。
如果要取整数，请用INT函数，例如：=INT(A1) 意思是A1单元格取整。
如果要四舍五入，请使用ROUND函数。例如：=ROUND（A1,0） 意思是A1单元格的小数部分四舍五入。
ROUND(number,decimals)
number:要舍入的数
decimals：指定的保留小数的位数
decimals的取值可为正数，0，负数。当decimals的值为正数时，针对小数点后的数据进行四舍五入；当decimals的值为0时，返回最接近number的整数；当decimals的值为负数时，针对小数点前的数据进行四舍五入，被舍掉的数据用0占位。
示例：
　　ROUND(123.456，2) 返回结果为：123.46
　　ROUND(123.456，0) 返回结果为：123
　　ROUND(123.456，-2) 返回结果为：100

SQL中的小数点后的输入位数.

1、用函数 ROUND(数值,s) ，其中 s 表示 小数位数。
例：SELECT ROUND(4.994,2) 返回 4.990。
2、用函数 CAST(数值 as numeric(n,s))，其中n表示有效数字位数，s表示小数位数。
例：SELECT CAST(4.994 as numeric(10,2)) 返回 4.99。
3、用函数 CONVERT(numeric(n,s),数值)，其中n表示有效数字位数，s表示小数位数。
例: SELECT CONVERT(numeric(10,2),4.985) 返回 4.99。
其运用的函数是函数 TRUNC。而trunc函数的功能和函数INT类似，是截取日期或数字，返回指定的值。函数trunc直接去除数字的小数部分，而函数INT则是向下舍入到最接近的整数。
扩展资料
TRUNC(for number)语法格式：TRUNC（number,[decimals]）
其中：
number 待做截取处理的数值。
decimals 指明需保留小数点后面的位数。可选项，忽略它则截去所有的小数部分。
trunc函数 turnc（x，y）如果y是负数，则对x在小数点左边的第|y|位处进行截断。
例如：TRUNC(5.75, -1)=0；
看成 0005.75.000 从小数点左边第一位往左边截，是0。
下面是该函数的使用情况：
TRUNC（89.985，2）=89.98
TRUNC（89.985）=89
TRUNC（89.985，-1）=80
注意：第二个参数可以为负数，表示为小数点左边指定位数后面的部分截去，即均以0记。与取整类似，比如参数为1即取整到十分位，如果是-1，则是取整到十位，以此类推。
参考资料来源：百度百科 trunc

excel计算如何只取整数？

如果要只取整数，舍弃小数部分，请用INT函数，例如：=INT(A1) 意思是A1单元格取整。
如果要四舍五入，请使用ROUND函数。例如：=ROUND（A1,0） 意思是A1单元格的小数部分四舍五入。
ROUND(number,decimals)
number:要舍入的数
decimals：指定的保留小数的位数
decimals的取值可为正数，0，负数。当decimals的值为正数时，针对小数点后的数据进行四舍五入；当decimals的值为0时，返回最接近number的整数；当decimals的值为负数时，针对小数点前的数据进行四舍五入，被舍掉的数据用0占位。
示例：
　　ROUND(123.456，2) 返回结果为：123.46
　　ROUND(123.456，0) 返回结果为：123
　　ROUND(123.456，-2) 返回结果为：100
=ROUNDUP(1.1,0)或=ROUNDUP(A1,0)该函数表示向上保留,与之相反的=ROUNDDOWN表向下舍,如=ROUNDDOWN(1.7,0)=2
=ROUND(number,num_digits),前面为数值，后面为保留的位数，取整为零。
1、首先在我们的电脑桌面上新建一个excel表格并点击它
2、然后随便输入一些带有小数点位数的内容，
3、接着全选这部分表格
4、然后右击表格并点击设置单元格格式，
5、接着点击数值，
6、然后设置小数位数为0并点击确定，
7、通过以上操作，我们就把表格中的数字取整了。

Oracle round函数是什么意思？怎么运用？

Oracle Round 函数 (四舍五入)，是指传回一个数值，该数值是按照指定的小数位元数进行四舍五入运算的结果。
使用方法
SELECT ROUND( number, [ decimal_places ] ) FROM DUAL
其中number 为待做截取处理的数值。
decimals 指明需保留小数点后面的位数。可选项，忽略它则截去所有的小数部分，并四舍五入。如果为负数则表示从小数点开始左边的位数，相应整数数字用0填充，小数被去掉。需要注意的是，和trunc函数不同，对截取的数字要四舍五入。
参数:number : 欲处理之数值decimal_places : 四舍五入 , 小数取几位 ( 预设为 0 )Sample :select round(123.456, 0) from dual; -----回传 123 select round(123.456, 1) from dual;-----回传 123.5 select round(123.456, 2) from dual; -----回传 123.46 select round(123.456, 3) from dual; -----回传 123.456
扩展资料
MATLAB函数简介
调用格式：Y = round(X)
在matlab中round也是一个四舍五入函数。在matlab的命令窗口中输入doc round或者help round即可获得该函数的相关帮助信息。
程序示例
>>a = [-1.9,-0.2,3.4,5.6,7.0,2.4+3.6i]
a =
Columns 1 through 4
-1.9000 -0.2000 3.4000 5.6000
Columns 5 through 6
⒎0000 2.4000 + 3.6000i
>>round(a)
ans =
Columns 1 through 4
-2.0000 0 3.0000 6.0000
Columns 5 through 6
⒎0000 2.0000 + 4.0000i
a =
Columns 1 through 4
-1.9000 -0.2000 3.4000 5.6000
Columns 5 through 6
⒎0000 2.4000 + 3.6000i
参考资料：百度百科-round函数
Oracle Round 函数指：传回一个数值，该数值是按照指定的小数位元数进行四舍五入运算的结果。
用法：
SELECT ROUND( number, [ decimal_places ] ) FROM DUAL
参数:
number : 欲处理之数值
decimal_places : 四舍五入 , 小数取几位 ( 预设为 0 )
具体案例：
a、SELECT Round(160/3,3) FROM dual; -----结果 53.33
b、SELECT Round(160/3,1) FROM dual; -----结果 53.3
c、SELECT Round(160/3,0) FROM dual; -----结果 53
d、SELECT Round(160/3,-1) FROM dual; -----结果 50
e、SELECT Round(160/3,-2) FROM dual; -----结果 100
扩展资料
关于trunc 和round函数比较
整体概括：
round函数指四舍五入。
trunc函数指直接截取。
对于时间：Round函数对日期进行“四舍五入”，Trunc函数对日期进行截取。如果我们不指定格式的话，Round会返回一个最接近date参数的日期，而Trunc函数只会简单的截取时分秒部分，返回年月日部分。
对于数字：Round函数对数字同样进行“四舍五入”，Trunc函数截取时不进行四舍五入，可以指明保留小数点后面的位数。
参考资料来源：百度百科—round （函数）
round函数为Oracle中的四舍五入函数。运用的方法是Round（number，[decimals]）
其中：number 待做四舍五入处理的数值，decimals 指明需保留小数点后面的位数。可选项，忽略它则保留0位小数，精确到个位；为负数，表示为小数点左边四舍五入处理。
示例如下：
SQL> select round（123.123），
2 round（123.123,2），
3 round（123.16,2），
4 round（123.14,-2），
5 round（163.14,-2）
6 from dual;
ROUND（123.123） ROUND（123.123,2） ROUND（123.16,2） ROUND（123.14,-2） ROUND（163.14,-2）
123 123.12 123.16 100 200
扩展资料EXCEL中的round函数用法
ROUND(number,decimals)
number是要舍入的数，decimals是指定的保留小数的位数。
decimals的取值可为正数，0，负数。当decimals的值为正数时，针对小数点后的数据进行四舍五入；当decimals的值为0时，返回最接近number的整数；当decimals的值为负数时，针对小数点前的数据进行四舍五入，被舍掉的数据用0占位。
示例如下：
ROUND(123.456，2) 返回结果为：123.46
ROUND(123.456，0) 返回结果为：123
ROUND(123.456，-2) 返回结果为：100
参考资料：百度百科——round
Oracle中round函数是用于对数字进行截取操作，且会对截取的数字进行四舍五入运算。
Oracle中round函数的应用:
语法为ROUND(number，num_digits)
其中number是需要进行四舍五入的数字；num_digits为指定的位数，按此位数进行四舍五入，
如果 num_digits 大于 0，则四舍五入到指定的小数位，如果 num_digits 等于 0，
则四舍五入到最接近的整数，如果 num_digits 小于 0，则在小数点左侧进行四舍五入。
扩展资料：
Oracle中trunc函数：
trunc函数是返回x按精度y截取后的值 。
trunc(x[,y]) ，x,y，数字型表达式,如果y不为整数则截取y整数部分，如果y>0则截取到y位小数，如果y小于0则截取到小数点向左第y位，小数前其它数据用0表示。
例如：select trunc(5555.66666,2.1),trunc(5555.66666,-2.6),trunc(5555.033333) from dual;
返回：5555.66 5500 5555
相似性: round(x[,y]) 返回截取后的值，用法同trunc(x[,y]),只是要做四舍五入。
参考资料来源：百度百科-round函数
如何使用 Oracle Round 函数 (四舍五入)
描述 : 传回一个数值，该数值是按照指定的小数位元数进行四舍五入运算的结果。
SELECT ROUND( number, [ decimal_places ] ) FROM DUAL
参数:
number : 欲处理之数值
decimal_places : 四舍五入 , 小数取几位 ( 预设为 0 )
Sample :
select round(123.456, 0) from dual; 回传 123
select round(123.456, 1) from dual; 回传 123.5
select round(123.456, 2) from dual; 回传 123.46
select round(123.456, 3) from dual; 回传 123.456
select round(-123.456, 2) from dual; 回传 -123.46
Oracle Round 函数的意思是四舍五入的方法，即传回一个数值，该数值是按照指定的小数位元数进行四舍五入运算的结果。
Oracle Round 函数使用示例如下：
SELECT ROUND( number, [ decimal_places ] ) FROM DUAL
1、参数 number 是指需要处理的数值，是必须填写的值。
2、参数 decimal_places 是指在进行四舍五入运算时 , 小数的应取的位数，该参数可以不填，不填的时候，系统默认小数位数取0。
3、函数应用举例：
①“select round(988.211, 0) from dual;”得到结果为：988
②“select round(988.211, 1) from dual;”得到结果为：988.2
③“select round(988.211, 2) from dual;” 得到结果为：988.21
④“select round(988.211, 3) from dual;” 得到结果为：988.211
⑤“select round(-988.211, 2) from dual;”得到结果为：-988.21
扩展资料：
四舍五入是一种精确度的计数保留法，与其他方法本质相同。
但特殊之处在于采用四舍五入，能使被保留部分的与实际值差值不超过最后一位数量级的二分之一，假如0～9等概率出现的话，对大量的被保留数据，这种保留法的误差总和是最小的。
这也是我们使用这种方法为基本保留法的原因。
参考资料：百度百科-Round函数 百度百科-四舍五入

vb.net 怎样使计算结果只保留四位小数？

formatnumber（数，小数位数）
用这个函数把
Math.Round 方法 (Decimal, Int32)
将小数值舍入到指定精度。
命名空间： System
程序集： mscorlib（在 mscorlib.dll 中）
语法
Visual Basic（用法）
Dim d As Decimal
Dim decimals As Integer
Dim returnValue As Decimal
returnValue = Math.Round(d, decimals)
参数
d
类型：System.Decimal
要舍入的小数。
decimals
类型：System.Int32
返回值中的小数位数（精度）。
返回值
类型：System.Decimal
精度等于 decimals，最接近 d 的数字。
Math.Round(3.4666666, 4) 结果是 3.4667.

java实现金额转换，阿拉伯数字的金额转换成中国传统的形式

直接通过以下接口类方法实现即可：
import java.math.BigDecimal;
/**
* 金额工具类
*
* @author zn
*
* @Date 2013-2-1
* @Email zn.share@gmail.com
*/
public class MoneyUtil {
private static final int DFT_SCALE = 2;
/** 大写数字 */
private static final String[] NUMBERS = { "零", "壹", "贰", "叁", "肆", "伍",
"陆", "柒", "捌", "玖" };
/** 整数部分的单位 */
private static final String[] IUNIT = { "元", "拾", "佰", "仟", "万", "拾", "佰",
"仟", "亿", "拾", "佰", "仟", "万", "拾", "佰", "仟" };
/** 小数部分的单位 */
private static final String[] DUNIT = { "角", "分", "厘" };
/**
* 得到大写金额。
*/
public static String toChinese(String str) {
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 = "";
}
// integerStr去掉首0，不必去掉decimalStr的尾0(超出部分舍去)
if (!integerStr.equals("")) {
integerStr = Long.toString(Long.parseLong(integerStr));
if (integerStr.equals("0")) {
integerStr = "";
}
}
// overflow超出处理能力，直接返回
if (integerStr.length() > IUNIT.length) {
System.out.println(str + ":超出处理能力");
return str;
}
int[] integers = toArray(integerStr);// 整数部分数字
boolean isMust5 = isMust5(integerStr);// 设置万单位
int[] decimals = toArray(decimalStr);// 小数部分数字
return getChineseInteger(integers, isMust5)
+ getChineseDecimal(decimals);
}
/**
* 整数部分和小数部分转换为数组，从高位至低位
*/
private static int[] toArray(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;
}
/**
* 得到中文金额的整数部分。
*/
private static String getChineseInteger(int[] integers, boolean isMust5) {
StringBuffer chineseInteger = new StringBuffer("");
int length = integers.length;
for (int i = 0; i < length; i++) {
// 0出现在关键位置：1234(万)5678(亿)9012(万)3456(元)
// 特殊情况：10(拾元、壹拾元、壹拾万元、拾万元)
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 && isMust5)// 万(不必填)
key = IUNIT[4];
else if ((length - i) == 1)// 元(必填)
key = IUNIT[0];
// 0遇非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();
}
/**
* 得到中文金额的小数部分。
*/
private static String getChineseDecimal(int[] decimals) {
StringBuffer chineseDecimal = new StringBuffer("");
for (int i = 0; i < decimals.length; i++) {
// 舍去3位小数之后的
if (i == 3)
break;
chineseDecimal.append(decimals[i] == 0 ? ""
: (NUMBERS[decimals[i]] + DUNIT[i]));
}
return chineseDecimal.toString();
}
/**
* 判断第5位数字的单位"万"是否应加。
*/
private static boolean isMust5(String integerStr) {
int length = integerStr.length();
if (length > 4) {
String subInteger = "";
if (length > 8) { // TODO 12-9-17
// 取得从低位数，第5到第8位的字串
subInteger = integerStr.substring(length - 8, length - 4);
} else {
subInteger = integerStr.substring(0, length - 4);
}
return Integer.parseInt(subInteger) > 0;
} else {
return false;
}
}
/**
* BigDecimal 相乘,四舍五入保留0位
*
* @param a
* @param b
* @return a*b
*/
public static BigDecimal mutiply(String a, String b, int roundingMode) {
BigDecimal bd = new BigDecimal(a);
return bd.multiply(new BigDecimal(b)).setScale(DFT_SCALE, roundingMode);
}
/**
* BigDecimal 相除,四舍五入保留两位
*
* @param a
* @param b
* @return a/b
*/
public static BigDecimal div(String a, String b, int roundingMode) {
BigDecimal decimal1 = new BigDecimal(a);
BigDecimal decimal2 = new BigDecimal(b);
return decimal1.divide(decimal2, DFT_SCALE, roundingMode);
}
/**
* BigDecimal 相加,四舍五入保留两位
*
* @param a
* @param b
* @return a+b
*/
public static BigDecimal sum(String a, String b, int roundingMode) {
BigDecimal decimal1 = new BigDecimal(a);
BigDecimal decimal2 = new BigDecimal(b);
// DecimalFormat format = new DecimalFormat("#0.00");
return decimal1.add(decimal2).setScale(DFT_SCALE, roundingMode);
}
/**
* BigDecimal 相减,四舍五入保留两位
*
* @param a
* @param b
* @return a+b
*/
public static BigDecimal sub(String a, String b, int roundingMode) {
BigDecimal decimal1 = new BigDecimal(a);
BigDecimal decimal2 = new BigDecimal(b);
// DecimalFormat format = new DecimalFormat("#0.00");
return decimal1.subtract(decimal2).setScale(DFT_SCALE, roundingMode);
}
/**
* 100.00 为10000
*
* @param a
* @return
*/
public static BigDecimal format(String a, int roundingMode) {
return new BigDecimal(a).multiply(new BigDecimal(100)).setScale(0,
roundingMode);
}
public static void main(String[] args) {
String number = "54452";
System.out.println(number + " " + MoneyUtil.toChinese(number));
number = "30200";
System.out.println(number + " " + MoneyUtil.toChinese(number));
number = "30000.05";
System.out.println(number + " " + MoneyUtil.toChinese(number));
number = "30000.00";
System.out.println(number + " " + MoneyUtil.toChinese(number));
}
}
备注：最后面的main方法是具体的调用。
/**
* @(#)SimpleMoneyFormat.java
*
*金额转换，阿拉伯数字的金额转换为中国传统的形式输出
* @lpxuan
* @version 1.00 2008/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实现金额转换，阿拉伯数字的金额转换成中国传统的形式

import java.util.HashMap;

import java.text.NumberFormat;

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)));

}

}
</moneystr.length();i++){
</moneystr.length();i++){