Java金额帮助类——数字的转换（加减乘除）——取舍方式

货币金额的转换。
针对金额的数学方法，和格式转换

import java.math.BigDecimal;
import java.text.NumberFormat;


/**
 * MoneyHelper说明：

 * 1，尽量不要使用本类提供的参数类型为double型的方法，你要使用这些方法的前提是：你传近来的double数值精度在double型提供的精度范围内，
 *    如：double a= 999999999999999.999999,这值超出double的精度，他实际表示是10E15，那么调用这些方法可能的要意想不到的结果。

 * 2，尽量不要运用divide（除）的方法，除非你的除运算不作为中间计算结果

 *    如：MoneyHelper.multiply(MoneyHelper.divide("1","3"),"3")得不要结果1，

 *    因为在除得时候他的结果作为中间结果，除运算结果保留小数点后10位，然后做精确乘，结果就为0.9999999999
 */
public class MoneyHelper {
    
	//默认除法运算精度
    private static final int DEFAULT_DIV_SCALE = 10;
    
    //默认舍入模式
    private static final int DEFAULT_ROUND_MODEL = BigDecimal.ROUND_HALF_UP; 
    
    //这个类不能实例化
    private MoneyHelper(){
    }
    
    /**
    舍入模式:
    ROUND_CEILING 向正无穷方向舍入
    ROUND_DOWN 向零方向舍入
    ROUND_FLOOR 向负无穷方向舍入
    ROUND_HALF_DOWN 向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样，向下舍入, 例如1.55 保留一位小数结果为1.5
    ROUND_HALF_EVEN 向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样，则向相邻的偶数舍入

    ROUND_HALF_UP 向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样，向上舍入, 1.55保留一位小数结果为1.6
    ROUND_UNNECESSARY 计算结果是精确的，不需要舍入模式

    ROUND_UP 向远离0的方向舍入

    */

    /**
	 * 提供精确的加法运算。

	 * 
	 * @param v1 被加数

	 * @param v2 加数
	 * @return 两个参数的和
	 */
	public static double add(double v1, double v2) {
		BigDecimal b1 = new BigDecimal(Double.toString(v1));
		BigDecimal b2 = new BigDecimal(Double.toString(v2));
		return b1.add(b2).doubleValue();
	}

	/**
	 * 提供精确的加法运算。

	 * 
	 * @param v1 被加数

	 * @param v2 加数
	 * @return 两个参数的和
	 */
	public static String add(String v1, String v2) {
		BigDecimal b1 = new BigDecimal(v1);
		BigDecimal b2 = new BigDecimal(v2);
		return b1.add(b2).toString();
	}

	/**
	 * 提供精确的减法运算。

	 * 
	 * @param v1 被减数

	 * @param v2 减数
	 * @return 两个参数的差
	 */
	public static double subtract(double v1, double v2) {
		BigDecimal b1 = new BigDecimal(Double.toString(v1));
		BigDecimal b2 = new BigDecimal(Double.toString(v2));
		return b1.subtract(b2).doubleValue();
	}

	/**
	 * 提供精确的减法运算

	 * 
	 * @param v1
	 * @param v2
	 * @return 两个参数数学差，以字符串格式返回
	 */

	public static String subtract(String v1, String v2) {
		BigDecimal b1 = new BigDecimal(v1);
		BigDecimal b2 = new BigDecimal(v2);
		return b1.subtract(b2).toString();
	}

	/**
	 * 提供精确的乘法运算。

	 * 
	 * @param v1 被乘数

	 * @param v2 乘数
	 * @return 两个参数的积
	 */
	public static double multiply(double v1, double v2) {
		BigDecimal b1 = new BigDecimal(Double.toString(v1));
		BigDecimal b2 = new BigDecimal(Double.toString(v2));
		return b1.multiply(b2).doubleValue();
	}

	/**
	 * 提供精确的乘法运算

	 * 
	 * @param v1
	 * @param v2
	 * @return 两个参数的数学积，以字符串格式返回

	 */
	public static String multiply(String v1, String v2) {
		BigDecimal b1 = new BigDecimal(v1);
		BigDecimal b2 = new BigDecimal(v2);
		return b1.multiply(b2).toString();
	}

	/**
	 * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到 小数点以后10位，以后的数字四舍五入,舍入模式采用ROUND_HALF_UP
	 * 
	 * @param v1
	 * @param v2
	 * @return 两个参数的商
	 */

	public static double divide(double v1, double v2) {
		return divide(v1, v2, DEFAULT_DIV_SCALE);
	}

	/**
	 * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 定精度，以后的数字四舍五入。舍入模式采用ROUND_HALF_UP
	 * 
	 * @param v1
	 * @param v2
	 * @param scale 表示需要精确到小数点以后几位。

	 * @return 两个参数的商
	 */

