java 保留两位小数的几种方法

1.代码：

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

public class format {
 double f = 111231.5585;
 public void m1() {
  BigDecimal bg = new BigDecimal(f);
  double f1 = bg.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
  System.out.println(f1);
 }
 /**
  * DecimalFormat转换最简便
  */
 public void m2() {
  DecimalFormat df = new DecimalFormat("#.00");
  System.out.println(df.format(f));
 }
 /**
  * String.format打印最简便
  */
 public void m3() {
  System.out.println(String.format("%.2f", f));
 }
 public void m4() {
  NumberFormat nf = NumberFormat.getNumberInstance();
  nf.setMaximumFractionDigits(2);
  System.out.println(nf.format(f));
 }
 public static void main(String[] args) {
  format f = new format();
  f.m1();
  f.m2();
  f.m3();
  f.m4();
 }
}

2.输出结果:

111231.56
111231.56
111231.56
111,231.56

这里我们提供了一个工具类，定义浮点数的加、减、乘、除和四舍五入等运算方法。以供参考。

源文件MathExtend.java：

import java.math.BigDecimal;

public class MathExtend

{

 //默认除法运算精度

 private static final int DEFAULT_DIV_SCALE = 10;



 /**

 * 提供精确的加法运算。

 * @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_EVEN

 * @param v1

 * @param v2

 * @return 两个参数的商

 */

 public static double divide(double v1, double v2)

 {

   return divide(v1, v2, DEFAULT_DIV_SCALE);

 }



 /**

  * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指

  * 定精度，以后的数字四舍五入。舍入模式采用ROUND_HALF_EVEN

  * @param v1

  * @param v2

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

  * @return 两个参数的商

  */

 public static double divide(double v1,double v2, int scale)

 {

   return divide(v1, v2, scale, BigDecimal.ROUND_HALF_EVEN);

 }



 /**

  * 提供（相对）精确的除法运算。当发生除不尽的情况时，由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_EVEN

  * @param v1

  * @param v2

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

  */

 public static String divide(String v1, String v2)

 {

   return divide(v1, v2, DEFAULT_DIV_SCALE);

 }



 /**

  * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指

  * 定精度，以后的数字四舍五入。舍入模式采用ROUND_HALF_EVEN

  * @param v1

  * @param v2

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

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

  */

 public static String divide(String v1, String v2, int scale)

 {

   return divide(v1, v2, DEFAULT_DIV_SCALE, BigDecimal.ROUND_HALF_EVEN);

 }



 /**

  * 提供（相对）精确的除法运算。当发生除不尽的情况时，由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_EVEN

  * @param v 需要四舍五入的数字

  * @param scale 小数点后保留几位

  * @return 四舍五入后的结果

  */

 public static double round(double v,int scale)

 {

   return round(v, scale, BigDecimal.ROUND_HALF_EVEN);

 }

 /**

  * 提供精确的小数位四舍五入处理

  * @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_EVEN

  * @param v 需要四舍五入的数字

  * @param scale 小数点后保留几位

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

  */

 public static String round(String v, int scale)

 {

  return round(v, scale, BigDecimal.ROUND_HALF_EVEN);

 }

 /**

  * 提供精确的小数位四舍五入处理

  * @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();

 }

}