Java格式化类Format

---

Format介绍

java.text.Format是Java格式化的抽象基类。主要用于将对象格式化为指定模式的字符串，或者将指定模式的字符串解析为对象。

Format方法

- format（格式化）

格式化：对象格式化为字符串。

1. public final String format (Object obj)

   public final String format (Object obj) {
       return format(obj, new StringBuffer(), new FieldPosition(0)).toString();
   }
   1
   2
   3

   一般使用此方法来将对象格式化为字符串，该方法为不可变方法，方法内部调用抽象方法的具体子类实现。

2. public abstract StringBuffer format(Object obj, StringBuffer toAppendTo, FieldPosition pos)
   抽象方法，子类必须实现该方法，定义子类自己具体的对象格式化为字符串的逻辑。

- parseObject（解析）

解析：字符串解析为对象。

1. public Object parseObject(String source) throws ParseException

   public Object parseObject(String source) throws ParseException {
       ParsePosition pos = new ParsePosition(0);
       Object result = parseObject(source, pos);
       if (pos.index == 0) {
           throw new ParseException("Format.parseObject(String) failed",
               pos.errorIndex);
       }
       return result;
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9

   一般使用此方法来将字符串解析为对象，该方法为不可变方法，方法内部调用抽象方法的具体子类实现。

2. public abstract Object parseObject (String source, ParsePosition pos)
   抽象方法，子类必须实现该方法，定义子类自己具体的字符串解析为对象的逻辑。

格式化分类

日期时间格式化

1. DateFormat

日期格式化抽象类，根据当前语言环境格式化日期和时间。

因为DateFormat是一个抽象类，所以不能直接new创建实例对象。但DateFormat提供了一些静态方法便于我们构建DateFormat子类的实例。

常用方法

getInstance

获取格式化的日期时间

• getInstance()：输出样式：22-8-30 下午4:14

getDateInstance

获取格式化的日期

getTimeInstance

获取格式化的时间

getDateTimeInstance

获取格式化的日期时间

方法入参

style

设置输出样式。

DateFormat提供了多种输出样式：

    /**
     * 完整样式
     */
    public static final int FULL = 0;
    /**
     * 长样式
     */
    public static final int LONG = 1;
    /**
     * 中等样式
     */
    public static final int MEDIUM = 2;
    /**
     * 短样式
     */
    public static final int SHORT = 3;
    /**
     * 默认样式：中等样式
     */
    public static final int DEFAULT = MEDIUM;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

Locale

设置语言环境。

• language：语言（zh：中文）
• region：地区（CN：China）

2. SimpleDateFormat

SimpleDateFormat是DateFormat的一个具体实现类，是非线程安全的。

因为DateFormat直接支持的样式比较少，经常满足不了实际需求，于是SimpleDateFormat就来了，SimpleDateFormat提供了丰富的样式且可自定义样式。

在使用SimpleDateFormat的时候，需要通过字母来描述时间元素，并组装成想要的日期和时间模式。

常用模式元素

常用的日期时间元素和字母的对应表如下：

y与Y的区别：

• YY是周年
• yy是日历年，推荐使用y

举例：今天是2019年12月30日，日历年是 2019，但周年是 2020，因为本周是 2020 年的第 1 周。所以yy是19，而YY是20。

使用方法

格式化

public static void main(String[] args) throws ParseException {
    Date date = new Date();
    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("G yyyy-MM-dd HH:mm:ss S E z");
    String format = simpleDateFormat.format(date);
}
1
2
3
4
5

debug：

解析

public static void main(String[] args) throws ParseException {
        String str = "公元 2022-08-30 22:10:03 530 星期二 CST";
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("G yyyy-MM-dd HH:mm:ss S E z");
        Date date1 = (Date) simpleDateFormat.parseObject(str);
}
1
2
3
4
5

debug：

3. ClassicFormat

暂不分析。

数字格式化

1. NumberFormat

数字格式化抽象类，根据当前语言环境格式化数字。

NumberFormat是一个抽象类，不能直接new创建实例对象。NumberFormat提供了一些静态方法便于我们构建NumberFormat子类的实例。

常用方法

getInstance

获取格式化的常规数值

• getInstance()
• getInstance(Locale inLocale)

getNumberInstance

获取格式化的常规数值

• getNumberInstance()
• getNumberInstance(Locale inLocale)

getIntegerInstance

获取格式化的整型数值

• getIntegerInstance()
• getIntegerInstance(Locale inLocale)

getPercentInstance

获取格式化的百分比数值

• getPercentInstance()
• getPercentInstance(Locale inLocale)

getCurrencyInstance

获取格式化的指定语言环境的货币数值

• getCurrencyInstance()
• getCurrencyInstance(Locale inLocale)

方法示例

public static void main(String[] args) throws ParseException {
    NumberFormat instance = NumberFormat.getInstance();
    String format = instance.format(2.3);
    System.out.println("getInstance=====================" + format);
    NumberFormat integerInstance = NumberFormat.getIntegerInstance();
    String format1 = integerInstance.format(2.3);
    System.out.println("getIntegerInstance==============" + format1);
    NumberFormat percentInstance = NumberFormat.getPercentInstance();
    String format2 = percentInstance.format(2.3);
    System.out.println("getPercentInstance==============" + format2);
    NumberFormat currencyInstance = NumberFormat.getCurrencyInstance();
    String format3 = currencyInstance.format(2.3);
    System.out.println("getCurrencyInstance=============" + format3);
    NumberFormat currencyInstance1 = NumberFormat.getCurrencyInstance(Locale.US);
    String format4 = currencyInstance1.format(2.3);
    System.out.println("getCurrencyInstance(Locale.US)==" + format4);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

控制台日志：

getInstance=====================2.3
getIntegerInstance==============2
getPercentInstance==============230%
getCurrencyInstance=============￥2.30
getCurrencyInstance(Locale.US)==$2.30
1
2
3
4
5

2. DecimalFormat

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

DecimalFormat能够分析和格式化任意语言环境中的数字：

• 包括对西方语言、阿拉伯语和印度语数字的支持。
• 支持整数 (123)、定点数 (123.4)、科学记数法表示的数 (1.23E4)、百分数 (12%) 和金额 ($123)等。
• 所有的内容都可以本地化（本地化：使用本地的语言环境）。

需要注意的是：DecimalFormat是非线程安全的。

DecimalFormat支持手动配置模式和使用模式符号。

手动设置模式

• setMaximumFractionDigits(int newValue)：设置小数部分中允许的最大数字位数
• setMinimumFractionDigits(int newValue)：设置小数部分中允许的最小数字位数，如果原数小数位数不够的话，会补零。
• setGroupingSize(int i)：设置分组中一组的位数（整数部分，默认3个数字为一组）。
• setGroupingUsed(boolean value)：设置是否使用分组，true表示使用，false表示取消分组
• setMaximumIntegerDigits(int newValue)：设置整数部分允许的最大数字位数
• setMinimumIntegerDigits(int newValue)：设置整数部分允许的最小数字位数

使用模式符号串

使用方法

格式化

① 手动配置模式

    public static void main(String[] args) throws ParseException {
        DecimalFormat decimalFormat = new DecimalFormat();
        decimalFormat.setGroupingUsed(true);// 使用分组
        decimalFormat.setGroupingSize(4);// 分组中一组的位数
        decimalFormat.setMinimumIntegerDigits(2);// 整数部分最小位数
        decimalFormat.setMaximumIntegerDigits(8);// 整数部分最大位数
        decimalFormat.setMinimumFractionDigits(2);// 小数部分最小位数
        decimalFormat.setMaximumFractionDigits(4);// 小数部分最大位数

        System.out.println(decimalFormat.format(1.11));// 01.11

        System.out.println(decimalFormat.format(11111.222));// 1,1111.222

        System.out.println(decimalFormat.format(11111111111.222222222222));// 1111,1111.2222
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

② 使用模式符号串

    public static void main(String[] args){
        double pi = 3.1415926;

        // 取整数部分，整数部分不足2位补0
        System.out.println(new DecimalFormat("00").format(pi));// 03

        // 取整数部分和10位小数，整数部分不足2位补0，小数部分不足10位补0
        System.out.println(new DecimalFormat("00.0000000000").format(pi));// 03.1415926000

        // 取整数部分，整数部分不足2位不管
        System.out.println(new DecimalFormat("##").format(pi));// 3
        // ###和上面的##没区别
        System.out.println(new DecimalFormat("###").format(pi));// 3

        // 取整数部分和10位小数，整数部分不足2位不管，小数部分不足10位不管
        System.out.println(new DecimalFormat("##.##########").format(pi));// 3.1415926

        // 若输入为非负数，按;前面的正常模式输出
        // 若输入为负数，按;后面的（负数输入的输出前缀+正常模式输出的绝对值）输出
        System.out.println(new DecimalFormat("#.##;前缀").format(3.1415926));// 3.14
        System.out.println(new DecimalFormat("#.##;前缀").format(-3.1415926));// 前缀3.14

        // 百分比方式计数（百分号在末位），取整数部分和2位小数，小数部分不足2位不管
        System.out.println(new DecimalFormat("#.##%").format(pi));// 314.16%

        // 百分比方式计数（百分号在首位），取整数部分和2位小数，小数部分不足2位不管
        System.out.println(new DecimalFormat("%#.##").format(pi));// %314.16

        // 千分比方式计数（千分号在末位），取整数部分和2位小数，小数部分不足2位不管
        System.out.println(new DecimalFormat("#.##\u2030").format(pi));// 3141.59‰

        // 千分比方式计数（千分号在首位），取整数部分和2位小数，小数部分不足2位不管
        System.out.println(new DecimalFormat("\u2030#.##").format(pi));// ‰3141.59

        //显示为科学计数法，并取五位小数
        System.out.println(new DecimalFormat("#.#####E0").format(pi));// 3.14159E0

        //显示为两位整数的科学计数法，并取四位小数
        System.out.println(new DecimalFormat("00.####E0").format(pi));// 31.4159E-1

        //取整数部分，每三位以逗号进行分隔。
        System.out.println(new DecimalFormat(",###").format(pi));// 3

        // 添加货币符号在首位，如果同时出现两个该符号，则用国际货币符号
        System.out.println(new DecimalFormat("¤#.##").format(pi));// ￥3.14
        System.out.println(new DecimalFormat("\u00A4#.##").format(pi));// ￥3.14
        System.out.println(new DecimalFormat("¤¤#.##").format(pi));// CNY3.14

        // 添加货币符号在末位，如果同时出现两个该符号，则用国际货币符号
        System.out.println(new DecimalFormat("#.##¤").format(pi));// 3.14￥
        System.out.println(new DecimalFormat("#.##\u00A4").format(pi));// 3.14￥
        System.out.println(new DecimalFormat("#.##¤¤").format(pi));// 3.14CNY

        // 将特殊字符变为普通字符
        System.out.println(new DecimalFormat("''#.##").format(pi));// '3.14
        System.out.println(new DecimalFormat("#.##''").format(pi));// 3.14'
        System.out.println(new DecimalFormat("'#'#.##").format(pi));// #3.14
        System.out.println(new DecimalFormat("#.##'#'").format(pi));// 3.14#

        //将格式嵌入文本
        System.out.println(new DecimalFormat("圆周率π：#.##").format(pi));// 圆周率π：3.14
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

解析

解析也可以手动配置模式或者使用模式符号串，这里只以使用模式符号串方式举例。

    public static void main(String[] args) throws ParseException {
        System.out.println(new DecimalFormat("圆周率π：#.##").parseObject("圆周率π：3.14"));// 3.14

        System.out.println(new DecimalFormat("#.##;前缀").parseObject("前缀3.14"));// -3.14

        System.out.println(new DecimalFormat("00.####E0").parseObject("31.4159E-1"));// 3.14159
    }
1
2
3
4
5
6
7

3. ChoiceFormat

ChoiceFormat将格式化运用到某个范围的数。

ChoiceFormat与其他Format类的不同之处在于，它使用构造函数放入方式（而不是使用getInstance样式工厂方法）创建ChoiceFormat对象。

注意：limits数组需要升序排列（否则结果会出错）

常用方法

nextDouble(double d)

查找大于d的最小double值，一般用在limits数组中，从而使limits数组形成一个右开区间数组

例如：limits = {0,1,ChoiceFormat.nextDouble(1)}

nextDouble(double d, boolean positive)

1. positive=true，表示查找大于d的最小double值，一般用在limits数组中，从而使limits数组形成一个右开区间数组
2. positive=false，表示查找小于d的最大double值，一般用在limits数组中，从而使limits数组形成一个左开区间数组

previousDouble(double d)

查找小于d的最大double值，一般用在limits数组中，从而使limits数组形成一个左开区间数组

public static void main(String[] args) {
	 System.out.println(ChoiceFormat.nextDouble(1));// 1.0000000000000002
	 System.out.println(ChoiceFormat.nextDouble(1,true));// 1.0000000000000002
	 System.out.println(ChoiceFormat.nextDouble(1,false));// 0.9999999999999999
	 System.out.println(ChoiceFormat.previousDouble(1));// 0.9999999999999999
}
1
2
3
4
5
6

上面三个方法的使用场景：

如果有个这样的需求：

1. 当number < 1时，取值0
2. 当1 <= number <= 2时，取值1
3. 当2 < number <= 3时，取值2
4. 当number > 3时，取值3

代码实现：

    double[] limits = {0, 1, 2, 3};
    String[] formats = {"0","1","2","3"};
    ChoiceFormat format = new ChoiceFormat(limits, formats);
1
2
3

如果这样的写法，显然不能满足：

• number = 2时，取值1
• number = 3时，取值2

我们可以这么写

public static void main(String[] args) {
    double[] limits = {0, 1, ChoiceFormat.nextDouble(2), ChoiceFormat.nextDouble(3)};
    String[] formats = {"0","1","2","3"};
    ChoiceFormat format = new ChoiceFormat(limits, formats);
    System.out.println(format.format(0));
    System.out.println(format.format(1));
    System.out.println(format.format(2));
    System.out.println(format.format(3));
    System.out.println(format.format(4));
}
1
2
3
4
5
6
7
8
9
10

能完全满足上面的需求（number = 2时，取值1；number = 3时，取值2）。

ChoiceFormat(double[] limits, String[] formats)

构造函数中接收一个formats数组和一个limits数组，这两个数组必须具有相同数量的元素。

• 第一个数组是原始双精度数组，表示每个间隔的最小值(起始值)。
• 第二个数组是一个字符串数组，代表与每个间隔关联的名称。

limits数组实际上是个区间，可开可闭，并且必须按升序排列，如果不按升序排列，格式化结果将会不正确，还可以使用\u221E(表示无穷大)。

匹配规则：limits[i] <= number

number表示使用format方法传入的值，i表示limit数组中的索引。当且仅当上述公式成立时，number匹配i，如果不能匹配，则会根据number是太小还是太大，匹配limits数组的第一个索引或最后一个索引，然后使用匹配的limits数组中的索引，去formats数组中寻找相同索引的值。

public static void main(String[] args) {
	double[] limits = {0, 1, 2, 3, 4, 5, 6};
	String[] formats = { "星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日" };
	ChoiceFormat format = new ChoiceFormat(limits, formats);
	System.out.println(format.format(-1));// 星期一
	System.out.println(format.format(0));// 星期一
	System.out.println(format.format(1));// 星期二
	System.out.println(format.format(2.5));// 星期三
	System.out.println(format.format(6.6));// 星期日
	System.out.println(format.format(7));// 星期日
	System.out.println(format.format(8));// 星期日
}
1
2
3
4
5
6
7
8
9
10
11
12

ChoiceFormat(String newPattern)

ChoiceFormat类的构造方法也允许我们传入一个模式字符串，format方法会根据这个模式字符串执行格式化操作。

模式元素的格式：doubleNum [占位符] formatStr

占位符

注意：比较运算符和平时实现相反的，因为该地方类似于变量在比较运算符的右边（平时是在左边）

模式字符串中的每个模式元素之间使用 | 分割，| 前后可以添加空格以美化代码。

其实在ChoiceFormat(String newPattern)构造方法的内部，模式字符串还是被转换为limits和formats两个数组。

public static void main(String[] args) {
	ChoiceFormat choice=new ChoiceFormat("1 # A | 2 < B | 3 \u2264 C | 5 # D");
	System.out.println(choice.format(0));
	System.out.println(choice.format(1));
	System.out.println(choice.format(2));
	System.out.println(choice.format(3));
	System.out.println(choice.format(4));
	System.out.println(choice.format(5));
	System.out.println(choice.format(6));
}
1
2
3
4
5
6
7
8
9
10

字符串格式化

1. MessageFormat

MessageFormat提供与语言环境无关的生成连接消息的方式。

通常用MessageFormat的静态方法format，该方法接收一个字符串的模式和一组对象(对象数组)，按照模式形式将格式化的对象插入到模式中，然后返回字符串结果。

static String format(String pattern, Object … arguments)

• pattern：字符串模式
• arguments：对象数组

模式元素

模式元素格式：ArgumentIndex[,FormatType[,FormatStyle]]

• ArgumentIndex：入参索引位置（从0开始）
• FormatType：格式化类型
• FormatStyle：格式化样式

格式化类型

• date：调用DateFormat进行格式化
• time：调用DateFormat进行格式化
• number：调用NumberFormat进行格式化
• choice：调用ChoiceFormat进行格式化

格式化样式

• short
• medium
• long
• full
• integer
• currency
• percent
• SubformatPattern(子模式)

使用示例

public static void main(String[] args) {
    Date date = new Date();
    System.out.println(MessageFormat.format("{0},{1},{2}", date, date, 1.11));
    System.out.println(MessageFormat.format("{0,date},{1,time},{2,number}", date, date, 1.11));
    System.out.println(MessageFormat.format("{0,date,MEDIUM},{1,time,MEDIUM},{2,number,integer},{3,number,#.#}", date, date, 1.11, 2.22));
}

1
2
3
4
5
6
7

输出：

22-9-5 下午10:47,22-9-5 下午10:47,1.11
2022-9-5,22:47:39,1.11
2022-9-5,22:47:39,1,2.2
1
2
3

2. String.format

String有两个格式化方法

• format(String format, Object… args)
• format(Locale l, String format, Object… args)

format参数

format参数格式：%[index$][flags][width][.precision]conversion

模块

标识

转换符

举例：

public static void main(String[] args) {
    System.out.println(String.format("%2$06.2f======%1$d", 2, 11.1111));// 011.11======2
}
1
2
3