【Java基础】使用NumberFormat 、DecimalFormat进行数字格式化

柔情只为你懂 2022-10-08 00:49 931阅读 0赞

### 文章目录 ###

*  一.NumberFormat
 *   *  1.基本介绍
     *  2.实例化方法
     *  3.货币格式化
     *  4.百分比格式化
     *  5.简单工具类
 *  二.DecimalFormat
 *   *  1.基本介绍
     *  2.常见符号
     *  3.使用
     *   *  3.1. "0" 和 "\#"配合使用
         *  3.2. 科学计数法 "E"
         *  3.3. 分组分隔符和减号
         *   *  3.3.1.分组分隔符 ","
             *  3.3.2.减号 "-"
         *  3.4. 关于前缀、后缀
         *   *  3.4.1. "%" 将数字乘以100
             *  3.4.2. "\\u2030" 将数字乘以1000
             *  3.4.3. "¤(\\u00A4)" 本地化货币符号
             *  3.4.4. " ' " 用于引用特殊的字符，作为前缀或后缀。
         *  3.5. 四舍五入
         *  3.6. 同步
         *  3.7. 特殊值

# 一.NumberFormat #

## 1.基本介绍 ##

*  NumberFormat 是`所有数值格式的抽象父类`。此类提供格式化和解析数值的接口。
 *  NumberFormat 还提供了一些方法来确定哪些语言环境具有数值格式，以及它们的名称是什么。
 *  NumberFormat 可用于格式化和解析任何语言环境的数值。使代码能够完全独立于小数点、千位分隔符甚至所用特定小数位数的语言环境约定，并与数值格式是否为偶小数无关。

## 2.实例化方法 ##

*  **getInstance()、getNumberInstance()**。返回当前默认语言环境的通用数值格式。
 *  **getInstance(Locale)、getNumberInstance(Locale)**。返回指定语言环境的通用数值格式。
 *  **NumberFormat.setMinimumIntegerDigits(int)**。设置数的整数部分所允许的最小位数。
 *  **NumberFormat.setMaximumIntegerDigits(int)**。设置数的整数部分所允许的最大位数。
 *  **NumberFormat.setMinimumFractionDigits(int)**。设置最少小数点位数，不足的位数以0补位，超出的话按实际位数输出。
 *  **NumberFormat.setMaximumFractionDigits(int)**。设置最多保留小数位数，不足不补0。

import java.util.Locale;
    
    public class NumberFormatTest{ 
        public static void main(String[] args) { 
            double d = 12345.676688000;
            NumberFormat nf = NumberFormat.getNumberInstance();
          
            System.out.println(nf.format(d));//12,345.677 默认只保留到小数点后三位
            
            nf.setMinimumIntegerDigits(2);
            System.out.println(nf.format(d));//12,345.677 整数部分大于2位按默认最大小数位数3位输出
            
            d = 1234.0;
            nf.setMaximumIntegerDigits(3);
            System.out.println(nf.format(d));//234
            
            nf = NumberFormat.getInstance();
            d = 12345.6766;
            nf.setMinimumFractionDigits(1);
            System.out.println(nf.format(d));//12,345.677 小数部分大于1位，按默认最大小数位数3位输出
            
            nf.setMinimumFractionDigits(5);
            System.out.println(nf.format(d));//12,345.67660 不够位数补0
            
            nf.setMaximumFractionDigits(1);
            System.out.println(nf.format(d));//12,345.7
            
            nf = NumberFormat.getNumberInstance(Locale.US);
            d = 12345.6789;
            System.out.println(nf.format(d));//12,345.679
            
            nf = NumberFormat.getNumberInstance(Locale.FRANCE);
            System.out.println(nf.format(d));//12 345,679
        }
    }

## 3.货币格式化 ##

1.  **getCurrencyInstance()**。静态方法，建立一个NumberFormat类的对象并返回引用，该引用指定货币格式为系统预设的货币格式。
2.  **getCurrencyInstance(Locale)** 。静态方法，建立一个NumberFormat类的对象，并返回引用，该引用的货币格式由Locale指定。Locale类在java.util包中。

