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

 }

}