返回 登录
0

Java 字符串格式化详解

在 Java 的 String 类中,可以使用 format() 方法格式化字符串,该方法有两种重载形式: String.format(String format, Object… args) 和 String.format(Locale locale, String format, Object… args) 。两者的唯一区别是前者使用本地语言环境,后者使用指定语言环境

查看源码可以发现,该方法最终调用 java.util.Formatter 类的 format 方法。

public static String format(String format, Object... args) {
   return new Formatter().format(format, args).toString();
}

public static String format(Locale l, String format, Object... args) {
   return new Formatter(l).format(format, args).toString();
}

所以,掌握了 Formatter 的使用,也就掌握了 String.format 的使用,从此 Java 中格式化字符串再无敌手~ 所以我们这里先来讲解 Formatter 的用法。

参考 Java Api 中关于 Formatter 的使用说明,我们可以发现 format 方法的第一个参数是有固定格式的。其格式如下:

%[argument_index$][flags][width][.precision]conversion

argument_index: 可选,是一个十进制整数,用于表明参数在参数列表中的位置。第一个参数由 "1$" 引用,第二个参数由 "2$" 引用,依此类推。

flags: 可选,用来控制输出格式

width: 可选,是一个正整数,表示输出的最小长度

precision:可选,用来限定输出的精度

conversion:必须,用来表示如何格式化参数的字符

参考文档,可以发现 Java 其实把格式化划分为两大类:常规类型格式化和时间日期格式化,下面我们就先来介绍一下常规类型的格式化。

补充:Java 中对格式化其实还有根据类型来分类的,但这里为了方便讲述,只简单的依据格式化的参数类型来讲述,如果以后有机会,会开一篇更详细的博客。

常规类型格式化

在开始之前,这里先放一段 Api 中提供的示例代码,你可以带着示例中的问题去看接下来的内容,也可以看完之后回来看示例,你看懂了多少呢?

StringBuilder sb = new StringBuilder();
// Send all output to the Appendable object sb
Formatter formatter = new Formatter(sb, Locale.US);

// Explicit argument indices may be used to re-order output.
formatter.format("%4$2s %3$2s %2$2s %1$2s", "a", "b", "c", "d")
// -> " d  c  b  a"

// Optional locale as the first argument can be used to get
// locale-specific formatting of numbers.  The precision and width can be
// given to round and align the value.
formatter.format(Locale.FRANCE, "e = %+10.4f", Math.E);
// -> "e =    +2,7183"

// The '(' numeric flag may be used to format negative numbers with
// parentheses rather than a minus sign.  Group separators are
// automatically inserted.
formatter.format("Amount gained or lost since last statement: $ %(,.2f",
               balanceDelta);
// -> "Amount gained or lost since last statement: $ (6,217.58)"

// Writes a formatted string to System.out.
System.out.format("Local time: %tT", Calendar.getInstance());
// -> "Local time: 13:34:18"

// Writes formatted output to System.err.
System.err.printf("Unable to open file '%1$s': %2$s",
                fileName, exception.getMessage());
// -> "Unable to open file 'food': No such file or directory"

Calendar c = new GregorianCalendar(1995, MAY, 23);
String s = String.format("Duke's Birthday: %1$tb %1$te, %1$tY", c);
// -> s == "Duke's Birthday: May 23, 1995"

conversion

从上述内容可以发现,只有 conversion 这个参数是必选的。 conversion 是用来表示如何格式化参数的字符。先来看个例子:

//输出:我的名字叫:小明
System.out.println(String.format("大家好,我叫:%s","小明"));

%s是一个占位符, s 是一个转换符,指明将参数格式化为字符串。 值得注意的是,占位符代表的格式化类型必须与参数的类型相兼容,否则运行时会抛出异常 ,如:

System.out.println(String.format("大家好,我叫:%d","小明"));

运行这段代码,就会抛出如下异常:

Exception in thread "main" java.util.IllegalFormatConversionException: d != java.lang.String
    at java.util.Formatter$FormatSpecifier.failConversion(Formatter.java:4302)
    at java.util.Formatter$FormatSpecifier.printInteger(Formatter.java:2793)
    at java.util.Formatter$FormatSpecifier.print(Formatter.java:2747)
    at java.util.Formatter.format(Formatter.java:2520)
    at java.util.Formatter.format(Formatter.java:2455)
    at java.lang.String.format(String.java:2940)

