精华内容
下载资源
问答
  • java保留两位小数

    2021-03-14 10:17:55
    java保留两位小数问题:方式一:四舍五入double f = 111231.5585;BigDecimal b = new BigDecimal(f);double f1 = b.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();保留两位小数----------------------------...

    java保留两位小数问题:

    方式一:

    四舍五入

    double   f   =   111231.5585;

    BigDecimal   b   =   new   BigDecimal(f);

    double   f1   =   b.setScale(2,   BigDecimal.ROUND_HALF_UP).doubleValue();

    保留两位小数

    ---------------------------------------------------------------

    方式二:

    java.text.DecimalFormat   df   =new   java.text.DecimalFormat("#.00");

    df.format(你要格式化的数字);

    例:new java.text.DecimalFormat("#.00").format(3.1415926)

    #.00 表示两位小数 #.0000四位小数 以此类推...

    方式三:

    double d = 3.1415926;

    String result = String .format("%.2f");

    %.2f %. 表示 小数点前任意位数   2 表示两位小数 格式后的结果为f 表示浮点型

    方式四:

    NumberFormat ddf1=NumberFormat.getNumberInstance() ;

    void setMaximumFractionDigits(int digits)

    digits 显示的数字位数

    为格式化对象设定小数点后的显示的最多位,显示的最后位是舍入的

    import java.text.* ;

    import java.math.* ;

    class TT

    {

    public static void main(String args[])

    { double x=23.5455;

    NumberFormat ddf1=NumberFormat.getNumberInstance() ;

    ddf1.setMaximumFractionDigits(2);

    String s= ddf1.format(x) ;

    System.out.print(s);

    }

    }

    ---------------------------------------------------------------------------------------------------------

    有一篇:

    (1)、浮点数精确计算

    胜利油田三流合一项目中一直存在一个问题,就是每次报表统计的物资金额和实际的金额要差那么几分钱,和实际金额不一致,让客户觉得总是不那么舒服,原因是因为我们使用java的浮点类型double来定义物资金额,并且在报表统计中我们经常要进行一些运算,但Java中浮点数(double、float)的计算是非精确计算,请看下面一个例子:

    System.out.println(0.05 + 0.01);

    System.out.println(1.0 - 0.42);

    System.out.println(4.015 * 100);

    System.out.println(123.3 / 100);

    你的期望输出是什么?可实际的输出确实这样的:

    0.060000000000000005

    0.5800000000000001

    401.49999999999994

    1.2329999999999999

    这个问题就非常严重了,如果你有123.3元要购买商品,而计算机却认为你只有123.29999999999999元,钱不够,计算机拒绝交易。

    (2)、四舍五入

    是否可以四舍五入呢?当然可以,习惯上我们本能就会这样考虑,但四舍五入意味着误差,商业运算中可能意味着错误,同时Java中也没有提供保留指定位数的四舍五入方法,只提供了一个Math.round(double d)和Math.round(float f)的方法,分别返回长整型和整型值。round方法不能设置保留几位小数,我们只能象这样(保留两位):

    public double round(double value){

    return Math.round( value * 100 ) / 100.0;

    }

    但非常不幸的是,上面的代码并不能正常工作,给这个方法传入4.015它将返回4.01而不是4.02,如我们在上面看到的

    4.015 * 100 = 401.49999999999994

    因此如果我们要做到精确的四舍五入,这种方法不能满足我们的要求。

    还有一种方式是使用java.text.DecimalFormat,但也存在问题,format采用的舍入模式是(舍入模式在下面有介绍),比如说4.025保留两位小数会是4.02,因为.025距离”nearest neighbor”(.02和.03)长度是相等,向下舍入就是.02,如果是4.0251那么保留两位小数就是4.03。

    System.out.println(new java.text.DecimalFormat("0.00").format(4.025));

    System.out.println(new java.text.DecimalFormat("0.00").format(4.0251));

    输出是

    4.02

    4.03

    (3)、浮点数输出(科学记数法)

    Java浮点型数值在大于9999999.0就自动转化为科学记数法来表示,我们看下面的例子:

    System.out.println(999999999.04);

    System.out.println(99999999.04);

    System.out.println(10000000.01);

    System.out.println(9999999.04);

    输出的结果如下:

    9.9999999904E8

    9.999999904E7

    1.000000001E7

    9999999.04

    但有时我们可能不需要科学记数法的表示方法,需要转换为字符串,还不能直接用toString()等方法转换,很烦琐。

    BigDecimal介绍

    BigDecimal是Java提供的一个不变的、任意精度的有符号十进制数对象。它提供了四个构造器,有两个是用BigInteger构造,在这里我们不关心,我们重点看用double和String构造的两个构造器(有关BigInteger详细介绍请查阅j2se API文档)。

    (double val)

    Translates a double into a BigDecimal.

    Translates the String representation of a BigDecimal into a BigDecimal.

    BigDecimal(double)是把一个double类型十进制数构造为一个BigDecimal对象实例。

    BigDecimal(String)是把一个以String表示的BigDecimal对象构造为BigDecimal对象实例。

    习惯上,对于浮点数我们都会定义为double或float,但BigDecimal API文档中对于BigDecimal(double)有这么一段话:

    Note: the results of this constructor can be somewhat unpredictable. One might assume thatnew BigDecimal(.1)is exactly equal to .1, but it is actually equal to .10000000000000000555111512312578 27021181583404541015625. This is so because .1 cannot be represented exactly as a double (or, for that matter, as a binary fraction of any finite length). Thus, the long value that is being passed in to the constructor is not exactly equal to .1, appearances notwithstanding.

    The (String) constructor, on the other hand, is perfectly predictable:new BigDecimal(".1")is exactly equal to .1, as one would expect. Therefore, it is generally recommended that the (String) constructor be used in preference to this one

    下面对这段话做简单解释:

    注意:这个构造器的结果可能会有不可预知的结果。有人可能设想new BigDecimal(.1)等于.1是正确的,但它实际上是等于.1000000000000000055511151231257827021181583404541015625,这就是为什么.1不能用一个double精确表示的原因,因此,这个被放进构造器中的长值并不精确的等于.1,尽管外观看起来是相等的。

    然而(String)构造器,则完全可预知的,new BigDecimal(“.1”)如同期望的那样精确的等于.1,因此,(String)构造器是被优先推荐使用的。

    看下面的结果:

    System.out.println(new BigDecimal(123456789.02).toString());

    System.out.println(new BigDecimal("123456789.02").toString());

    输出为:

    123456789.01999999582767486572265625

    123456789.02

    现在我们知道,如果需要精确计算,非要用String来够造BigDecimal不可!

    实现方案

    现在我们已经知道怎么解决这个问题了,原则上是使用BigDecimal(String)构造器,我们建议,在商业应用开发中,涉及金额等浮点数计算的数据,全部定义为String,数据库中可定义为字符型字段,在需要使用这些数据进行运算的时候,使用BigDecimal(String)构造BigDecimal对象进行运算,保证数据的精确计算。同时避免了科学记数法的出现。如果科学记数表示法在应用中不是一种负担的话,可以考虑定义为浮点类型。

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

    源文件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();

    }

    }

    BigDecimal舍入模式(Rounding mode)介绍:

    BigDecimal定义了一下舍入模式,只有在作除法运算或四舍五入时才用到舍入模式,下面简单介绍,详细请查阅J2se API文档

    static int

    Rounding mode to round towards positive infinity.

    向正无穷方向舍入

    static int

    Rounding mode to round towards zero.

    向零方向舍入

    static int

    Rounding mode to round towards negative infinity.

    向负无穷方向舍入

    static int

    Rounding mode to round towards "nearest neighbor" unless both neighbors are equidistant, in which case round down.

    向(距离)最近的一边舍入,除非两边(的距离)是相等,如果是这样,向下舍入,例如1.55保留一位小数结果为1.5

    static int

    Rounding mode to round towards the "nearest neighbor" unless both neighbors are equidistant, in which case, round towards the even neighbor.

    向(距离)最近的一边舍入,除非两边(的距离)是相等,如果是这样,如果保留位数是奇数,使用ROUND_HALF_UP,如果是偶数,使用ROUND_HALF_DOWN

    static int

    Rounding mode to round towards "nearest neighbor" unless both neighbors are equidistant, in which case round up.

    向(距离)最近的一边舍入,除非两边(的距离)是相等,如果是这样,向上舍入, 1.55保留一位小数结果为1.6

    static int

    Rounding mode to assert that the requested operation has an exact result, hence no rounding is necessary.

    计算结果是精确的,不需要舍入模式

    static int

    Rounding mode to round away from zero.

    向远离0的方向舍入

    展开全文
  • java保留两位小数4种方法Java中保留小数有四种方法,如下:public class Format {double f = 23065.57845;public void m1() {BigDecimal bg = new BigDecimal(f);double f1 = bg.setScale(2, BigDecimal.ROUND_HALF_...

    java保留两位小数4种方法

    Java中保留小数有四种方法,如下:

    public class Format {

    double f = 23065.57845;

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

    }

    /**

    * @param args

    */

    public static void main(String[] args) {

    Format f = new Format();

    f.m1();

    f.m2();

    f.m3();

    f.m4();

    }

    }

    计算结果如下:

    23065.58

    23065.58

    23065.58

    23,065.58

    2.int类型除以一个输保留一位小数的计算如下:

    int i=15868

    if (i>1000) {

    DecimalFormat df = new DecimalFormat("#.0");

    System.out.println(df.format((float)i/1000)+"km");

    }else{

    System.out.println(i+"m");

    }

    计算结果为:15.9km

    转载自:http://blog.csdn.net/ming1683/article/details/3195058

    展开全文
  • java保留两位小数(不四舍五入)

    千次阅读 2021-04-15 20:32:06
    这篇文章主要介绍了java使double类型保留两位小数的方法,大家参考使用吧 复制代码 代码如下: mport java.text.DecimalFormat; DecimalFormat df = new DecimalFormat("######0.00"); double d1 = 3.23456 double d2 ...

    这篇文章主要介绍了java使double类型保留两位小数的方法,大家参考使用吧 复制代码 代码如下: mport java.text.DecimalFormat; DecimalFormat    df   = new DecimalFormat("######0.00"); double d1 = 3.23456  double d2 = 0.0;double d3 = 2.0;df.format(d1); df.format(d2); df.format(d3); 3个结果分别为:…

    java保留两位小数问题: 方式一: 四舍五入  double   f   =   111231.5585;  BigDecimal   b   =   new   BigDecimal(f);  double   f1   =   b.setScale(2,   BigDecimal.ROUND_HALF_UP).doubleValue();  保留两位小数  ---------------------------------------------------------------   方…

    一.java保留两位小数方式 public static void main(String[] args) { System.out.println("=======DecimalFormat(四舍五入,五入可能失败)========="); DecimalFormat decimalFormat = new DecimalFormat("0.00"); System.out.println(decimalFormat.format(0.235)); //0.23…

    php保留两位小数而且四舍五入 $num = 123213.666666; echo sprintf("%.2f", $num); php保留两位小数而且不四舍五入 $num = 123213.666666; echo sprintf("%.2f",substr(sprintf("%.3f", $num), 0, -2)); php进一法取整 echo ceil(4.3);    // 5 echo ceil(9.999);  // 10 php…

    php保留两位小数并且四舍五入 $num = 123213.666666; echo sprintf("%.2f", $num); php保留两位小数并且不四舍五入 php进一法取整 php舍去法,取整数 echo floor(4.3); // 4 echo floor(9.999); // 9…

    小数例子: PHP保留两位小数并且四舍五入 1 $n=0.1265489; 2 echo sprintf("%.2f", $n); // 0.13 大家可以看到我们用到了sprintf函数对$n进行了格式化%.2f是目标格式,其中2表示两位f表示float(浮点型) 第3为小数6被四舍五入 再看个例子 1 $n=0.1265489 2 echo substr(sprintf("%.3f",$n),0,-1);// 0.12 代码输出了保留2为小数没有四舍五入,实际上…

    php保留两位小数并且四舍五入 $num = 123213.666666; echo sprintf("%.2f", $num); php保留两位小数并且不四舍五入 $num = 123213.666666; echo sprintf("%.2f",substr(sprintf("%.3f", $num), 0, -2)); php进一法取整 echo ceil(4.3); // 5 echo ceil(9.999); // 10 php舍去法,…

    Oracle中,利用sql语句中的函数实现保留两位小数和四舍五入保留两位小数: select trunc(1.23856789,2) from dual round(m,n) 可以四舍五入 trunc(m,n) 直接丢弃,不四舍五入…

    php保留两位小数并且四舍五入 $num = 5566.56831; echo sprintf("%.2f", $num); php保留两位小数并且不四舍五入 $num = 5566.56831; echo sprintf("%.2f",substr(sprintf("%.3f", $num), 0, -2)); php进一法取整 echo ceil(4.2); // 5 php舍去法取整 echo floor(4.2); // 4…

    在实际项目开发中,经常会存在浮点数四舍五入保留几位小数的问题,故收集了几种常用方法: 直接上代码(保留两位小数). Format.java: import java.math.BigDecimal; import java.text.DecimalFormat; import java.text.NumberFormat; class Format { private double src_num; public Format(double num){ src_num = num; } /* *…

    1.  String类型数字始终保留两位小数 , RoundingMode.HALF_UP); return bd.toString(); } /** * 使用DecimalFormat,保留小数点后两位 */ public static String format2(double value) { DecimalFormat df = new DecimalFormat("0.00"); df.setRoundingMode(RoundingMode.HALF_UP); return…

    选中若干单元格,然后右击设置单元格格式,数值中保留两位小数   使用round函数四舍五入,如下图所示,我在N10单元格中输入"ROUND(M10,1)"即可,其中ROUND是函数名,M10是要被处理的数字,后面的1是保留1为小数,如果要哦保留两位小数就写2,下面的单元格照着拖就行了.  …

    有时候在测试过程中会截取返回值,当你截取的值不是最终的值,需要进行计算后才能使用并且需要保留两位小数,不进行四舍五入的计算: 此时 我使用了各种办法,但是最终我采用了一种最直接,最暴力的方法就是先乘后除,先变int后转floa. Action(){ float a = 2.8999;float b;b = ((int)(a * 100))/100.0; lr_output_message("保留两位小数%.2f\n",b); return 0;} 结果:保留两位小数2.89.以上为测试…

    import java.text.DecimalFormat; import java.math.RoundingMode; class Text{ public static void main(String args[]){ DecimalFormat formater = new DecimalFormat(); formater.setMaximumFractionDigits(2); formater.setGroupingSize(0); formater.setRoundingMo…

    喵喵最近经常遇到小数点保留的问题,转载一篇Java里面的几种小数点位数控制方法. 这是转载的原地址:https://www.cnblogs.com/chenrenshui/p/6128444.html 新手上路,多多关照.有什么错误请大家在评论区指出. 话不多说,上代码: import java.math.BigDecimal; import java.text.DecimalFormat; import java.text.NumberFormat; public class format {…

    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); , BigDecimal.ROUND_HALF_UP).doubleValue(); System.out.prin…

    Math.Round(45.367,2)     //Returns   45.37 Math.Round(45.365,2)     //Returns   45.36 C#中的Round()不是我们中国人理解的四舍五入,是老外的四舍五入,是符合IEEE标准的四舍五入,具体是四舍六入,下面的才是符合中国人理解的四舍五入 Math.Round(45.367,2,MidpointRounding.AwayFromZero);//45.37 Math.Round(45.365,2,MidpointR…

    01.import java.math.BigDecimal; 02.import java.text.DecimalFormat; 03.import java.text.NumberFormat; 04. 05.public class format { 06. double f = 111231.5585; 07. public void m1() { 08. BigDecimal bg = new BigDecimal(f); 09. double f1 = bg.setScale(2,…

    import java.math.BigDecimal; import java.text.DecimalFormat; import java.text.NumberFormat; publicclass format { double f = 111231.5585; publicvoid m1() { BigDecimal bg = new BigDecimal(f); double f1 = bg.setScale(2, BigDecimal.ROUND_HALF_UP).doubleV…

    1 Math.Round(45.367,2) //Returns 45.37 2 Math.Round(45.365,2) //Returns 45.36 C#中的Round()不是我们中国人理解的四舍五入,是老外的四舍五入,是符合IEEE标准的四舍五入,具体是四舍六入,下面的才是符合中国人理解的四舍五入 1 Math.Round(45.367,2,MidpointRounding.AwayFromZero); //Returns 45.37 2 Math.Round(45.365,2,Midp…

    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).doubl…

    下面直接上代码: DecimalFormat df1 = new DecimalFormat("#.00");DecimalFormat df2 = new DecimalFormat("######0.00");double d1 = 1.0;double d2 = 5;double d3 = 0.11;double d4 = 1.11;System.out.println("df1:"+df1.format(d1)+" pk &qu…

    mport java.text.DecimalFormat; DecimalFormat df = new DecimalFormat("######0.00"); double d1 = 3.23456 double d2 = 0.0; double d3 = 2.0; df.format(d1); df.format(d2); df.format(d3); 3个结果分别为: 3.23 0.00 2.00 java保留两位小数问题: 方式一: 四舍五入 double f = 1112…

    1. 功能 将程序中的double值精确到小数点后两位.可以四舍五入,也可以直接截断. 比如:输入12345.6789,输出可以是12345.68也可以是12345.67.至于是否需要四舍五入,可以通过参数来决定(RoundingMode.UP/RoundingMode.DOWN等参数). 2. 实现代码 package com.clzhang.sample; import java.math.BigDecimal; import java.math.RoundingMode; import j…

    java保留两位小数问题: 方式一: 四舍五入  double   f   =   111231.5585;  BigDecimal   b   =   new   BigDecimal(f);  double   f1   =   b.setScale(2,   BigDecimal.ROUND_HALF_UP).doubleValue();  保留两位小数  ---------------------------------------------------------------   方…

    http://blog.csdn.net/yuhua3272004/article/details/3075436 使用java.math.BigDecimal工具类实现   java保留两位小数问题: 方式一(四舍五入形式保留两位小数,注意模式ROUND_HALF_UP): 四舍五入   double   f   =   111231.5585;   BigDecimal   b   =   new   BigDecimal(f);   double   f1   =   b.setScale…

    java使double保留两位小数的多方法 java保留两位小数 mport java.text.DecimalFormat; DecimalFormat df = new DecimalFormat("######0.00"); double d1 = 3.23456 double d2 = 0.0; double d3 = 2.0; df.format(d1); df.format(d2); df.format(d3); 3个结果分别为: 3.23 0.00 2.00 java保留…

    转载:http://blog.csdn.net/wj_j2ee/article/details/8560132 java保留两位小数问题: 方式一: 四舍五入  double   f   =   111231.5585;  BigDecimal   b   =   new   BigDecimal(f);  double   f1   =   b.setScale(2,   BigDecimal.ROUND_HALF_UP).doubleValue();  保留两位小数  -----------…

    java保留两位小数的方法 import java.math.BigDecimal; import java.text.DecimalFormat; import java.text.NumberFormat; public class NumberFormatDemo { public static void main(String[] args) { // BigDecimal // 保留两位小数 System.out.println(new BigDecimal(0.2).setScale…

    js保留两位小数方法总结 最近在做结算系统,经常需要用到金额保留两位小数,刚开始我一直用的是Angular中的过滤器number |2,但是,这无法满足我的需求.问题是,当用户离开文本框时,我需要将用户输入的内容转换成保留两位小数的格式,我想了好久,没有想出来,然后我试了toFixed()方法,这个方法也不可行,因为它将数据转换成了字符串,传给后台是错的.然后,我就找了其他方法.现在刚好有空,所以就把相关保留两位小数的方法总结了一下,不同的场景用不同的方法,即用即取. 一.四舍五入相关 1.to…

    展开全文
  • Java保留两位小数的实现方法采用四舍五入的方式 : 该方式来自网络import java.math.BigDecimal;import java.text.DecimalFormat;import java.text.NumberFormat;public class format {double f = 111231.5585;...

    Java保留两位小数的实现方法

    采用四舍五入的方式 : 该方式来自网络

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

    }

    }

    结果:

    111231.56

    111231.56

    111231.56

    111,231.56

    采用非四舍五入的方式 :

    public static void main(String[] args) {

    double finalMoney = 27.989;

    System.out.println(finalMoney);

    DecimalFormat formater = new DecimalFormat();

    formater.setMaximumFractionDigits(2);

    formater.setGroupingSize(0);

    formater.setRoundingMode(RoundingMode.FLOOR);

    System.out.println(formater.format(finalMoney));

    }

    结果

    27.989

    27.98

    感谢阅读,希望能帮助到大家,谢谢大家对本站的支持!

    展开全文
  • 这篇文章主要介绍了java使double类型保留两位小数的方法,大家参考使用吧mportjava.text.DecimalFormat;DecimalFormatdf=newDecimalFormat("######0.00");doubled1=3.23456doubled2=0.0;doubled3=2.0;df.format(d1);...
  • java保留两位小数问题

    千次阅读 2020-12-30 05:01:34
    java保留两位小数问题:方式一:四舍五入doublef=111231.5585;BigDecimalb=newBigDecimal(f);doublef1=b.setScale(2,BigDecimal.ROUND_HALF_UP).doubleValue();保留两位小数-----------------------------...
  • import java.math.BigDecimal;import java.text.DecimalFormat;import java.text.NumberFormat;public class testNumber {public static double num = 3.1015926;public static double zero = 0.00000;//方法一:...
  • 保留小数位不四舍五入 public static void main(String[] args) { BigDecimal b = new BigDecimal("2.226667").setScale(2, BigDecimal.ROUND_DOWN); System.out.println(b.toString()); } 输出结果: 2.22 ...
  • 项目中有一个小需求,两个整数相除,结果需要保留两位小数,即1.00、0.50这种数据格式。以下做法不行,因为两整数相除,小数点以后的数字会被截断,让运算结果为整数类型,int x = 10;int y = 20;int a = x/y;System...
  • 在平时写程序的时,可以需要在界面或者页面上展示保留小数点后两位的数据。为了达到这样的展示效果,本文列举了几个方法:使用java.math.BigDecimal使用java.text.DecimalFormat使用java.text.NumberFormat使用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 ...
  • 如下例: double a = 1; double b = 3; BigDecimal num1 = new BigDecimal("" + a); BigDecimal num2 = new ...// 四舍五入保留两位小数 BigDecimal result1 = num1.divide(num2,2, BigDecimal.ROUND_HALF_UP); //
  • double oneDouble = Double.parseDouble(one+ ""); double twoDouble = Double.parseDouble(two+ ""); double rercent = oneDouble / twoDouble ; String result = String.format("%.2f", rercent * 100);
  • Java保留两位小数

    2021-02-28 12:06:08
    原标题:Java保留两位小数double num = 494123.558578923;public void m1() {BigDecimal bg = new BigDecimal(num);double a = bg.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();System.out.println(a);}...
  • Java保留两位小数的几种写法总结

    千次阅读 2020-12-20 08:56:11
    使用java.math.BigDecimal2. 使用java.text.DecimalFormat3. 使用java.text.NumberFormat4. 使用java.util.Formatter5. 使用String.format文章末尾给大家分享了更多的拓展知识,另外可以自己实现或者借用封装好的...
  • 4种方法,都是四舍五入,例: import java.math.BigDecimal; import java.text.DecimalFormat; import java.text.NumberFormat; public class format { double f = 111231.5585; public void m1() { ...
  • java小技巧:保留两位小数&&计算年龄/*** java实现:保留两位小数.此方法只适用于保留两位小数的情况.**/public double keep2DigitPrecision(double input){double ret ;ret = Math.round(input*100)/100.00...
  • 剖析Java输出怎么保留两位小数

    千次阅读 2021-02-26 18:50:02
    Java中,当两个整数相除时,由于小数点以后的数字会被截断,运算结果将为整数,此时若希望得到运算结果为浮点数,必须将两整数其一或是两者都强制转换为浮点数,也就是Java输出怎么保留两位小数?接下来郑州达内Java...
  • 使用BigDecimal,保留小数点后两位public static String format1(double value) {BigDecimal bd = new BigDecimal(value);bd = bd.setScale(2, RoundingMode.HALF_UP);return bd.toString();}使用DecimalFormat,保留...
  • 在写程序的时候,有时候可能...本文以两位小数为例给出四种方法。package CodeJava_Leet;import java.math.BigDecimal;import java.text.DecimalFormat;import java.text.NumberFormat;/*** Created by Yechengpeng ...
  • 首先,简单的聊一下我认为的 4 年经验左右、优秀的 Java 程序员应该具备的技能有哪些,按“专业技能”和“项目”块,包括但不限于以下内容。 专业技能方面 基础:JDK 常用类的原理、源码、使用场景。 设计模式:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 36,044
精华内容 14,417
关键字:

java保留两位小数

java 订阅
友情链接: Archive.zip