import java.text.NumberFormat;
    import java.util.Locale;
    
    public class NumberFormatTest{ 
        public static void main(String[] args) { 
            //按系统预设的货币格式输出，这里是人民币
            NumberFormat nf = NumberFormat.getCurrencyInstance();
            System.out.println(nf.format(123.456));//￥123.46
            
            //按指定的货币格式输出，这里是美元
            //Locale locale = Locale.US;
            nf = NumberFormat.getCurrencyInstance(Locale.US);
            System.out.println(nf.format(123.456));//$123.46
        }
    }

## 4.百分比格式化 ##

1.  **getPercentInstance()**。静态方法，创建一个NumberFormat类的对象并返回其引用。该对象指定百分比格式为系统预设格式。
2.  **getPercentInstance(Locale)**。静态方法，创建一个NumberFormat类的对象并返回引用。该对象的百分比格式由Locale来指定。

import java.text.NumberFormat;
    public class NumberFormatTest { 
        public static void main(String[] args) { 
            //按系统预设百分比格式输出
            double d = 123.456;
            NumberFormat nf = NumberFormat.getPercentInstance();
            System.out.println(nf.format(d));//12,346%
            
            //按指定百分比格式输出，这里是法国格式
            nf = NumberFormat.getPercentInstance(Locale.FRANCE);
            System.out.println(nf.format(d));//12 346 %
        }
    }

## 5.简单工具类 ##

import java.text.DecimalFormat;
    import java.text.NumberFormat;
    
    public class NumberDealUtil { 
        /** * 移除数字前面和后面冗余的0，只保留3位小数 * * @param isFormat 是否需要千位分隔符(,)这种格式输出 * @param num * @return */
        public static String trim0(boolean isFormat, double num) { 
            NumberFormat nf = NumberFormat.getInstance();
            if (!isFormat) { 
                //设置输出格式是否使用“,”分组,默认是使用的
                nf.setGroupingUsed(false);
            }
            String result = nf.format(num);
    // return isFormat ? result : result.replace(",", ""); //用上面代码替换去除分隔符操作
            return result;
        }
    
        /** * 移除数字前面和后面冗余的0 * * @param isFormat 是否需要千位分隔符(,)这种格式输出 * @param num * @param fractionDigit 要保留的小数位数 * @return */
        public static String trim0(boolean isFormat, double num, int fractionDigit) { 
            NumberFormat nf = NumberFormat.getInstance();
            nf.setMaximumFractionDigits(fractionDigit);
            //setMaximumFractionDigits不会保留小数点和后面多余的0，不需下面正则去除
    // if (result.contains(".") && result.endsWith("0")) { 
    // result = result.replaceAll("0+?$", "");//去掉多余的0
    // result = result.replaceAll("[.]$", "");//如最后一位是.则去掉
    // }
            if (!isFormat) { 
                //设置输出格式是否使用“,”分组,默认是使用的
                nf.setGroupingUsed(false);
            }
            String result = nf.format(num);
    // return isFormat ? result : result.replace(",", "");
            return result;
        }
    
        /** * 指定位数输出，不足补0 * 整数部分如果位数大于需要的位数按实际位数输出 * 小数部分如果大于需要的位数四舍五入 * * @param num * @param integerDigit 整数部分位数 * @param fractionDigit 小数部分位数 * @return */
        public static String add0Format(double num, int integerDigit, int fractionDigit) { 
            StringBuilder rule = new StringBuilder();
            if (integerDigit <= 0) { 
                rule.append("#");
            } else { 
                for (int i = 0; i < integerDigit; i++) { 
                    rule.append("0");
                }
            }
            if (fractionDigit > 0) { 
                rule.append(".");
                for (int i = 0; i < fractionDigit; i++) { 
                    rule.append("0");
                }
            }
            DecimalFormat df = new DecimalFormat(rule.toString());
            return df.format(num);
        }
    
        /** * 保留几位小数，不足不补0，小数部分冗余的0也不显示 * * @param num * @param fractionDigit 要保留小数的位数 * @return */
        public static String fractionDigitFormat(double num, int fractionDigit) { 
            /*方法一*/
    // StringBuilder rule = new StringBuilder("#");
    // if (fractionDigit > 0) { 
    // rule.append(".");
    // for (int i = 0; i < fractionDigit; i++) { 
    // rule.append("#");
    // }
    // }
    // DecimalFormat df = new DecimalFormat(rule.toString());
    // return df.format(num);
    
            /*方法二*/
            NumberFormat nf = NumberFormat.getInstance();
            nf.setMaximumFractionDigits(fractionDigit);
            //设置输出格式是否使用“,”分组,这里不使用
            nf.setGroupingUsed(false);
            return nf.format(num);
        }
    }

