DecimalFormat

最新推荐文章于 2024-06-27 13:28:25 发布
最新推荐文章于 2024-06-27 13:28:25 发布
阅读量602 收藏
点赞数
分类专栏： 自定义view之路 自定义view
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_31057219/article/details/78464813
版权

参考：Java DecimalFormat 用法

简介：

DecimalFormat 是 NumberFormat 的一个具体子类，用于格式化十进制数字。

public abstract class Format implements Serializable, Cloneable {}

public abstract class NumberFormat extends Format  {}

public class DecimalFormat extends NumberFormat {}

将数字进行格式化，比如取2位小数，这是最常见的。Java 提供 DecimalFormat　类，帮你用最快的速度将数字格式化。

DecimalFormat 类主要靠 # 和 0 两种占位符号来指定数字长度。

模式中的”#”表示如果该位存在字符，则显示字符，如果不存在，则不显示。

//符号含义：
//        E:表示有几位小数
//        0 一个数字
//        # 一个数字，不包括 0
//        . 小数的分隔符的占位符
//        , 分组分隔符的占位符
//        ; 分隔格式。
//        - 缺省负数前缀。
//        % 乘以 100 和作为百分比显示
//        ? 乘以 1000 和作为千进制货币符显示；用货币符号代替；
//          如果双写，国际货币符号代替。如果出现在一个模式中，用货币十进制分隔符代 替十进制分隔符。
//        X 前缀或后缀中使用的任何其它字符，用来引用前缀或后缀中的特殊字符。

示例：

import java.text.DecimalFormat;


public class TestNumberFormat {

    public static void main(String[] args) {

//圆周率
        System.out.println(Math.PI);//3.141592653589793
//取一位整数
        System.out.println(new DecimalFormat("0").format(Math.PI));//3
//取一位整数和两位小数
        System.out.println(new DecimalFormat("0.00").format(Math.PI));//3.14
//取两位整数和三位小数，整数不足部分以0填补,小数部分最后一位四舍五入。
        System.out.println(new DecimalFormat("00.000").format(Math.PI));// 03.142
//取所有整数部分
        System.out.println(new DecimalFormat("#").format(Math.PI));//3
//以百分比方式计数，并取两位小数
        System.out.println(new DecimalFormat("#.##%").format(Math.PI));//314.16%


//欧拉常数和自然对数的基数
        System.out.println(Math.E);//2.718281828459045
//取一位整数
        System.out.println(new DecimalFormat("0").format(Math.E));//3
//取一位整数和两位小数
        System.out.println(new DecimalFormat("0.00").format(Math.E));//2.72
//取两位整数和三位小数，整数不足部分以0填补,小数部分最后一位四舍五入。
        System.out.println(new DecimalFormat("00.000").format(Math.E));// 02.718
//取所有整数部分
        System.out.println(new DecimalFormat("#").format(Math.E));//3
//以百分比方式计数，并取两位小数
        System.out.println(new DecimalFormat("#.##%").format(Math.E));//271.83%


        long c = 299792458;//光速
//显示为科学计数法，并取五位小数
        System.out.println(new DecimalFormat("#.#####E0").format(c));//2.99792E8
//显示为两位整数的科学计数法，并取四位小数
        System.out.println(new DecimalFormat("00.####E0").format(c));//29.9792E7
//每三位以逗号进行分隔。
        System.out.println(new DecimalFormat(",###").format(c));//299,792,458
//将格式嵌入文本
        System.out.println(new DecimalFormat("光速大小为每秒,###米。").format(c));


        DecimalFormat f1, f2;
        f1 = new DecimalFormat("0.000");
        f2 = new DecimalFormat("#.000");
        System.out.println("带0号的" + f1.format(0.20));//带0号的0.200
        System.out.println("带#的" + f2.format(0.20));//带#的.200

        f1 = new DecimalFormat("0.00");
        f2 = new DecimalFormat("0.##");
        System.out.println("小数点00：" + f1.format(0.2));//小数点00：0.20
        System.out.println("小数点##：" + f2.format(0.2));//小数点##：0.2

        f1 = new DecimalFormat("0.00");
        f2 = new DecimalFormat("##.00");
        System.out.println("00的整数：" + f1.format(22));//00的整数：22.00
        System.out.println("##的整数：" + f2.format(22));//##的整数：22.00


        DecimalFormat df1 = new DecimalFormat("0.0");
        DecimalFormat df2 = new DecimalFormat("#.#");
        DecimalFormat df3 = new DecimalFormat("000.000");
        DecimalFormat df4 = new DecimalFormat("###.###");
        System.out.println(df1.format(12.34));//12.3
        System.out.println(df2.format(12.34));//12.3
        System.out.println(df3.format(12.34));//012.340
        System.out.println(df4.format(12.34));//12.34
    }
}