	public static double divide(double v1, double v2, int scale) {
		return divide(v1, v2, scale, DEFAULT_ROUND_MODEL);
	}

	/**
	 * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 定精度，以后的数字四舍五入。舍入模式采用用户指定舍入模式

	 * 
	 * @param v1
	 * @param v2
	 * @param scale 表示需要精确到小数点以后几位

	 * @param round_mode 表示用户指定的舍入模式

	 * @return 两个参数的商
	 */

	public static double divide(double v1, double v2, int scale, int round_mode) {
		if (scale < 0) {
			throw new IllegalArgumentException(
					"The scale must be a positive integer or zero");
		}
		BigDecimal b1 = new BigDecimal(Double.toString(v1));
		BigDecimal b2 = new BigDecimal(Double.toString(v2));
		return b1.divide(b2, scale, round_mode).doubleValue();
	}

	/**
	 * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到 小数点以后10位，以后的数字四舍五入,舍入模式采用ROUND_HALF_UP
	 * 
	 * @param v1
	 * @param v2
	 * @return 两个参数的商，以字符串格式返回

	 */

	public static String divide(String v1, String v2) {
		return divide(v1, v2, DEFAULT_DIV_SCALE);
	}

	/**
	 * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 定精度，以后的数字四舍五入。舍入模式采用ROUND_HALF_UP
	 * 
	 * @param v1
	 * @param v2
	 * @param scale 表示需要精确到小数点以后几位

	 * @return 两个参数的商，以字符串格式返回

	 */

	public static String divide(String v1, String v2, int scale) {
		return divide(v1, v2, scale, DEFAULT_ROUND_MODEL);
	}

	/**
	 * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 定精度，以后的数字四舍五入。舍入模式采用用户指定舍入模式

	 * 
	 * @param v1
	 * @param v2
	 * @param scale 表示需要精确到小数点以后几位

	 * @param round_mode 表示用户指定的舍入模式

	 * @return 两个参数的商，以字符串格式返回

	 */

	public static String divide(String v1, String v2, int scale, int round_mode) {
		if (scale < 0) {
			throw new IllegalArgumentException(
					"The scale must be a positive integer or zero");
		}
		BigDecimal b1 = new BigDecimal(v1);
		BigDecimal b2 = new BigDecimal(v2);
		return b1.divide(b2, scale, round_mode).toString();
	}

	/**
	 * 提供精确的小数位四舍五入处理,舍入模式采用ROUND_HALF_UP
	 * 
	 * @param v 需要四舍五入的数字
	 * @param scale 小数点后保留几位
	 * @return 四舍五入后的结果
	 */

	public static double round(double v, int scale) {
		return round(v, scale, DEFAULT_ROUND_MODEL);
	}

	/**
	 * 提供精确的小数位四舍五入处理
	 * 
	 * @param v 需要四舍五入的数字
	 * @param scale 小数点后保留几位
	 * @param round_mode 指定的舍入模式

	 * @return 四舍五入后的结果
	 */

	public static double round(double v, int scale, int round_mode) {
		if (scale < 0) {
			throw new IllegalArgumentException(
					"The scale must be a positive integer or zero");
		}
		BigDecimal b = new BigDecimal(Double.toString(v));
		return b.setScale(scale, round_mode).doubleValue();
	}

	/**
	 * 提供精确的小数位四舍五入处理,舍入模式采用ROUND_HALF_UP
	 * 
	 * @param v 需要四舍五入的数字
	 * @param scale 小数点后保留几位
	 * @return 四舍五入后的结果，以字符串格式返回

	 */

	public static String round(String v, int scale) {
		return round(v, scale, DEFAULT_ROUND_MODEL);
	}

	/**
	 * 提供精确的小数位四舍五入处理
	 * 
	 * @param v 需要四舍五入的数字
	 * @param scale 小数点后保留几位
	 * @param round_mode 指定的舍入模式

	 * @return 四舍五入后的结果，以字符串格式返回

	 */

	public static String round(String v, int scale, int round_mode) {
		if (scale < 0) {
			throw new IllegalArgumentException(
					"The scale must be a positive integer or zero");
		}
		BigDecimal b = new BigDecimal(v);
		return b.setScale(scale, round_mode).toString();

	}

	/**
	 * 取整数部分

	 * 
	 * @param v 需要取整的数

	 * @return  截断小数点数字后的结果

	 */
	public static long getIntegerInstance(double v) {
		BigDecimal b = new BigDecimal(Double.toString(v));
		return b.setScale(0, BigDecimal.ROUND_DOWN).longValue();
	}
	/**
	 * 取整数部分

	 * 
	 * @param v 需要取整的数

	 * @return 截断小数点数字后的结果

	 */
	public static String getIntegerInstance(String v) {
		return round(v, 0, BigDecimal.ROUND_DOWN).toString();
	}
	