那么,转换符除了 s ,还有哪些呢?那我们就来看下代码:

/**
* conversion 的具体占位符
*/
private static void formatConversion() {
   System.out.println(String.format("'b':将参数格式化为boolean类型输出,`B`的效果相同,但结果中字母为大写。%b", false));
   System.out.println(String.format("'h':将参数格式化为散列输出,原理:Integer.toHexString(arg.hashCode()),`H`的效果相同,但结果中字母为大写。%h", "ABC"));
   System.out.println(String.format("'s':将参数格式化为字符串输出,如果参数实现了 Formattable接口,则调用 formatTo方法。`S`的效果相同。%s", 16));
   System.out.println(String.format("FormatImpl类实现了Formattable接口:%s", new FormatImpl()));
   System.out.println(String.format("'c':将参数格式化为Unicode字符,'C'的效果相同。%c", 'A'));
   System.out.println(String.format("'d':将参数格式化为十进制整数。%d", 11));
   System.out.println(String.format("'o':将参数格式化为八进制整数。%o", 9));
   System.out.println(String.format("'x':将参数格式化为十六进制整数。%x", 17));
   System.out.println(String.format("'e':将参数格式化为科学计数法的浮点数,'E'的效果相同。%E", 10.000001));
   System.out.println(String.format("'f':将参数格式化为十进制浮点数。%f", 10.000001));
   System.out.println(String.format("'g':根据具体情况,自动选择用普通表示方式还是科学计数法方式,'G'效果相同。10.01=%g", 10.01));
   System.out.println(String.format("'g':根据具体情况,自动选择用普通表示方式还是科学计数法方式,'G'效果相同。10.00000000005=%g", 10.00000000005));
   System.out.println(String.format("'a':结果被格式化为带有效位数和指数的十六进制浮点数,'A'效果相同,但结果中字母为大写。%a", 10.1));
   System.out.println(String.format("'t':时间日期格式化前缀,会在后面讲述"));
   System.out.println(String.format("'%%':输出%%。%%"));
   System.out.println(String.format("'n'平台独立的行分隔符。System.getProperty(\"line.separator\")可以取得平台独立的行分隔符,但是用在format中间未免显得过于烦琐了%n已经换行"));
}

private static class FormatImpl implements Formattable {

   @Override
   public void formatTo(Formatter formatter, int flags, int width, int precision) {
       formatter.format("我是Formattable接口的实现类");
   }
}
输出如下:

'b':将参数格式化为boolean类型输出,`B`的效果相同,但结果中字母为大写。false
'h':将参数格式化为散列输出,原理:Integer.toHexString(arg.hashCode()),`H`的效果相同,但结果中字母为大写。fc42
's':将参数格式化为字符串输出,如果参数实现了 Formattable接口,则调用 formatTo方法。`S`的效果相同。16
FormatImpl类实现了Formattable接口:我是Formattable接口的实现类
'c':将参数格式化为Unicode字符,'C'的效果相同。A
'd':将参数格式化为十进制整数。11
'o':将参数格式化为八进制整数。11
'x':将参数格式化为十六进制整数。11
'e':将参数格式化为科学计数法的浮点数,'E'的效果相同。1.000000E+01
'f':将参数格式化为十进制浮点数。10.000001
'g':根据具体情况,自动选择用普通表示方式还是科学计数法方式,'G'效果相同。10.01=10.0100
'g':根据具体情况,自动选择用普通表示方式还是科学计数法方式,'G'效果相同。10.00000000005=10.0000
'a':结果被格式化为带有效位数和指数的十六进制浮点数,'A'效果相同,但结果中字母为大写。0x1.4333333333333p3
't':时间日期格式化前缀,会在后面讲述
'%':输出%。%
'n':平台独立的行分隔符。System.getProperty("line.separator")可以取得平台独立的行分隔符,但是用在format中间未免显得过于烦琐了
已经换行

补充:

