7. JDK拍了拍你：字符串拼接必定记得用MessageFormat#format

分享、成长，拒绝浅藏辄止。关注公号【BAT的乌托邦】，回复专栏获取原创专栏：重学Spring、重学MyBatis、中间件、云计算...本文已被 https://www.yourbatman.cn 收录。

✍前言

你好，我是A哥(YourBatman)。本文所属专栏：Spring类型转换，公号后台回复专栏名便可获取所有内容。

在平常开发中，咱们常常会有格式化的需求，如日期格式化、数字格式化、钱币格式化等等。

格式化器的做用彷佛跟转换器的做用相似，可是它们的关注点却不同：

• 转换器：将类型S转换为类型T，关注的是类型而非格式
• 格式化器： String <-> Java类型。这么一看它彷佛和PropertyEditor相似，可是它的关注点是字符串的格式

Spring有本身的格式化器抽象org.springframework.format.Formatter，可是谈到格式化器，必然就会联想起来JDK本身的java.text.Format体系。为后文作好铺垫，本文就先介绍下JDK为咱们提供了哪些格式化能力。

版本约定

• JDK：8

✍正文

Java里历来都缺乏不了字符串拼接的活，JDK也提供了多种“工具”供咱们使用，如：StringBuffer、StringBuilder以及最直接的+号，相信这些你们都有用过。但这都不是本文的内容，本文将讲解格式化器，给你提供一个新的思路来拼接字符串，而且是推荐方案。

JDK内置有格式化器，即是java.text.Format体系。它是个抽象类，提供了两个抽象方法：

public abstract class Format implements Serializable, Cloneable {
    public abstract StringBuffer format(Object obj, StringBuffer toAppendTo, FieldPosition pos);    
    public abstract Object parseObject (String source, ParsePosition pos);
}

• format：将Object格式化为String，并将此String放到toAppendTo里面
• parseObject：讲String转换为Object，是format方法的逆向操做

Java SE针对于Format抽象类对于常见的应用场景分别提供了三个子类实现：

DateFormat：日期时间格式化

抽象类。用于用于格式化日期/时间类型java.util.Date。虽然是抽象类，但它提供了几个静态方法用于获取它的实例：

// 格式化日期 + 时间
public final static DateFormat getInstance() {
    return getDateTimeInstance(SHORT, SHORT);
}
public final static DateFormat getDateTimeInstance(int dateStyle, int timeStyle, Locale aLocale){
    return get(timeStyle, dateStyle, 3, aLocale);
}

// 格式化日期
public final static DateFormat getDateInstance(int style, Locale aLocale) {
    return get(0, style, 2, aLocale);
}
// 格式化时间
public final static DateFormat getTimeInstance(int style, Locale aLocale){
    return get(style, 0, 1, aLocale);
}

有了这些静态方法，你可在没必要关心具体实现的状况下直接使用：

/**
 * {@link DateFormat}
 */
@Test
public void test1() {
    Date curr = new Date();

    // 格式化日期 + 时间
    System.out.println(DateFormat.getInstance().getClass() + "-->" + DateFormat.getInstance().format(curr));
    System.out.println(DateFormat.getDateTimeInstance().getClass() + "-->" + DateFormat.getDateTimeInstance().format(curr));

    // 格式化日期
    System.out.println(DateFormat.getDateInstance().getClass() + "-->" + DateFormat.getDateInstance().format(curr));

    // 格式化时间
    System.out.println(DateFormat.getTimeInstance().getClass() + "-->" + DateFormat.getTimeInstance().format(curr));
}

运行程序，输出：

class java.text.SimpleDateFormat-->20-12-25 上午7:19
class java.text.SimpleDateFormat-->2020-12-25 7:19:30
class java.text.SimpleDateFormat-->2020-12-25
class java.text.SimpleDateFormat-->7:19:30

嗯，能够看到底层实现实际上是我们熟悉的SimpleDateFormat。实话说，这种作法不经常使用，狠一点：基本不会用（框架开发者可能会用作兜底实现）。

SimpleDateFormat