	/**
	 * 保留到小数点后面位数(截断需要保留小数位数后面的数值) eg:truncate(1.3456,3)=1.345
	 * 
	 * @param v 需要保留的数

	 * @param scale 小数点后保留几位
	 * @return 截断后的结果
	 */
	public static double truncate(double v,int scale) {
		return round(v, scale, BigDecimal.ROUND_DOWN);
	}
	
	/**
	 * 保留到小数点后面位数(截断需要保留小数位数后面的数值) eg:truncate("1.3456",3)=1.345
	 * 
	 * @param v 需要保留的数

	 * @param scale 小数点后保留几位
	 * @return 截断后的结果
	 */
	public static String truncate(String v,int scale) {
		return round(v, scale, BigDecimal.ROUND_DOWN).toString();
	}
	
	/**
	 * 转化为百分数的形式。如 getPercentInstance(63.25656,2)==>6,325.66%
	 * 
	 * @param v 
	 * @param scale 小数点后保留几位
	 * @return 返回
	 */
	public static String getPercentInstance(double v,int scale) {
		NumberFormat percentFormat = NumberFormat.getPercentInstance();
		percentFormat.setMinimumFractionDigits(scale);   
        return percentFormat.format(round(v,scale+2));
        
	}
	
	/**
	 * 转化为货币的形式,精确到分。如 getCurrencyInstance(6322.255,true)==>￥6,322.26
	 * @param v 
	 * @param flag 是否显示￥  （ture显示）

	 * @return 返回货币的形式

	 * @return
	 */
	public static String getCurrencyInstance(double v, boolean flag) {
		if (flag) {
			NumberFormat currencyFormat = NumberFormat.getCurrencyInstance();
			//return (currencyFormat.format(v)));错误
			return (currencyFormat.format(round(v,2)));
		} else {
			NumberFormat   nf   =   NumberFormat.getInstance();
			nf.setMinimumFractionDigits(2);
			nf.setMaximumFractionDigits(2);
			//return (nf.format(v));错误
			return (nf.format(round(v,2)));

		}
	}
	
    /** 
     * 处理金额，使其有两位小数 如果传入的数小数位数大于2位，直接截断小数点2位后的数字，不考虑四舍五入     
     * @param str String
     * @return String
     */
   public static String dealMoneyFormat(String str) {
	  BigDecimal bd=new BigDecimal(MoneyHelper.getIntegerInstance(MoneyHelper.multiply(str,"100")));
   	  return (bd.movePointLeft(2).toString());
   }

	public static String dealMoneyFormat(long amount) {
   	    String str = Utils.divLongToString(amount);
		BigDecimal bd=new BigDecimal(MoneyHelper.getIntegerInstance(MoneyHelper.multiply(str,"100")));
		return (bd.movePointLeft(2).toString());
	}
   
   /** 
    * 处理金额数值问题

    * @param str String 
    * @param n int 
    * @return String 
    */ 
   public static String shrRadixPoint(String str, int n) { 
   	if ( (str == null) || (str == "") || ("null".equals(str))) {
   		return "0"; 
   	}
   	BigDecimal b1 = new BigDecimal(str);
   	return b1.movePointLeft(n).toString();
   } 


    public static void main(String[] agrs){
   		double d1 = 1.23;
   		double d2 = 2.34;
   		//加法
		System.out.println(MoneyHelper.add(d1,d2));

		//减法
		System.out.println(MoneyHelper.subtract(d2,d1));

		//乘法
		System.out.println(MoneyHelper.multiply(d1,100));

		//除法
		System.out.println(MoneyHelper.divide(d1,2));

		System.out.println(MoneyHelper.multiply(MoneyHelper.divide("1","3"),"3"));

		//四舍五入
		System.out.println(MoneyHelper.round(d1,1));

		//取整
		System.out.println(MoneyHelper.getIntegerInstance(d1));

		//百分号
    	System.out.println(MoneyHelper.getPercentInstance(63.25655,2));

    	//转化
    	System.out.println(MoneyHelper.getCurrencyInstance(333.145,false));
    	System.out.println(MoneyHelper.getCurrencyInstance(333.145,true));

    	//格式化数字
    	NumberFormat   nnf   =   NumberFormat.getInstance();
    	nnf.setMaximumFractionDigits(0);
    	System.out.println(nnf.format(333.5145));

    	//保留分
    	System.out.println(MoneyHelper.dealMoneyFormat("0.006546546"));

    	//转小数
		System.out.println(shrRadixPoint("300000",2));

    }

}

结果：
	3.57
	1.11
	123.0
	0.615
	0.9999999999
	1.2
	1
	6,325.66%
	333.15
	￥333.15
	334
	0.00
	3000.00