# 二.DecimalFormat #

## 1.基本介绍 ##

DecimalFormat 是 NumberFormat 的一个具体子类，`用于格式化十进制数字。包含一个模式和一组符号`。

*  **主要靠 \# 和 0 两种占位符号来指定数字长度**。
 *  `“0”`：表示一位数值，如没有，显示0。
    
     *  如“0000.0000”，整数位或小数位>4，按实际输出，<4整数位前面补0小数位后面补0，凑足4位。
    
        //比实际数字的位数多，不足的地方用0补上。
        new DecimalFormat(“00.00”).format(3.14) //结果：03.14
        new DecimalFormat(“0.000”).format(3.14) //结果： 3.140
        new DecimalFormat(“00.000”).format(3.14) //结果：03.140
        //比实际数字的位数少：整数部分不改动，小数部分，四舍五入
        new DecimalFormat(“0.000”).format(13.146) //结果：13.146
        new DecimalFormat(“00.00”).format(13.146) //结果：13.15
        new DecimalFormat(“0.00”).format(13.146) //结果：13.15
 *  `“#”`：表示任意位数的整数。如没有，则不显示。在小数点位使用，只表示一位小数，超出部分四舍五入。
    
     *  如：“\#”：无小数，小数部分四舍五入。“.\#”：整数部分不变，一位小数，四舍五入。“.\#\#”：整数部分不变，二位小数，四舍五入。
    
        //比实际数字的位数多，不变。
        new DecimalFormat(“##.##”).format(3.14) //结果：3.14
        new DecimalFormat(“#.###”).format(3.14) //结果： 3.14
        new DecimalFormat(“##.###”).format(3.14) //结果：3.14
        //比实际数字的位数少：整数部分不改动，小数部分，四舍五入
        new DecimalFormat(“#.###”).format(13.146) //结果：13.146
        new DecimalFormat(“##.##”).format(13.146) //结果：13.15
        new DecimalFormat(“#.##”).format(13.146) //结果：13.15

## 2.常见符号 ##

<table> 
 <thead> 
  <tr> 
   <th>符号</th> 
   <th>位置</th> 
   <th>本地化?</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>0</td> 
   <td>数字</td> 
   <td>是</td> 
   <td>阿拉伯数字</td> 
  </tr> 
  <tr> 
   <td><code>#</code></td> 
   <td>数字</td> 
   <td>是</td> 
   <td>阿拉伯数字如果不存在就显示为空</td> 
  </tr> 
  <tr> 
   <td>.</td> 
   <td>数字</td> 
   <td>是</td> 
   <td>小数分隔符或货币小数分隔符</td> 
  </tr> 
  <tr> 
   <td>-</td> 
   <td>数字</td> 
   <td>是</td> 
   <td>减号</td> 
  </tr> 
  <tr> 
   <td>,</td> 
   <td>数字</td> 
   <td>是</td> 
   <td>分组分隔符</td> 
  </tr> 
  <tr> 
   <td>E</td> 
   <td>数字</td> 
   <td>是</td> 
   <td>分割科学技术法中的尾数和指数。在前缀和后缀中无需添加引号</td> 
  </tr> 
  <tr> 
   <td>;</td> 
   <td>子模式边界</td> 
   <td>是</td> 
   <td>分隔正数和负数子模式</td> 
  </tr> 
  <tr> 
   <td>%</td> 
   <td>前缀或后缀</td> 
   <td>是</td> 
   <td>乘以100并显示为百分数</td> 
  </tr> 
  <tr> 
   <td>/u2030</td> 
   <td>前缀或后缀</td> 
   <td>是</td> 
   <td>乘以1000并显示为千分数</td> 
  </tr> 
  <tr> 
   <td>¤ (\u00A4)</td> 
   <td>前缀或后缀</td> 
   <td>否</td> 
   <td>货币记号，由货币符号替换。如果两个同时出现，则用国际货币符号替换。如果出现在某个模式中，则使用货币小数分隔符，而不使用小数分隔符</td> 
  </tr> 
  <tr> 
   <td>’</td> 
   <td>前缀或后缀</td> 
   <td>否</td> 
   <td>用于在前缀或或后缀中为特殊字符加引号，例如 “’#’#” 将 123 格式化为 “#123”。要创建单引号本身，请连续使用两个单引号："# o’'clock"</td> 
  </tr> 
 </tbody> 
</table>

## 3.使用 ##

### 3.1. “0” 和 "\#"配合使用 ###

import java.text.DecimalFormat;
    
    public class NumberFormatTest { 
        public static void main(String[] args) { 
            //圆周率
            double pi = 3.1415927;
            //取一位整数
            System.out.println(new DecimalFormat("0").format(pi));//3
            //取一位整数和两位小数
            System.out.println(new DecimalFormat("0.00").format(pi));//3.14
            //取两位整数和三位小数，整数不足部分以0填补。
            System.out.println(new DecimalFormat("00.000").format(pi));// 03.142
            //取所有整数部分
            System.out.println(new DecimalFormat("#").format(pi));//3
            //以百分比方式计数，并取两位小数
            System.out.println(new DecimalFormat("#.##%").format(pi));//314.16%
    
            System.out.println("");
    
            //光速
            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));
    
            System.out.println("");
    
            pi = 12.34;
            //整数
            System.out.println(new DecimalFormat("6").format(pi));//612
            System.out.println(new DecimalFormat("60").format(pi));//612
            System.out.println(new DecimalFormat("06").format(pi));//126
            System.out.println(new DecimalFormat("00600").format(pi));//00126
            System.out.println(new DecimalFormat("#####60000").format(pi));//00126
            //小数
            System.out.println(new DecimalFormat(".6").format(pi));//12.6
            System.out.println(new DecimalFormat(".06").format(pi));//12.36
            System.out.println(new DecimalFormat(".60").format(pi));//12.36
            System.out.println(new DecimalFormat(".0600").format(pi));//12.3406
            System.out.println(new DecimalFormat(".6000").format(pi));//12.3406
            System.out.println(new DecimalFormat(".600000##").format(pi));//12.340006
        }
    }

测试结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70]  
我们来对比分析一下上面两个值，很明显.就是我们常用的小数点分隔符，前面是整数，后面是小数。

> 1.整数：若是n个0，就从个位开始向高位填充，如果有值就是原来的值，没有就填充0。  
>         若都是\#，没有实际意义，不管是几个\#，最后的结果都是原来的整数。  
>         0和\#配合使用，`只能是"##00",不能是"00##",就是#在前0在后`。实现是上面的合集。  
> 2.小数：是可以保留小数点后几位的（几个0后或几个\#）。  
>         若n个0，就是保留n位小数，小数不足的部分用0填充。  
>         若n个\#，就是保留n位小数，小数不足部分没有就是没有。  
>         0和\#配合使用，`只能是".00##",不能是".##00",就是0在前#在后`。实现和上面一样。  
> 3.数字（1-9）：上面的分析不是\#就是0，如果是其他的数值会怎样呢？  
> 上面的扩展很详细的说明这个问题。  
>         整数：若没有0或\#，默认在后面拼接整数；若有0或\#，找到第一个0或\#的位置，然后找出所有的0或\#拼在一起，按照上面的规则，在第一个0或\#出现的位置插入响应的格式化以后的值。  
>         小数：若没有0或\#，格式化是什么就显示什么；若有0或\#，找出所有的0或\#拼在一起，按照上面的规则，在小数点的后面插入响应的格式化以后的值。

### 3.2. 科学计数法 “E” ###

pi = 123456789.3456;
    System.out.println(new DecimalFormat("0E0").format(pi));//1E8
    System.out.println(new DecimalFormat("0E00").format(pi));//1E08
    System.out.println(new DecimalFormat("#E0").format(pi));//.1E9
    System.out.println(new DecimalFormat("##E0").format(pi));//1.2E8
    System.out.println(new DecimalFormat("###E0").format(pi));//123E6
    System.out.println(new DecimalFormat("####E0").format(pi));//1.235E8
    System.out.println(new DecimalFormat("#####E0").format(pi));//1234.6E5
    System.out.println(new DecimalFormat("######E0").format(pi));//123.457E6
    System.out.println(new DecimalFormat("#######E0").format(pi));//12.34568E7
    System.out.println(new DecimalFormat("########E0").format(pi));//1.2345679E8
    System.out.println(new DecimalFormat("#########E0").format(pi));//123456789E0
    System.out.println(new DecimalFormat("##########E0").format(pi));//123456789.3E0
          
    pi = 12345678.3456;
    System.out.println(new DecimalFormat("0E0").format(pi));//1E7
    System.out.println(new DecimalFormat("0E00").format(pi));//1E07
    System.out.println(new DecimalFormat("#E0").format(pi));//.1E8
    System.out.println(new DecimalFormat("##E0").format(pi));//12E6
    System.out.println(new DecimalFormat("###E0").format(pi));//12.3E6
    System.out.println(new DecimalFormat("####E0").format(pi));//1235E4
    System.out.println(new DecimalFormat("#####E0").format(pi));//123.46E5
    System.out.println(new DecimalFormat("######E0").format(pi));//12.3457E6
    System.out.println(new DecimalFormat("#######E0").format(pi));//12.34568E7
    System.out.println(new DecimalFormat("########E0").format(pi));//12345678E0
    System.out.println(new DecimalFormat("#########E0").format(pi));//12345678.3E0
    System.out.println(new DecimalFormat("##########E0").format(pi));//12345678.35E0
    
    /** * 0的个数决定最后输出结果的位数 * 并且与0的位置无关 */
    pi = 12345;
    System.out.println(new DecimalFormat("###.##E0").format(pi));//12.345E3
    System.out.println(new DecimalFormat("##0.##E0").format(pi));//12.345E3
    System.out.println(new DecimalFormat("##0.0##E0").format(pi));//12.345E3
    System.out.println(new DecimalFormat("##0.00000##E0").format(pi));//12.3450E3
    System.out.println(new DecimalFormat("#00.0000##E0").format(pi));//12.3450E3
    System.out.println(new DecimalFormat("#00.00000##E0").format(pi));//12.34500E3

> 总结：
> 
> 1.  使用科学计数法，首先保证E前面有0或者\#，否则就不是科学计数法。
> 2.  E后面必须是0，0的个数对后面的显示是有影响的，多余就会填充0.
> 3.  E前面只有一个\#，得到的结果肯定是.开头的结果。
> 4.  E前面\#与0的总个数决定后面的指数，具体：总个数和指数比较，如果指数的值大于总个数，那么得到的指数的值是个数的倍数；如果指数的值小于等于总个数，那么得到的指数的值等于总个数；
> 5.  整个模式中的0的总个数决定最后输出结果的位数，并且与0的位置无关。
> 6.  如果整数部分需要保留几位数，就使用几个0。

### 3.3. 分组分隔符和减号 ###

#### 3.3.1.分组分隔符 “,” ####

pi = 1299792458;
    //每三位以逗号进行分隔。
    System.out.println(new DecimalFormat(",###").format(pi));//1,299,792,458
    System.out.println(new DecimalFormat(",##").format(pi));//12,99,79,24,58
    System.out.println(new DecimalFormat("###,##").format(pi));//12,99,79,24,58

> 上面的代码，最常用的就是千位分隔符。
> 
>  *  不管模式中有多少个分隔符，最右边的那一个有效；每一组的个数就是最右边的分隔符之右的整数位数。

#### 3.3.2.减号 “-” ####

`-`表示输出为`负数`， 要放在最前面。代码如下：

pi = 3.14;
    System.out.println(new DecimalFormat("-0.00").format(pi));//-3.14

### 3.4. 关于前缀、后缀 ###

#### 3.4.1. “%” 将数字乘以100 ####

`%处理最前面`不能放置之外，其他的地方都可以放置。

pi = 0.1234;
    System.out.println(new DecimalFormat("0.00%").format(pi));//12.34%
    System.out.println(new DecimalFormat("0%.00").format(pi));//12.34%
    System.out.println(new DecimalFormat("%0.00").format(pi));//%12.34

#### 3.4.2. “\\u2030” 将数字乘以1000 ####

`\u2030`和`%`用法是一样的。

pi = 0.1234;
    System.out.println(new DecimalFormat("0.00\u2030").format(pi));//123.40‰
    System.out.println(new DecimalFormat("0.0\u20300").format(pi));//123.40‰
    System.out.println(new DecimalFormat("\u20300.00").format(pi));//‰123.40

#### 3.4.3. “¤(\\u00A4)” 本地化货币符号 ####

`如果连续出现2次`，代表`货币符号的国际代号`。

pi = 1234.5678;
    System.out.println(new DecimalFormat(",000.00¤").format(pi));//1,234.57￥
    System.out.println(new DecimalFormat(",000.¤00").format(pi));//1,234.57￥
    System.out.println(new DecimalFormat("¤,000.00").format(pi));//￥1,234.57
    System.out.println(new DecimalFormat(",00¤0.¤00").format(pi));//1,234.57￥￥
    System.out.println(new DecimalFormat("¤,000.¤00").format(pi));//￥1,234.57￥
    System.out.println(new DecimalFormat(",000.00¤¤").format(pi));//1,234.57CNY

#### 3.4.4. " ’ " 用于引用特殊的字符，作为前缀或后缀。 ####

pi = 4.5678;
    System.out.println(new DecimalFormat("'#'0.00").format(pi));//#4.57
    System.out.println(new DecimalFormat("'^ _ ^'0.00").format(pi));//^ _ ^4.57
    //使用'本身作为前缀或后缀
    System.out.println(new DecimalFormat("''0.00").format(pi));//'4.57

### 3.5. 四舍五入 ###

说的就是我们数学上常说的四舍五入的问题。  
DecimalFormat 提供 `RoundingMode`中定义的舍入模式进行格式化。默认情况下，它使用 `Round ingMode.HALF_EVEN`。

### 3.6. 同步 ###

DecimalFormat 通常不是同步的。`建议为每个线程创建独立的格式实例。如果多个线程同时访问某个格式，则必须保持外部同步`。

### 3.7. 特殊值 ###

**"NaN"** 被格式化为一个字符串，通常具有单个字符`\uFFFD`。此字符串由`DecimalFormatSymbols 对象`所确定。这是唯一不使用前缀和后缀的值。

*  `无穷大的值`被格式化为一个字符串，通常具有单个字符 `\u221E`，具有正数或负数前缀和后缀。`无穷大值的字符串由 DecimalFormatSymbols 对象所确定。`

**将负零（"-0"）解析为**

*  如果`isParseBigDecimal()`为 **true**，则为`BigDecimal(0)`，
 *  如果 `isParseBigDecimal()`为 **false** 并且 `isParseIntegerOnly()`为 **true**，则为 `Long(0)`，
 *  如果`isParseBigDecimal()`和 `isParseIntegerOnly()`均为 **false**，则为 `Double(-0.0)`。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70]: /images/20221005/2d6ba3b76e70410d87ac9c35f4acbb3b.png