通常来讲，咱们会直接使用SimpleDateFormat来对Date进行格式化，它能够本身指定Pattern，个性化十足。如：

@Test
public void test2() {
    DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd"); // yyyy-MM-dd HH:mm:ss
    System.out.println(dateFormat.format(new Date()));
}

运行程序，输出：

2020-12-25

关于SimpleDateFormat的使用方式再也不啰嗦，不会的就可走自行劝退手续了。此处只提醒一点：SimpleDateFormat线程不安全。

说明：JDK 8之后再也不建议使用Date类型，也就不会再使用到DateFormat。同时我我的建议：在项目中可强制严令禁用

NumberFormat：数字格式化

抽象类。用于格式化数字，它能够对数字进行任意格式化，如小数、百分数、十进制数等等。它有两个实现类：

类结构和DateFormat相似，也提供了getXXXInstance静态方法给你直接使用，无需关心底层实现：

@Test
public void test41() {
    double myNum = 1220.0455;

    System.out.println(NumberFormat.getInstance().getClass() + "-->" + NumberFormat.getInstance().format(myNum));
    System.out.println(NumberFormat.getCurrencyInstance().getClass() + "-->" + NumberFormat.getCurrencyInstance().format(myNum));
    System.out.println(NumberFormat.getIntegerInstance().getClass() + "-->" + NumberFormat.getIntegerInstance().format(myNum));
    System.out.println(NumberFormat.getNumberInstance().getClass() + "-->" + NumberFormat.getNumberInstance().format(myNum));
    System.out.println(NumberFormat.getPercentInstance().getClass() + "-->" + NumberFormat.getPercentInstance().format(myNum));
}

运行程序，输出：

class java.text.DecimalFormat-->1,220.045
class java.text.DecimalFormat-->￥1,220.05
class java.text.DecimalFormat-->1,220
class java.text.DecimalFormat-->1,220.045
class java.text.DecimalFormat-->122,005%

这一看就知道DecimalFormat是NumberFormat的主力了。

DecimalFormat

Decimal：小数，小数的，十进位的。

用于格式化十进制数字。它具备各类特性，能够解析和格式化数字，包括：西方数字、阿拉伯数字和印度数字。它还支持不一样种类的数字，包括：整数(123)、小数(123.4)、科学记数法(1.23E4)、百分数(12%)和货币金额($123)。全部这些均可以进行本地化。

下面是它的构造器：

其中最为重要的就是这个pattern（不带参数的构造器通常不会用），它表示格式化的模式/模版。通常来讲咱们对DateFormat的pattern比较熟悉，但对数字格式化的模版符号了解甚少。这里我就帮你整理出这个表格（信息源自JDK官网），记得搜藏哦：

符号	Localtion	是否本地化	释义
0	Number	是	Digit
#	Number	是	Digit。如果0就显示为空
.	Number	是	小数/货币分隔符
-	Number	是	就表明减号
,	Number	是	分组分隔符
E	Number	是	科学计数法分隔符（位数和指数）
%	前/后缀	是	乘以100并显示为百分数
¤	前/后缀	否	货币记号。若连续出现两次就用国际货币符号代替
'	先后缀	否	用于引用特殊字符。做用相似于转义字符

说明：Number和Digit的区别：

• Number是个抽象概念，其表达形式能够是数字、手势、声音等等。如1024就是个number
• Digit是用来表达的单独符号。如0-9这是个digit就能够用来表示number，如1024就是由一、0、二、4这四个digit组成的

看了这个表格的符号规则，估计不少同窗仍是一脸懵逼。不啰嗦了，上干货

1、0和#的使用（最多见使用场景）

这是最经典、最多见的使用场景，甚至来讲你有可能职业生涯只会用到此场景。

/**
 * {@link DecimalFormat}
 */