对于浮点转换符 ‘e’ 、’E’ 和 ‘f’,精度是小数点分隔符后的位数。如果转换符是 ‘g’ 或 ‘G’,那么精度是舍入计算后所得数值的所有位数。如果转换是 ‘a’ 或 ‘A’,则不必指定精度。
对于部分转换符,如 ‘b’ 和 ‘B’ ,两者转换效果是相似的,但是 ‘B’ 会把输出中的字母都转换为大写,其它相似特性的转换符应该还有好多,大家可以去找一下O(∩_∩)O哈哈~
argument_index

还记得前面那个小明的例子嘛?现在我们来改变一下输出,要求输出如下内容:

//其中,小明、25、小小明都是由参数传递
大家好,我叫:小明,今年:25岁。小明是小小明的爸爸。

看到这个,大家会怎么做呢?也许,你会写成:

System.out.println(String.format("大家好,我叫:%s,今年:%d岁。%s%s的爸爸。", "小明", 25, "小明", "小小明"));

恩,这样做输出的确没错,但是我们却重复输入参数“小明”。这里,就要用到 argument_index 这个参数。使用 argument_index 可以指定使用第几个参数来替换占位符,一旦使用 argument_index 用于指出参数在参数列表中位置,则所有占位符都要加上,否则会出错。修改之后的代码如下:

System.out.println(String.format("大家好,我叫:%1$s,今年:%2$d岁。%1$s%3$s的爸爸。", "小明", 25, "小小明"));

补充:对于

System.out.println(String.format("大家好,我叫:%s,今年:%d岁。%s%s的爸爸。", "小明", 25, "小明", "小小明"));

在 Java 中执行可能没什么问题,但如果把 “大家好,我叫:%s,今年:%d岁。%s是%s的爸爸。” 放到 Android 的 strings.xml 中,则会出现错误,解决办法就是指明每个参数在参数列表中位置。

flags

flags是可选参数,用于控制输出的格式,比如左对齐、金额用逗号隔开。

'-' 在最小宽度内左对齐,不可以与“用0填充”同时使用

'+' 结果总是包括一个符号

' ' 正值前加空格,负值前加负号

'0' 结果将用零来填充

','3位数字之间用“,”分隔(只适用于fgG的转换)

'(' 若参数是负数,则结果中不添加负号而是用圆括号把数字括起来(只适用于eEfgG的转换)
/**
* flags 的标识
*/
private static void formatFlags() {
   System.out.println("'-':在最小宽度内左对齐,不可与\"用0填充\"同时使用。");
   System.out.println(String.format("设置最小宽度为8为,左对齐。%-8d:%-8d:%-8d%n", 1, 22, 99999999));
   System.out.println(String.format("'0':结果将用零来填充。设置最小宽度为8,d:d:d", 1, -22, 99999990));
   System.out.println(String.format("'+':结果总是包括一个符号。%+d:%+d:%+d", 1, -2, 0));
   System.out.println(String.format("' ':正值前加空格,负值前加负号。% d:% d:% d", 1, -2, 0));
   System.out.println(String.format("',':每3位数字之间用“,”分隔(只适用于fgG的转换)。%,d:%,d:%,d", 1, 100, 1000));
   System.out.println(String.format("'(':若参数是负数,则结果中不添加负号而是用圆括号把数字括起来(只适用于eEfgG的转换)。%(d:%(d", 1, -1));
}

输出如下:

'-':在最小宽度内左对齐,不可与"用0填充"同时使用。
设置最小宽度为8为,左对齐。1       :22      :99999999

'0':结果将用零来填充。设置最小宽度为800000001:-0000022:99999990
'+':结果总是包括一个符号。+1:-2:+0
' ':正值前加空格,负值前加负号。 1:-2: 0
',':3位数字之间用“,”分隔(只适用于fgG的转换)。1:100:1,000
'(':若参数是负数,则结果中不添加负号而是用圆括号把数字括起来(只适用于eEfgG的转换)。1:(1)

width

width是可选参数,用于控制输出的宽度。示例如下:

System.out.println(String.format("设置最小宽度为8,不满8位用0填充:d:d", 1, -10000000));

输出如下:

设置最小宽度为8,不满8位用0填充:00000001:-10000000

但是 width 的值不能为 0 ,否则会抛出

Exception in thread "main" java.util.DuplicateFormatFlagsException: Flags = '0'
    at java.util.Formatter$Flags.parse(Formatter.java:4443)
    at java.util.Formatter$FormatSpecifier.flags(Formatter.java:2640)
    at java.util.Formatter$FormatSpecifier.<init>(Formatter.java:2709)
    at java.util.Formatter.parse(Formatter.java:2560)
    at java.util.Formatter.format(Formatter.java:2501)
    at java.util.Formatter.format(Formatter.java:2455)
    at java.lang.String.format(String.java:2940)

precision

precision是可选参数,用来限定输出的精度,用于浮点数。示例如下:

/**
* 格式化精度,仅限浮点数
*/
private static void formatPrecision() {
   //System.out.println(String.format("设置精度为2位:%.2d", 1));
   System.out.println(String.format("设置精度为2位:%.2f", 1f));
}

输出如下:

设置精度为2位:1.00

值得注意的是,如果对整型数据设置精度,则会抛出如下异常:

Exception in thread "main" java.util.IllegalFormatPrecisionException: 2
    at java.util.Formatter$FormatSpecifier.checkInteger(Formatter.java:2984)
    at java.util.Formatter$FormatSpecifier.<init>(Formatter.java:2729)
    at java.util.Formatter.parse(Formatter.java:2560)
    at java.util.Formatter.format(Formatter.java:2501)
    at java.util.Formatter.format(Formatter.java:2455)
    at java.lang.String.format(String.java:2940)

时间日期格式化

在平时开发中,经常会碰到要显示时间日期的。以前写过一篇 Android 时间、日期相关类和方法 的博客,里面对 Android 中经常出现的时间日期格式做了总结,但觉得还是过于繁琐,这次总结 Java 中格式化输出,没想到 Java 中已经包含了如此多关于时间的转换符,完全能应对日常开发需要,而且不用复杂的计算。

Java 中时间日期格式化的转换符可以分为三类,分别是:时间格式化转换符、日期格式化转换符、时间日期格式化转换符。相比于日期和时间日期格式化转换符,时间格式化转换符就相对多一点。

时间日期格式化字符串的格式如下:

%[argument_index$][flags][width]conversion

相对于普通的格式,时间日期格式化少了 precision ,而 conversion 是由两个字符组成,且第一个字符固定为 t 或 T 。

网上部分博文是贴了转换符说明的表格,但是写完代码之后突然发现,Java 格式化输出这部分内容, 看代码和输出其实比看表格更直观,谁让我们是程序员呢? 下面就用代码来讲述一下时间日期格式化转换符的三种类别。

格式化时间

示例代码如下:

/**
* 格式化时间
*/
private static void formatTime() {
   System.out.println("这是格式化时间相关的,具体输出跟你执行代码时间有关");
   Calendar calendar = Calendar.getInstance();
   System.out.println(String.format("'H':2位数24小时制,不足两位前面补0:%tH(范围:00-23)", calendar));
   System.out.println(String.format("'I':2位数12小时制,不足两位前面补0:%tI(范围:01-12)", calendar));
   System.out.println(String.format("'k':24小时制,不足两位不补0:%tk(范围:0-23)", calendar));
   System.out.println(String.format("'l':12小时制,不足两位不补0:%tl(范围:1-12)", calendar));
   System.out.println(String.format("'M':2位数的分钟,不足两位前面补0:%tM(范围:00-59)", calendar));
   System.out.println(String.format("'S':分钟中的秒,2位数,不足两位前面补0,60是支持闰秒的一个特殊值:%tS(范围:00-60)", calendar));
   System.out.println(String.format("'L':3位数的毫秒,不足三位前面补0:%tL(范围:000-999)", calendar));
   System.out.println(String.format("'N':9位数的微秒,不足九位前面补0:%tN(范围:000000000-999999999)", calendar));

   System.out.println(String.format("'p':输出本地化的上午下午,例如,Locale.US为am或pm,Locale.CHINA为上午或下午", calendar));
   System.out.println(String.format(Locale.US, "Local.US=%tp", calendar));
   System.out.println(String.format(Locale.CHINA, "Local.CHINA=%tp", calendar));
   System.out.println();

   System.out.println(String.format("'z':时区:%tz", calendar));
   System.out.println(String.format("'Z':时区缩写字符串:%tZ", calendar));
   System.out.println(String.format("'s':从1970-1-1 00:00到现在所经历的秒数:%ts", calendar));
   System.out.println(String.format("'Q':从1970-1-1 00:00到现在所经历的豪秒数:%tQ", calendar));
}