工具类：

import java.math.BigDecimal;

public class DecimalCalculate {
    /**
     * 由于Java的简单类型不能够精确的对浮点数进行运算，这个工具类提供精
     * 确的浮点数运算，包括加减乘除和四舍五入。
     */
    //默认除法运算精度
    private static final int DEF_DIV_SCALE = 10;

    //这个类不能实例化
    private DecimalCalculate() {
    }

    /**
     * 提供精确的加法运算。
     *
     * @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 double sub(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 double mul(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.multiply(b2).doubleValue();
    }

    /**
     * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
     * 小数点以后10位，以后的数字四舍五入。
     *
     * @param v1 被除数
     * @param v2 除数
     * @return 两个参数的商
     */
    public static double div(double v1, double v2) {
        return div(v1, v2, DEF_DIV_SCALE);
    }

    /**
     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
     * 定精度，以后的数字四舍五入。
     *
     * @param v1    被除数
     * @param v2    除数
     * @param scale 表示表示需要精确到小数点以后几位。
     * @return 两个参数的商
     */
    public static double div(double v1, double v2, int scale) {
        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, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    /**
     * 提供精确的小数位四舍五入处理。
     *
     * @param v     需要四舍五入的数字
     * @param scale 小数点后保留几位
     * @return 四舍五入后的结果
     */
    public static double round(double v, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b = new BigDecimal(Double.toString(v));
        BigDecimal one = new BigDecimal("1");
        return b.divide(one, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    /**
     * 提供精确的类型转换(Float)
     *
     * @param v 需要被转换的数字
     * @return 返回转换结果
     */
    public static float convertsToFloat(double v) {
        BigDecimal b = new BigDecimal(v);
        return b.floatValue();
    }

    /**
     * 提供精确的类型转换(Int)不进行四舍五入
     *
     * @param v 需要被转换的数字
     * @return 返回转换结果
     */
    public static int convertsToInt(double v) {
        BigDecimal b = new BigDecimal(v);
        return b.intValue();
    }

    /**
     * 提供精确的类型转换(Long)
     *
     * @param v 需要被转换的数字
     * @return 返回转换结果
     */
    public static long convertsToLong(double v) {
        BigDecimal b = new BigDecimal(v);
        return b.longValue();
    }

    /**
     * 返回两个数中大的一个值
     *
     * @param v1 需要被对比的第一个数
     * @param v2 需要被对比的第二个数
     * @return 返回两个数中大的一个值
     */
    public static double returnMax(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.max(b2).doubleValue();
    }

    /**
     * 返回两个数中小的一个值
     *
     * @param v1 需要被对比的第一个数
     * @param v2 需要被对比的第二个数
     * @return 返回两个数中小的一个值
     */
    public static double returnMin(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.min(b2).doubleValue();
    }

    /**
     * 精确对比两个数字
     *
     * @param v1 需要被对比的第一个数
     * @param v2 需要被对比的第二个数
     * @return 如果两个数一样则返回0，如果第一个数比第二个数大则返回1，反之返回-1
     */
    public static int compareTo(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.compareTo(b2);
    }

}

保留位数：

BigDecimal.ROUND_HALF_DOWN : 5去尾，其他四舍五入

BigDecimal.ROUND_HALF_UP : 5进位，其他四舍五入 ，即我们常用的四舍五入

BigDecimal.ROUND_UP : 都进位

BigDecimal.ROUND_DOWN : 都去尾

//保留四位小数测试：
{
    BigDecimal decimal = new BigDecimal("1.12345");
    System.out.println(decimal);
    BigDecimal setScale = decimal.setScale(4,BigDecimal.ROUND_HALF_DOWN);//5去尾，其他四舍五入
    System.out.println(setScale);
    //            1.1234

    BigDecimal setScale1 = decimal.setScale(4,BigDecimal.ROUND_HALF_UP);//5进位，其他四舍五入
    System.out.println(setScale1);
    //            1.1235

    BigDecimal setScale2 = decimal.setScale(4,BigDecimal.ROUND_UP);//都进位
    System.out.println(setScale2);
    //            1.1235

    BigDecimal setScale3 = decimal.setScale(4,BigDecimal.ROUND_DOWN);//都去尾
    System.out.println(setScale3);
    //            1.1234

    /*-------------------------------------------------------------------------------*/

    BigDecimal bigDecimal = new BigDecimal("1.12344");
    System.out.println(bigDecimal);
    BigDecimal setScale4 = bigDecimal.setScale(4,BigDecimal.ROUND_HALF_DOWN);//5去尾，其他四舍五入
    System.out.println(setScale4);
    //            1.1234

    BigDecimal setScale5 = bigDecimal.setScale(4,BigDecimal.ROUND_HALF_UP);//5进位，其他四舍五入
    System.out.println(setScale5);
    //            1.1234

    BigDecimal setScale6 = bigDecimal.setScale(4,BigDecimal.ROUND_UP);//都进位
    System.out.println(setScale6);
    //            1.1235

    BigDecimal setScale7 = bigDecimal.setScale(4,BigDecimal.ROUND_DOWN);//都去尾
    System.out.println(setScale7);
    //            1.1234

    /*-------------------------------------------------------------------------------*/

    BigDecimal bigdecimal = new BigDecimal("1.12346");
    System.out.println(bigdecimal);
    BigDecimal setScale8 = bigdecimal.setScale(4,BigDecimal.ROUND_HALF_DOWN);//5去尾，其他四舍五入
    System.out.println(setScale8);
    //            1.1235

    BigDecimal setScale9 = bigdecimal.setScale(4,BigDecimal.ROUND_HALF_UP);//5进位，其他四舍五入
    System.out.println(setScale9);
    //            1.1235

    BigDecimal setScale10 = bigdecimal.setScale(4,BigDecimal.ROUND_UP);//都进位
    System.out.println(setScale10);
    //            1.1235

    BigDecimal setScale11 = bigdecimal.setScale(4,BigDecimal.ROUND_DOWN);//都去尾
    System.out.println(setScale11);
    //            1.1234
}
Mars-xq
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java DecimalFormat常用方法详解
08-27
Java DecimalFormat常用方法详解 Java DecimalFormat是Java中用于格式化十进制数字的一种常用方法，它继承自NumberFormat类，提供了多种格式化方式，满足不同的需求。在本文中，我们将详细介绍Java DecimalFormat的...
java.text.DecimalFormat类十进制格式化
08-27
Java.text.DecimalFormat类十进制格式化方法详解 Java.text.DecimalFormat类是Java语言中用于格式化十进制数的类，它提供了灵活的格式化方式，能够满足大多数十进制格式化的需求。本文将详细介绍Java.text....
DecimalFormat 的使用
小牧在一直在学习,在前进的道路上大家一起学习，进步。
03-23 817
DecimalFormat是NumberFormat的一个具体子类，用于格式化十进制数字 默认采用的是四舍五入模式，当然我们可以修改模式 具体用法如下 API 地址 下面说2个0 和# double str =1.538; DecimalFormat decimalFormat = new DecimalFormat("0"); Log.e("-----decimalFormat", decimalFormat.format(str));/...
DecimalFormat类
sinat_41233888的博客
01-30 1791
DecimalFormat类： DecimalFormat是NumberFormat十进制数字格式的具体子类 。它具有多种功能，旨在解析和格式化任何语言环境中的数字，包括支持西方，阿拉伯语和印度语数字。它还支持不同类型的数字，包括整数（123），定点数（123.4），科学记数法（1.23E4），百分比（12％）和货币金额（123美元）。而且对于数值的小数部分，默认显示3位小数，在去掉超出小数点后...
DecimalFormat使用
最新发布
weixin_44192642的博客
06-27 174
DecimalFormat 是一个强大的工具，用于将数字格式化为特定的字符串表示形式，具有广泛的灵活性和功能，可以满足各种数字格式化的需求。DecimalFormat 是 Java 中用于格式化数字的类，它可以帮助将数字按照指定的格式进行格式化输出。如果需要更复杂的格式化，比如处理货币符号、百分比等，可以通过 DecimalFormat 的其他方法来实现。"###,###.##"：另一个示例，千位分隔符，保留至少一位小数，最多两位小数。"#,###.00"：表示数字，千位分隔符，保留两位小数。
DecimalFormat 格式化函数
惊鸿的博客
05-18 176
DecimalFormat 格式化函数示例 示例 object Test1 { def main(args: Array[String]): Unit = { val pi = 3.1415927 //取一位整数 println(new DecimalFormat("0").format(pi)) //3 //取一位整数和两位小数 println(new DecimalFormat("0.00").format(pi)) //3.14 //取两位整数和
decimalformat精度丢失_DecimalFormat
weixin_33410492的博客
01-12 521
DecimalFormat是格式为十进制数的NumberFormat的具体子类。它具有各种功能，旨在使任何地区的数字解析和格式化，包括支持西方，阿拉伯语和印度数字。它还支持不同类型的数字，包括整数(123)，定点数(123.4)，科学记数法(1.23E4)，百分比(12％)和货币金额(123美元)。所有这些都可以进行本地化。要获取特定区域设置的NumberFormat (包括默认语言环境)，请致电...
DecimalFormat的使用
qq_40321119的博客
03-10 130
https://www.jianshu.com/p/b3699d73142e
DecimalFormat的用法
WangXiaoYuuuuu
10-17 694
记一次DecimalFormat用法 这里我用到的是将浮点数类型的数字,在转换成字符串时,需要去掉小数点后的几位数. 做一下总结，以及一些基本用法 demo: float a = 3.14; 去掉小数位 String b = new DecimalFormat(“0”).format(a); //b=3 注意:在用0尽心格式化的时候,如果传入的参数当前位没有数字,会补上0 如:String b...
DecimalFormat用法
Yohann17的博客
07-25 1393
DecimalFormat用法
Java 格式化之DecimalFormat
weixin_44021334的博客
09-16 341
如题，格式化时保留小数点后2位是0省略，此类需求可以使用。初始化 DecimalFormat 时传 pattern ，根据 pattern 来格式化，
DecimalFormat多种用法详解
08-27
DecimalFormat 多种用法详解 DecimalFormat 是 Java 中一个强大的格式化工具，主要用于数字的格式化和解析。下面我们将详细介绍 DecimalFormat 的多种用法。 格式化数字 使用 DecimalFormat 可以根据本地设置或...
Java中DecimalFormat用法详解
08-27
Java中DecimalFormat用法详解 DecimalFormat是Java中一种重要的格式化工具，主要用于将数字格式化为指定的样式。通过使用DecimalFormat，我们可以将数字转换为各种格式，例如取小数点后几位、科学计数法、百分比...
java.text.DecimalFormat用法详解
08-27
java.text.DecimalFormat用法详解 Java中的java.text.DecimalFormat类提供了格式化数字的功能，通过指定pattern来控制数字的格式。下面将详细介绍DecimalFormat的用法和主要特征。 Pattern DecimalFormat的...
Android-垂直上下滚动的TextView
火星男孩的分享空间
07-05 7121
来自：https://github.com/paradoxie/AutoVerticalTextview 参考博客：Android-实现上下滚动的textview相关类的继承关系：public class View implements Drawable.Callback, KeyEvent.Callback, AccessibilityEventSource {...} publ
Android 抗锯齿的两种方式
火星男孩的分享空间
11-10 4229
出现锯齿条件：倾斜或旋转、快速变化。 当在屏幕上画一条直线时, 横竖不会出现锯齿, 但是当斜着画时, 就会出现锯齿的效果。方式一：通过画笔配置：paint.setAntiAlias(true); 方式二：通过画布配置：canvas.setDrawFilter(new PaintFlagsDrawFilter(0, Paint.ANTI_ALIAS_FLAG|Paint.FILTER_BITMAP
onMeasure与onSizeChanged获取尺寸区别
火星男孩的分享空间
06-06 3264
自定义view如下： public class MyView extends View { private static final int DEFAULT_WIDTH = 100; private static final int DEFAULT_HEIGHT = 100; private Paint paint; private Rect rect; ...
android : 属性动画
火星男孩的分享空间
02-09 2688
//属性动画 public final class ObjectAnimator extends ValueAnimator {...}public class ValueAnimator extends Animator {...}public final class AnimatorSet extends Animator {...}//补间动画 public class AnimationSe
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值