@Test
public void test4() {
    double myNum = 1220.0455;

    System.out.println("===============0的使用===============");
    System.out.println("只保留整数部分：" + new DecimalFormat("0").format(myNum));
    System.out.println("保留3位小数：" + new DecimalFormat("0.000").format(myNum));
    System.out.println("整数部分、小数部分都5位。不够的都用0补位(整数高位部，小数低位补)：" + new DecimalFormat("00000.00000").format(myNum));

    System.out.println("===============#的使用===============");
    System.out.println("只保留整数部分：" + new DecimalFormat("#").format(myNum));
    System.out.println("保留2为小数并以百分比输出：" + new DecimalFormat("#.##%").format(myNum));

    // 非标准数字（不建议这么用）
    System.out.println("===============非标准数字的使用===============");
    System.out.println(new DecimalFormat("666").format(myNum));
    System.out.println(new DecimalFormat(".6666").format(myNum));
}

运行程序，输出：

===============0的使用===============
只保留整数部分：1220
保留3位小数：1220.045
整数部分、小数部分都5位。不够的都用0补位(整数高位部，小数低位补)：01220.04550
===============#的使用===============
只保留整数部分：1220
保留2为小数并以百分比输出：122004.55%
===============非标准数字的使用===============
661220
1220.666

经过此案例，大体可得出以下结论：

• 整数部分：
  • 0和#均可用于取出所有整数部分
  • 0的个数决定整数部分长度，不够高位补0；#则无此约束，N多个#是同样的效果
