「java金额long」java金额加逗号

admin 2023-03-20 14:41:10 617

本篇文章给大家谈谈java金额long，以及java金额加逗号对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

1、java实现金额转换，阿拉伯数字的金额转换成中国传统的形式
2、java中long是什么意思
3、java如何把大写的金额改成小写
4、java中 long a=10000000000; 为啥会报错
5、Java金额的中文大写方式
6、java中long类型的取值范围到底是多少呢？

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方法是具体的调用。

java中long是什么意思

long 就是长整型的意思。java 的 8 个基本类型的一种。你应该要把 java 的 8 种基本类型一起记：byte short int long char float double boolean

int 是 32 位的整数，long 就是 64 位的整数，表示范围：-2^63 ~ 2^63 -1

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

/**

* @(#)SimpleMoneyFormat.java

*金额转换，阿拉伯数字的金额转换为中国传统的形式输出

* @lpxuan

* @version 1.00 2010/7/31

import java.text.NumberFormat;

import java.util.HashMap;

import java.lang.StringBuffer;

public class SimpleMoneyFormat {

public static final String EMPTY="";

public static final String ZERO="零";

public static final String ONE="壹";

public static final String TWO="贰";

public static final String THREE="叁";

public static final String FOUR="肆";

public static final String FIVE="伍";

public static final String SIX="陆";

public static final String SEVEN="柒";

public static final String EIGHT="捌";

public static final String NINE="玖";

public static final String TEN="拾";

public static final String HUNDRED="佰";

public static final String THOUSAND="仟";

public static final String TEN_THOUSAND="万";

public static final String HUNDRED_MILLION="亿";

public static final String YUAN="元";

public static final String JIAO="角";

public static final String FEN="分";

public static final String DOT=".";

private static SimpleMoneyFormat formatter=null;

private HashMap chineseNumberMap=new HashMap();

private HashMap chineseMoenyPattern=new HashMap();

private NumberFormat numberFormat=NumberFormat.getInstance();

//私有构造函数

private SimpleMoneyFormat() {

numberFormat.setMaximumFractionDigits(4);

numberFormat.setMinimumFractionDigits(2);

numberFormat.setGroupingUsed(false);

chineseNumberMap.put("0",ZERO);

chineseNumberMap.put("1",ONE);

chineseNumberMap.put("2",TWO);

chineseNumberMap.put("3",THREE);

chineseNumberMap.put("4",FOUR);

chineseNumberMap.put("5",FIVE);

chineseNumberMap.put("6",SIX);

chineseNumberMap.put("7",SEVEN);

chineseNumberMap.put("8",EIGHT);

chineseNumberMap.put("9",NINE);

chineseNumberMap.put(DOT,DOT);

chineseMoenyPattern.put("1",TEN);

chineseMoenyPattern.put("2",HUNDRED);

chineseMoenyPattern.put("3",THOUSAND);

chineseMoenyPattern.put("4",TEN_THOUSAND);

chineseMoenyPattern.put("5",TEN);

chineseMoenyPattern.put("6",HUNDRED);

chineseMoenyPattern.put("7",THOUSAND);

chineseMoenyPattern.put("8",HUNDRED_MILLION);

}

//单例模式

public static SimpleMoneyFormat getInstance(){

if(formatter==null)

formatter=new SimpleMoneyFormat();

return formatter;

}

public String format(String moneyStr){

checkPrecision(moneyStr);

String result;

result=convertToChineseNumber(moneyStr);

result=addUnitsToChineseMoenyString(result);

return result;

}

public String format(double moneyDouble){

return format(numberFormat.format(moneyDouble));

}

public String format(int moneyInt){

return format(numberFormat.format(moneyInt));

}

public String format(long moneyLong){

return format(numberFormat.format(moneyLong));

}

public String format(Number moneyNum){

return format(numberFormat.format(moneyNum));

}

private String convertToChineseNumber(String moneyStr){

String result;

StringBuffer cMoneyStringBuffer =new StringBuffer();

for(int i=0;imoneyStr.length();i++){

cMoneyStringBuffer.append(chineseNumberMap.

get(moneyStr.substring(i,i+1)));

}

int indexOfDot=cMoneyStringBuffer.indexOf(DOT);

int moneyPatternCursor=1;

for(int i=indexOfDot-1;i0;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(fractionDigits2)//精度不能比分低

throw new RuntimeException("金额"+moneyStr+"的小数位数多余两位.");

}

public static void main(String[] args){

System.out.println(getInstance().format(new Double(10010001.01)));

}

java中 long a=10000000000; 为啥会报错

正确的写法

long a=10000000000L; //将10000000000 这个整数常量，声明为long类型。

报错原因是：Java中整数类型的值默认成int类型，占4个字节，能表示的最大值是2的31次方减一，约2乘十的九次方。10 000 000 000不带L时，会被默认成int类型，但这个值远远超过int类型能表示的最大值，于是报错。

long类型占八个字节，能表示的最大值为2的63次方减一，约为9 乘十的十八次方，能表示的最小值是-2的63次方。10000000000这个值处在long类型的表示范围内，所以声明成一个long类型常量10000000000L不会出错。将long类型常量赋值给long类型变量，不存在数据类型转换的类型不兼容问题。

Java金额的中文大写方式

/**

* 金额小数转换成中文大写金额

* @author Neil Han

public class ConvertMoneyToUppercase {

private static final String UNIT[] = { "万", "千", "佰", "拾", "亿", "千", "佰",

"拾", "万", "千", "佰", "拾", "元", "角", "分" };

private static final String NUM[] = { "零", "壹", "贰", "叁", "肆", "伍", "陆",

"柒", "捌", "玖" };

private static final double MAX_VALUE = 9999999999999.99D;

/**

* 将金额小数转换成中文大写金额

* @param money

* @return result

public static String convertMoney(double money) {

if (money 0 || money MAX_VALUE)

return "参数非法!";

long money1 = Math.round(money * 100); // 四舍五入到分

if (money1 == 0)

return "零元整";

String strMoney = String.valueOf(money1);

int numIndex = 0; // numIndex用于选择金额数值

int unitIndex = UNIT.length - strMoney.length(); // unitIndex用于选择金额单位

boolean isZero = false; // 用于判断当前为是否为零

String result = "";

for (; numIndex strMoney.length(); numIndex++, unitIndex++) {

char num = strMoney.charAt(numIndex);

if (num == '0') {

isZero = true;

if (UNIT[unitIndex] == "亿" || UNIT[unitIndex] == "万"

|| UNIT[unitIndex] == "元") { // 如果当前位是亿、万、元，且数值为零

result = result + UNIT[unitIndex]; //补单位亿、万、元

isZero = false;

}

}else {

if (isZero) {

result = result + "零";

isZero = false;

}

result = result + NUM[Integer.parseInt(String.valueOf(num))] + UNIT[unitIndex];

}

//不是角分结尾就加"整"字

if (!result.endsWith("角")!result.endsWith("分")) {

result = result + "整";

}

//例如没有这行代码，数值"400000001101.2"，输出就是"肆千亿万壹千壹佰零壹元贰角"

result = result.replaceAll("亿万", "亿");

return result;

}

public static void main(String[] args) {

double value = Double.parseDouble("40330701101.2");

System.out.println("您输入的金额（小写）为：" + value);

System.out.println("您输入的金额（大写）为：" + convertMoney(value));

}

java中long类型的取值范围到底是多少呢？

范围：-9223372036854775808到9223372036854775807

解释：long类型是64位的也就是 ”-2^64“ 到”2^64 -1“.

在定义long类型时，如果数据类型超过int类型的取值范围，数据后面要加l或L，不超过则不需要加。

byte的取值范围为-128~127，占用1个字节（-2的7次方到2的7次方-1）

short的取值范围为-32768~32767，占用2个字节（-2的15次方到2的15次方-1）

int的取值范围为（-2147483648~2147483647），占用4个字节（-2的31次方到2的31次方-1）

long的取值范围为（-9223372036854774808~9223372036854774807），占用8个字节（-2的63次方到2的63次方-1）。

关于java金额long和java金额加逗号的介绍到此就结束了，不知道你从中找到你需要的信息了吗？如果你还想了解更多这方面的信息，记得收藏关注本站。

标签：java金额long