输出结果如下:

这是格式化时间相关的,具体输出跟你执行代码时间有关
'H':2位数24小时制,不足两位前面补021(范围:00-23'I':2位数12小时制,不足两位前面补009(范围:01-12'k':24小时制,不足两位不补021(范围:0-23'l':12小时制,不足两位不补09(范围:1-12'M':2位数的分钟,不足两位前面补026(范围:00-59'S':分钟中的秒,2位数,不足两位前面补060是支持闰秒的一个特殊值:44(范围:00-60'L':3位数的毫秒,不足三位前面补0502(范围:000-999'N':9位数的微秒,不足九位前面补0502000000(范围:000000000-999999999'p':输出本地化的上午下午,例如,Locale.US为am或pm,Locale.CHINA为上午或下午
Local.US=pm
Local.CHINA=下午

'z':时区:+0800
'Z':时区缩写字符串:CST
's':从1970-1-1 00:00到现在所经历的秒数:1476883604
'Q':从1970-1-1 00:00到现在所经历的豪秒数:1476883604502

格式化日期

示例代码如下:

/**
 * 格式化日期
 */
private static void formatDate() {
    System.out.println("-----------------------我是微笑的分割线O(∩_∩)O哈哈~-----------------------------");
    System.out.println("这是格式化时间相关的,具体输出跟你执行代码时间有关");
    Calendar calendar = Calendar.getInstance();
    System.out.println(String.format("'B':本地化显示月份字符串,如:January、February"));
    System.out.println(String.format("'b':本地化显示月份字符串的缩写,如:Jan、Feb"));
    System.out.println(String.format("'h':本地化显示月份字符串的缩写,效果同'b'"));
    System.out.println(String.format(Locale.US, "Locale.US 月份=%1$tB,缩写=%1$tb", calendar));
    System.out.println(String.format(Locale.CHINA, "Locale.CHINA 月份=%1$tB,缩写=%1$tb", calendar));

    System.out.println(String.format("'A':本地化显示星期几字符串,如:Sunday、Monday"));
    System.out.println(String.format("'a':本地化显示星期几字符串的缩写,如:Sun、Mon"));
    System.out.println(String.format(Locale.US, "Locale.US 星期几=%1$tA,缩写=%1$ta", calendar));
    System.out.println(String.format(Locale.CHINA, "Locale.CHINA 星期几=%1$tA,缩写=%1$ta", calendar));

    System.out.println(String.format("'C':年份除以100的结果,显示两位数,不足两位前面补0:%tC(范围:00-99)", calendar));
    System.out.println(String.format("'Y':显示四位数的年份,格利高里历,即公历。不足四位前面补0:%tY", calendar));
    System.out.println(String.format("'y':显示年份的后两位:%ty(范围:00-99)", calendar));
    System.out.println(String.format("'j':显示当前公历年的天数:第%tj天(范围:001-366)", calendar));
    System.out.println(String.format("'m':显示当前月份:%tm月(范围:01-13?怎么会有13个月?)", calendar));
    System.out.println(String.format("'d':显示是当前月的第几天,不足两位前面补0:%1$tm月第%1$td天(范围:01-31)", calendar));
    System.out.println(String.format("'e':显示是当前月的第几天:%1$tm月第%1$te天(范围:1-31)", calendar));
}

输出结果如下:

这是格式化时间相关的,具体输出跟你执行代码时间有关
'B':本地化显示月份字符串,如:January、February
'b':本地化显示月份字符串的缩写,如:Jan、Feb
'h':本地化显示月份字符串的缩写,效果同'b'
Locale.US 月份=October,缩写=Oct
Locale.CHINA 月份=十月,缩写=十月
'A':本地化显示星期几字符串,如:Sunday、Monday
'a':本地化显示星期几字符串的缩写,如:Sun、Mon
Locale.US 星期几=Wednesday,缩写=Wed
Locale.CHINA 星期几=星期三,缩写=星期三
'C':年份除以100的结果,显示两位数,不足两位前面补020(范围:00-99'Y':显示四位数的年份,格利高里历,即公历。不足四位前面补02016
'y':显示年份的后两位:16(范围:00-99'j':显示当前公历年的天数:第293天(范围:001-366'm':显示当前月份:10月(范围:01-13?怎么会有13个月?)
'd':显示是当前月的第几天,不足两位前面补010月第19天(范围:01-31'e':显示是当前月的第几天:10月第19天(范围:1-31

补充:在文档中发现一个略微奇怪的问题,就是 m 转换符,文档上的大意是:该转换符用于显示当前月是这一年的第几个月,文档里给的范围竟然是01-13,一年怎么会有13个月,告诉我不是我理解错了?

格式化时间日期

示例代码如下:

/**
 * 格式化时间日期
 */
private static void formatTimeAndDate() {
    System.out.println("-----------------------我是微笑的分割线O(∩_∩)O哈哈~-----------------------------");
    System.out.println("这是格式化时间相关的,具体输出跟你执行代码时间有关");
    Calendar calendar = Calendar.getInstance();
    //%tH:%tM的缩写
    System.out.println(String.format("'R':将时间格式化为:HH:MM(24小时制)。输出:%tR", calendar));
    //%tH:%tM:%tS的缩写
    System.out.println(String.format("'T':将时间格式化为:HH:MM:SS(24小时制)。输出:%tT", calendar));
    //%tI:%tM:%tS %Tp的缩写,输出形如:
    System.out.println(String.format("'r':将时间格式化为:09:23:15 下午,跟设置的语言地区有关。输出:%tr", calendar));
    //%tm/%td/%ty的缩写,输出形如
    System.out.println(String.format("'D':将时间格式化为:10/19/16。输出:%tD", calendar));
    //%tY-%tm-%td,输出形如:
    System.out.println(String.format("'F':将时间格式化为:2016-10-19。输出:%tF", calendar));
    //%ta %tb %td %tT %tZ %tY,输出形如:Sun Jul 20 16:17:00 EDT 1969
    System.out.println(String.format("'c':将时间格式化为\"Sun Jul 20 16:17:00 EDT 1969\"。输出:%tc", calendar));
}

输出结果如下:

这是格式化时间相关的,具体输出跟你执行代码时间有关
'R':将时间格式化为:HH:MM24小时制)。输出:21:26
'T':将时间格式化为:HH:MM:SS24小时制)。输出:21:26:44
'r':将时间格式化为:09:23:15 下午,跟设置的语言地区有关。输出:09:26:44 下午
'D':将时间格式化为:10/19/16。输出:10/19/16
'F':将时间格式化为:2016-10-19。输出:2016-10-19
'c':将时间格式化为"Sun Jul 20 16:17:00 EDT 1969"。输出:星期三 十月 19 21:26:44 CST 2016

总结

系统的介绍了 Java 中格式化字符串的方式及相关的转换符。不过只是对此有印象,方便日后温习,还得在日常中不断加强使用。

虽然 Formatter 中提供了很多关于时间日期的转换符,而且能满足日常的绝大部分使用,但还是存在限制,所以对于有特殊要求的时间格式,还是要学会自己定制。

String.format 这个方法很实用,但如果是大批量进行字符串格式化,就需要考虑到性能方面的问题,因为每次调用 format() 方法都会 new 一个 Formatter 对象。而在 Java 中频繁创建对象需要大量时间,而且还要花时间对这些对象进行垃圾回收和处理。最好的办法就是自己把 DateFormat 、 NumberFormat 、 MessageFormat 这些类封装成静态工具。

学习Java的同学注意了!!!
学习过程中遇到什么问题或者想获取学习资源的话,欢迎加入Java学习交流群,群号码:454297367 我们一起学Java!

评论