• 小数部分：
  • 可保留小数点后N位(0和#效果同样)
  • 若小数点后位数不够，若使用的0那就低位补0，若使用#就不补（该是几位就是几位）
• 数字(1-9)：并不建议模版里直接写1-9这样的数字，了解下便可

2、科学计数法E

若是你不是在证券/银行行业，这个大几率是用不着的（即便在，你估计也不会用它）。来几个例子感觉一把就成：

@Test
public void test5() {
    double myNum = 1220.0455;

    System.out.println(new DecimalFormat("0E0").format(myNum));
    System.out.println(new DecimalFormat("0E00").format(myNum));
    System.out.println(new DecimalFormat("00000E00000").format(myNum));
    System.out.println(new DecimalFormat("#E0").format(myNum));
    System.out.println(new DecimalFormat("#E00").format(myNum));
    System.out.println(new DecimalFormat("#####E00000").format(myNum));
}

运行程序，输出：

1E3
1E03
12200E-00001
.1E4
.1E04
1220E00000

3、分组分隔符,

分组分隔符比较经常使用，它就是咱们常看到的逗号,

@Test
public void test6() {
    double myNum = 1220.0455;

    System.out.println(new DecimalFormat(",###").format(myNum));
    System.out.println(new DecimalFormat(",##").format(myNum));
    System.out.println(new DecimalFormat(",##").format(123456789));

    // 分隔符,左边是无效的
    System.out.println(new DecimalFormat("###,##").format(myNum));
}

运行程序，输出：

1,220
12,20
1,23,45,67,89
12,20

4、百分号%

在展现层面也比较经常使用，用于把一个数字用%形式表示出来。

@Test
public void test42() {
    double myNum = 1220.0455;

    System.out.println("百分位表示：" + new DecimalFormat("#.##%").format(myNum));
    System.out.println("千分位表示：" + new DecimalFormat("#.##\u2030").format(myNum));
}

运行程序，输出：

百分位表示：122004.55%
千分位表示：1220045.5‰

5、本地货币符号¤

嗯，这个符号¤，键盘竟没法直接输出，得使用软键盘（建议使用copy大法）。

@Test
public void test7() {
    double myNum = 1220.0455;

    System.out.println(new DecimalFormat(",000.00¤").format(myNum));
    System.out.println(new DecimalFormat(",000.¤00").format(myNum));
    System.out.println(new DecimalFormat("¤,000.00").format(myNum));
    System.out.println(new DecimalFormat("¤,000.¤00").format(myNum));
    // 世界货币表达形式
    System.out.println(new DecimalFormat(",000.00¤¤").format(myNum));
}

运行程序，输出：

1,220.05￥
1,220.05￥
￥1,220.05
1,220.05￥￥
￥1,220.05￥
1,220.05CNY

注意最后一条结果：若是连续出现两次，表明货币符号的国际代号。

说明：结果默认都作了Locale本地化处理的，若你在其它国家就不会再是￥人名币符号喽

DecimalFormat就先介绍到这了，其实掌握了它就基本等于掌握了NumberFormat。接下来再简要看看它另一个“儿子”：ChoiceFormat。

ChoiceFormat

Choice：精选的，仔细推敲的。

这个格式化器很是有意思：至关于以数字为键，字符串为值的键值对。使用一组double类型的数组做为键，一组String类型的数组做为值，两数组相同（不必定必须是相同，见示例）索引值的元素做为一对。

@Test
public void test8() {
    double[] limits = {1, 2, 3, 4, 5, 6, 7};
    String[] formats = {"周一", "周二", "周三", "周四", "周五", "周六", "周天"};
    NumberFormat numberFormat = new ChoiceFormat(limits, formats);

    System.out.println(numberFormat.format(1));
    System.out.println(numberFormat.format(4.3));
    System.out.println(numberFormat.format(5.8));
    System.out.println(numberFormat.format(9.1));
    System.out.println(numberFormat.format(11));
}

运行程序，输出：

周一
周四
周五
周天
周天

结果解释：

1. 4.3位于4和5之间，取值4；5.8位于5和6之间，取值5
2. 9.1和11均超过了数组最大值（或者说找不到匹配的），则取值最后一对键值对。

可能你会想这有什么使用场景？？？是的，不得不认可它的使用场景较少，本文下面会介绍下它和MessageFormat的一个使用场景。

若是说DateFormat和NumberFormat都用没什么花样，主要记住它的pattern语法格式就成，那么就下来这个格式化器就是本文的主菜了，使用场景很是的普遍，它就是MessageFormat。

MessageFormat：字符串格式化

MessageFormat提供了一种与语言无关（无论你在中国仍是其它国家，效果同样）的方式生成拼接消息/拼接字符串的方法。使用它来构造显示给最终用户的消息。MessageFormat接受一组对象，对它们进行格式化，而后在模式的适当位置插入格式化的字符串。

先来个最简单的使用示例体验一把：

/**
 * {@link MessageFormat}
 */
@Test
public void test9() {
    String sourceStrPattern = "Hello {0},my name is {1}";
    Object[] args = new Object[]{"girl", "YourBatman"};

    String formatedStr = MessageFormat.format(sourceStrPattern, args);
    System.out.println(formatedStr);
}

运行程序，输出：

Hello girl,my name is YourBatman

有没有中似曾类似的感受，是否是和String.format()的做用特别像？是的，它俩的用法区别，到底使用税文下也会讨论。

要熟悉MessageFormat的使用，主要是要熟悉它的参数模式（你也能够理解为pattern）。

参数模式

MessageFormat采用{}来标记须要被替换/插入的部分，其中{}里面的参数结构具备必定模式：

ArgumentIndex[,FormatType[,FormatStyle]]

• ArgumentIndex：非必须。从0开始的索引值
• FormatType：非必须。使用不一样的java.text.Format实现类对入参进行格式化处理。它能有以下值：
  • number：调用NumberFormat进行格式化
  • date：调用DateFormat进行格式化
  • time：调用DateFormat进行格式化
  • choice：调用ChoiceFormat进行格式化
• FormatStyle：非必须。设置FormatType使用的样式。它能有以下值：
  • short、medium、long、full、integer、currency、percent、SubformPattern（如日期格式、数字格式#.##等）

说明：FormatType和FormatStyle只有在传入值为日期时间、数字、百分比等类型时才有可能须要设置，使用得并很少。毕竟：我在外部格式化好后再放进去不香吗？

@Test
public void test10() {
    MessageFormat messageFormat = new MessageFormat("Hello, my name is {0}. I’am {1,number,#.##} years old. Today is {2,date,yyyy-MM-dd HH:mm:ss}");
    // 亦可经过编程式 显示指定某个位置要使用的格式化器
    // messageFormat.setFormatByArgumentIndex(1, new DecimalFormat("#.###"));

    System.out.println(messageFormat.format(new Object[]{"YourBatman", 24.123456, new Date()}));
}

运行程序，输出：

Hello, my name is YourBatman. I’am 24.12 years old. Today is 2020-12-26 15:24:28

它既能够直接在模版里指定格式化模式类型，也能够经过API方法set指定格式化器，固然你也能够再外部格式化好后再放进去，三种方式都可，任君选择。

注意事项

下面基于此示例，对MessageFormat的使用注意事项做出几点强调。

@Test
public void test11() {
    System.out.println(MessageFormat.format("{1} - {1}", new Object[]{1})); // {1} - {1}
    System.out.println(MessageFormat.format("{0} - {1}", new Object[]{1})); // 输出：1 - {1}
    System.out.println(MessageFormat.format("{0} - {1}", new Object[]{1, 2, 3})); // 输出：1 - 2

    System.out.println("---------------------------------");

    System.out.println(MessageFormat.format("'{0} - {1}", new Object[]{1, 2})); // 输出：{0} - {1}
    System.out.println(MessageFormat.format("''{0} - {1}", new Object[]{1, 2})); // 输出：'1 - 2
    System.out.println(MessageFormat.format("'{0}' - {1}", new Object[]{1, 2})); // {0} - 2
    // 若你数据库值两边都须要''包起来，请你这么写
    System.out.println(MessageFormat.format("''{0}'' - {1}", new Object[]{1, 2})); // '1' - 2

    System.out.println("---------------------------------");
    System.out.println(MessageFormat.format("0} - {1}", new Object[]{1, 2})); // 0} - 2
    System.out.println(MessageFormat.format("{0 - {1}", new Object[]{1, 2})); // java.lang.IllegalArgumentException: Unmatched braces in the pattern.
}

1. 参数模式的索引值必须从0开始，不然全部索引值无效
2. 实际传入的参数个数能够和索引个数不匹配，不报错（能匹配上几个算几个）
3. 两个单引号''才算做一个'，若只写一个将被忽略甚至影响整个表达式
   1. 谨慎使用单引号'
   2. 关注'的匹配关系
4. {}只写左边报错，只写右边正常输出（注意参数的对应关系）

static方法的性能问题

咱们知道MessageFormat提供有一个static静态方法，很是方便的的使用：

public static String format(String pattern, Object ... arguments) {
    MessageFormat temp = new MessageFormat(pattern);
    return temp.format(arguments);
}

能够清晰看到，该静态方法本质上仍是构造了一个MessageFormat实例去作格式化的。所以：若你要屡次（如高并发场景）格式化同一个模版（参数可不同）的话，那么提早建立好一个全局的（非static） MessageFormat实例再执行格式化是最好的，而非一直调用其静态方法。

说明：若你的系统非高并发场景，此性能损耗基本无需考虑哈，怎么方便怎么来。毕竟朝生夕死的对象对JVM来讲没啥压力

和String.format选谁？

两者都能用于字符串拼接（格式化）上，撇开MessageFormat支持各类模式不说，咱们只须要考虑它俩的性能上差别。

• MeesageFormat：先分析（模版可提早分析，且能够只分析一次），再在指定位置上插入相应的值
  • 分析：遍历字符串，维护一个{}数组并记录位置
  • 填值
• String.format：该静态方法是采用运行时用正则表达式 匹配到占位符，而后执行替换的
  • 正则表达式为"%(\\d+\\$)?([-#+ 0,(\\<]*)?(\\d+)?(\\.\\d+)?([tT])?([a-zA-Z%])"
  • 根据正则匹配到占位符列表和位置，而后填值

一说到正则表达式，我内心就发触，由于它对性能是不友好的，因此孰优孰劣，高下立判。

说明：仍是那句话，没有绝对的谁好谁坏，若是你的系统对性能不敏感，那就是方便第一

经典使用场景

这个就不少啦，最多见的有：HTML拼接、SQL拼接、异常信息拼接等等。

好比下面这个SQL拼接：

StringBuilder sb =new StringBuilder();
sb.append("insert into user (");
sb.append("     name,");
sb.append("     accountId,");
sb.append("     zhName,");
sb.append("     enname,");
sb.append("     status");
sb.append(") values (");
sb.append("     ''{0}'',");
sb.append("     {1},");
sb.append("     ''{2}'',");
sb.append("     ''{3}'',");
sb.append("     {4},");
sb.append(")");

Object[] args = {name, accountId, zhName, enname, status};

// 最终SQL
String sql = MessageFormat.format(sb.toString(), arr);

你看，多工整。

说明：若是值是字符串须要'包起来，那么请使用两边各两个包起来

✍总结

本文内容介绍了JDK原生的格式化器知识点，主要做用在这三个方面：

• DateFormat：日期时间格式化
• NumberFormat：数字格式化
• MessageFormat：字符串格式化

Spring是直接面向使用者的框架产品，很显然这些是不够用的，而且JDK的格式化器在设计上存在一些弊端。好比常常被吐槽的：日期/时间类型格式化器SimpleDateFormat为毛在java.text包里，而它格式化的类型Date却在java.util包内，这实为不合适。

有了JDK格式化器做为基础，下篇咱们就能够浩浩荡荡的走进Spring格式化器的大门了，看看它是如何优于JDK进行设计和抽象的。

---

✔✔✔推荐阅读✔✔✔

【Spring类型转换】系列：

• 1. 揭秘Spring类型转换 - 框架设计的基石
• 2. Spring早期类型转换，基于PropertyEditor实现
• 3. 搞定收工，PropertyEditor就到这
• 4. 上新了Spring，全新一代类型转换机制
• 5. 穿过拥挤的人潮，Spring已为你制做好高级赛道
• 6. 抹平差别，统一类型转换服务ConversionService

【Jackson】系列：

• 1. 初识Jackson -- 世界上最好的JSON库
• 2. 妈呀，Jackson原来是这样写JSON的
• 3. 懂了这些，方敢在简历上说会用Jackson写JSON
• 4. JSON字符串是如何被解析的？JsonParser了解一下
• 5. JsonFactory工厂而已，还蛮有料，这是我没想到的
• 6. 二十不惑，ObjectMapper使用也再也不迷惑
• 7. Jackson用树模型处理JSON是必备技能，不信你看

【数据校验Bean Validation】系列：

• 1. 不吹不擂，第一篇就能提高你对Bean Validation数据校验的认知
• 2. Bean Validation声明式校验方法的参数、返回值
• 3. 站在使用层面，Bean Validation这些标准接口你须要烂熟于胸
• 4. Validator校验器的五大核心组件，一个都不能少
• 5. Bean Validation声明式验证四大级别：字段、属性、容器元素、类
• 6. 自定义容器类型元素验证，类级别验证（多字段联合验证）

【新特性】系列：

• Spring Cloud 2020.0.0正式发布，再见了Netflix
• IntelliJ IDEA 2020.3正式发布，年度最后一个版本很讲武德
• IntelliJ IDEA 2020.2正式发布，诸多亮点总有几款能助你提效
• [IntelliJ IDEA 2020.1正式发布，你要的Almost都在这！]()
• Spring Framework 5.3.0正式发布，在云原生路上继续发力
• Spring Boot 2.4.0正式发布，全新的配置文件加载机制（不向下兼容）
• Spring改变版本号命名规则：此举对非英语国家很友好
• JDK15正式发布，划时代的ZGC同时宣布转正

【程序人生】系列：

• 蚂蚁金服上市了，我不想努力了
• 若是程序员和产品经理都用凡尔赛文学对话......
• 程序人生 | 春风得意马蹄疾，一日看尽长安花

还有诸如【Spring配置类】【Spring-static关键字】【Spring数据绑定】【Spring Cloud Netflix】【Feign】【Ribbon】【Hystrix】...更多原创专栏，关注BAT的乌托邦回复专栏二字便可所有获取，也可加我fsx1056342982，交个朋友。

有些已完结，有些连载中。我是A哥(YourBatman)，我们下期见