你是否经常忘记 Java String 格式说明符？或者你从来都没有时间学习过。以下是您可以使用的各种标识符参考。

你是否尝试阅读并理解 java 的 String 格式化文档？我觉得很难理解。尽管这个文档提供了所有的信息，但是它的组织结构让人失望。

String 格式化

在 Java 中格式化字符串最常用的方法就是 String.format()，如果有一个 Java 版本的 printf，它会像下面这样：

String output = String.format("%s = %d", "joe", 35);

• 1

对于控制台中的格式化输出，可以使用 System.out 或 System.err 中的 printf() 或者 format()方法。

System.out.printf("My name is: %s%n", "joe");

• 1

创建一个 Formatter 并将其链接到 StringBuilder，通过format() 格式化输出的内容会追加到 StringBuilder 中。

StringBuilder sbuf = new StringBuilder();
Formatter fmt = new Formatter(sbuf);
fmt.format("PI = %f%n", Math.PI);
System.out.print(sbuf.toString());
// you can continue to append data to sbuf here.

• 1
• 2
• 3
• 4
• 5

格式说明符

以下是所有支持的转换说明符的快速参考。

日期和时间格式

注意：使用 “%T” 替换下面的 “%t” 可以将输出结果变成大写形式。

参数索引

参数索引是以 $ 结尾，在 % 后面的数字，用于指定在参数列表中的参数。参数索引从 1 开始。

String.format("%2$s", 32, "Hello"); // 输出："Hello"

• 1

格式化整数

使用%d格式说明符，您可以使用所有整数类型的参数，包括byte，short，int，long 和BigInteger。默认格式：

String.format("%d", 93); // 输出：93

• 1

指定宽度：

String.format("|%20d|", 93); // 输出：|                  93|

• 1

指定宽度内的左对齐：

String.format("|%-20d|", 93); // 输出：|93                  |

• 1

用零填充：

String.format("|%020d|", 93); // 输出：|00000000000000000093|

• 1

用”+”号打印正数（负数总是包含”-“）：

String.format("|%+20d|", 93);  // 输出：|                 +93|
String.format("|%+20d|", -93); // 输出：|                 -93|

• 1
• 2

正数之前的空格，按正常值计算负数的“-”。

String.format("|% d|", 93);  // 输出：| 93| 
String.format("|% d|", -36); // 输出：|-36|

• 1
• 2

使用和区域相关的千位分隔符，美国的是“,”：

String.format("|%,d|", 10000000); // 输出：|10,000,000|

• 1

中国的也一样：

String.format(Locale.CHINA, "|%,d|", 10000000)// 输出：|10,000,000|

• 1

使用左边括号括起来可以跳过“-”。

String.format("|%(d|", -36); // 输出：|(36)|

• 1

八进制输出。

String.format("|%o|"), 93); // 输出：135

• 1

十六进制输出。

String.format("|%x|", 93); // 输出：5d

• 1

八进制和十六进制输出的替代表示。

带前导0的八进制和带前导”0x“的十六进制输出：

String.format("|%#o|", 93); // 输出：0135
String.format("|%#x|", 93); // 输出：0x5d
String.format("|%#X|", 93); // 输出：0X5D

• 1
• 2
• 3

字符串和字符转换

默认格式。

打印整个字符串。

String.format("|%s|", "Hello World"); // 输出："Hello World"

• 1

指定字段长度。

String.format("|%20s|", "Hello World"); // 输出：|         Hello World|

• 1

左对齐文本。

String.format("|%-20s|", "Hello World"); // 输出：|Hello World         |

• 1

指定最大字符数。

String.format("|%.5s|", "Hello World"); // 输出：|Hello|

• 1

指定宽度和最大字符数。

String.format("|%20.5s|", "Hello World"); // 输出：|               Hello|

• 1

日期格式化

由于原文示例不涉及日期的例子，所以这一节是我个人增加的。

所有日期，除了纯数字显示的内容和区域无关外，文字显示的都和区域相关（下面示例的区域为中国）。

最简单的星期几。

String.format(Locale.US, "%tA", new Date()); // 输出：Sunday
String.format("%tA", new Date());            // 输出：星期日

• 1
• 2

“％tc “相当于 “%ta %tb %td %tT %tZ %tY ”，而且不需要自己指定索引。

String.format("%tc", new Date()); // 输出：星期日 四月 16 08:21:59 CST 2017

• 1

如果想要通过具体标识手动指定成上面的效果，需要增加索引。

String.format("%1$ta %1$tb %1$td %1$tT %1$tZ %1$tY", new Date());
// 输出：星期日 四月 16 08:24:06 CST 2017

• 1
• 2

常见的 “yyyy-MM-dd HH:mm:ss” 格式。

String.format("%1$tY-%1$tm-%1$td %1$tT", new Date());
// 输出：2017-04-16 08:31:16

• 1
• 2

总结

本篇教程解释了 Java 中的 String 格式化。我们涵盖了支持的格式说明符。数字和字符串格式都支持各种可代替的标识。

import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class StringFormatUtil {

    private static final Pattern pattern = Pattern.compile("\\{(.*?)\\}");
    private static Matcher matcher;

    /**
     * 格式化字符串 字符串中使用{key}表示占位符
     *
     * @param sourStr
     *            需要匹配的字符串
     * @param param
     *            参数集
     * @return
     */
    public static String stringFormat(String sourStr, Map<String, Object> param) {
        String tagerStr = sourStr;
        if (param == null)
            return tagerStr;
        try {
            matcher = pattern.matcher(tagerStr);
            while (matcher.find()) {
                String key = matcher.group();
                String keyclone = key.substring(1, key.length() - 1).trim();
                Object value = param.get(keyclone);
                if (value != null)
                    tagerStr = tagerStr.replace(key, value.toString());
            }
        }catch (Exception e){
            return null;
        }
        return tagerStr;
    }

    /**
     * 格式化字符串 字符串中使用{key}表示占位符 利用反射 自动获取对象属性值 (必须有get方法)
     *
     * @param sourStr 需要匹配的字符串
     *
     * @return
     */
    public static String stringFormat(String sourStr, Object obj) {
        String tagerStr = sourStr;
        matcher = pattern.matcher(tagerStr);
        if (obj == null)
            return tagerStr;

        PropertyDescriptor pd;
        Method getMethod;
        // 匹配{}中间的内容 包括括号
        while (matcher.find()) {
            String key = matcher.group();
            String keyclone = key.substring(1, key.length() - 1).trim();
            try {
                pd = new PropertyDescriptor(keyclone, obj.getClass());
                getMethod = pd.getReadMethod();// 获得get方法
                Object value = getMethod.invoke(obj);
                if (value != null)
                    tagerStr = tagerStr.replace(key, value.toString());
            } catch (Exception e) {
                // TODO Auto-generated catch block
                // Loggers.addException(e);
            }
        }
        return tagerStr;
    }

    /**
     * 格式化字符串 (替换所有) 字符串中使用{key}表示占位符
     *
     * @param sourStr
     *            需要匹配的字符串
     * @param param
     *            参数集
     * @return
     */
    public static String stringFormatAll(String sourStr, Map<String, Object> param) {
        String tagerStr = sourStr;
        if (param == null)
            return tagerStr;
        try {
            matcher = pattern.matcher(tagerStr);
            while (matcher.find()) {
                String key = matcher.group();
                String keyclone = key.substring(1, key.length() - 1).trim();
                Object value = param.get(keyclone);
                if (value != null)
                    tagerStr = tagerStr.replace(key, value.toString());
            }
        }catch (Exception e){
            return null;
        }
        return tagerStr;
    }

    /**
     * 格式花字符串，按照占位符名字
     * 输入：sourStr = xxxxx{a}xxxx{b}  ,param = {a:A,b:B}
     * 输出：targetStr = xxxxAxxxxB
     * @param sourStr
     * @param param
     * @return
     */
    public static String stringFormat(String sourStr, JSONObject param) {
        String tagerStr = sourStr;
        if (param == null)
            return tagerStr;
        try {
            matcher = pattern.matcher(tagerStr);
            while (matcher.find()) {
                String key = matcher.group();
                String keyclone = key.substring(1, key.length() - 1).trim();
                Object value = param.get(keyclone);
                if (value != null)
                    tagerStr = tagerStr.replace(key, value.toString());
            }
        }catch (Exception e){
            return null;
        }
        return tagerStr;
    }

    public static void main(String[] args) {
//        Map<String,Object> map = new HashMap<>();
//        map.put("id","111");
//        map.put("sss","ss");
//        JSONObject json = new JSONObject();
//        json.put("id","212");
//        json.put("fff","xxxx");
//        json.put("emmmmm",11);
//        stringFormat("sisas&{fff}_diwahwi%{id}{jio}",json);
    }
}

引言

一、String.format()介绍

String.format()字符串常规类型格式化的两种重载方式：

// 使用本地语言环境，制定字符串格式和参数生成格式化的新字符串
String str = String.format(String format, Object… args);

// 使用指定的语言环境，制定字符串格式和参数生成格式化的字符串
String str = String.format(Locale locale, String format, Object… args);

常用的类型

二、举例说明

代码如下（示例）：
字符串格式化，常用于拼接URL

    public static void main(String[] args) {
        String str = "";
        str=String.format("hallo World,%s", "你好，世界");
        System.out.println(str);
        str=String.format("Hi,%s,%s,%s", "小张","小王","小赵");
        System.out.println(str);
        System.out.printf("字母a的大写是：%c %n", 'A');
        System.out.printf("3>7的结果是：%b %n", 3>7);
        System.out.printf("100的一半是：%d %n", 100/2);
        System.out.printf("100的16进制数是：%x %n", 100);
        System.out.printf("100的8进制数是：%o %n", 100);
        System.out.printf("50元的书打8.5折扣是：%f 元%n", 50*0.85);
        System.out.printf("上面价格的16进制数是：%a %n", 50*0.85);
        System.out.printf("上面价格的指数表示：%e %n", 50*0.85);
        System.out.printf("上面价格的指数和浮点数结果的长度较短的是：%g %n", 50*0.85);
        System.out.printf("上面的折扣是%d%% %n", 85);
        System.out.printf("字母A的散列码是：%h %n", 'A');
    }

输出结果：

hallo World,你好，世界
Hi,小张,小王,小赵
字母a的大写是：A 
3>7的结果是：false 
100的一半是：50 
100的16进制数是：64 
100的8进制数是：144 
50元的书打8.5折扣是：42.500000 元
上面价格的16进制数是：0x1.54p5 
上面价格的指数表示：4.250000e+01 
上面价格的指数和浮点数结果的长度较短的是：42.5000 
上面的折扣是85% 
字母A的散列码是：41 

搭配转换符的标志

代码如下（示例）：

	public static void main(String[] args) {
	    String str=null;
	    //$使用
	    str=String.format("格式参数$的使用：%1$d,%2$s", 99,"abc");           
	    System.out.println(str);                     
	    //+使用
	    System.out.printf("显示正负数的符号：%+d与%d%n", 99,-99);
	    //补O使用
	    System.out.printf("最牛的编号是：%03d%n", 7);
	    //空格使用
	    System.out.printf("Tab键的效果是：% 8d%n", 7);
	    //.使用
	    System.out.printf("整数分组的效果是：%,d%n", 9989997);
	    //空格和小数点后面个数
	    System.out.printf("一本书的价格是：% 50.5f元%n", 49.8);
	}

输出结果：

格式参数$的使用：99,abc
显示正负数的符号：+99与-99
最牛的编号是：007
Tab键的效果是：       7
整数分组的效果是：9,989,997
一本书的价格是：                                          49.80000元

日期和事件字符串格式化

在程序界面中经常需要显示时间和日期，但是其显示的 格式经常不尽人意，需要编写大量的代码经过各种算法才得到理想的日期与时间格式。字符串格式中还有%tx转换符没有详细介绍，它是专门用来格式化日期和时 间的。%tx转换符中的x代表另外的处理日期和时间格式的转换符，它们的组合能够将日期和时间格式化成多种格式。

常见日期和时间组合的格式，如图所示

代码如下（示例）：

		public static void main(String[] args) {
		    Date date=new Date();                                
		    //c的使用
		    System.out.printf("全部日期和时间信息：%tc%n",date);        
		    //f的使用
		    System.out.printf("年-月-日格式：%tF%n",date);
		    //d的使用
		    System.out.printf("月/日/年格式：%tD%n",date);
		    //r的使用
		    System.out.printf("HH:MM:SS PM格式（12时制）：%tr%n",date);
		    //t的使用
		    System.out.printf("HH:MM:SS格式（24时制）：%tT%n",date);
		    //R的使用
		    System.out.printf("HH:MM格式（24时制）：%tR",date);
		}

输出结果：

全部日期和时间信息：星期一 九月 10 10:43:36 CST 2012
年-月-日格式：2012-09-10
月/日/年格式：09/10/12
HH:MM:SS PM格式（12时制）：10:43:36 上午
HH:MM:SS格式（24时制）：10:43:36
HH:MM格式（24时制）：10:43

定义日期格式的转换符可以使日期通过指定的转换符生成新字符串。这些日期转换符如图所示

		public static void main(String[] args) {
		    Date date=new Date();                                    
		    //b的使用，月份简称
		    String str=String.format(Locale.US,"英文月份简称：%tb",date);     
		    System.out.println(str);                                                                            
		    System.out.printf("本地月份简称：%tb%n",date);
		    //B的使用，月份全称
		    str=String.format(Locale.US,"英文月份全称：%tB",date);
		    System.out.println(str);
		    System.out.printf("本地月份全称：%tB%n",date);
		    //a的使用，星期简称
		    str=String.format(Locale.US,"英文星期的简称：%ta",date);
		    System.out.println(str);
		    //A的使用，星期全称
		    System.out.printf("本地星期的简称：%tA%n",date);
		    //C的使用，年前两位
		    System.out.printf("年的前两位数字（不足两位前面补0）：%tC%n",date);
		    //y的使用，年后两位
		    System.out.printf("年的后两位数字（不足两位前面补0）：%ty%n",date);
		    //j的使用，一年的天数
		    System.out.printf("一年中的天数（即年的第几天）：%tj%n",date);
		    //m的使用，月份
		    System.out.printf("两位数字的月份（不足两位前面补0）：%tm%n",date);
		    //d的使用，日（二位，不够补零）
		    System.out.printf("两位数字的日（不足两位前面补0）：%td%n",date);
		    //e的使用，日（一位不补零）
		    System.out.printf("月份的日（前面不补0）：%te",date);
		}

输出结果：

英文月份简称：Sep
本地月份简称：九月
英文月份全称：September
本地月份全称：九月
英文星期的简称：Mon
本地星期的简称：星期一
年的前两位数字（不足两位前面补0）：20
年的后两位数字（不足两位前面补0）：12
一年中的天数（即年的第几天）：254
两位数字的月份（不足两位前面补0）：09
两位数字的日（不足两位前面补0）：10
月份的日（前面不补0）：10

和日期格式转换符相比，时间格式的转换符要更多、更精确。它可以将时间格式化成时、分、秒甚至时毫秒等单位。格式化时间字符串的转换符如图所示

	public static void main(String[] args) {
		Date date = new Date();
		//H的使用
		System.out.printf("2位数字24时制的小时（不足2位前面补0）:%tH%n", date);
		//I的使用
		System.out.printf("2位数字12时制的小时（不足2位前面补0）:%tI%n", date);
		//k的使用
		System.out.printf("2位数字24时制的小时（前面不补0）:%tk%n", date);
		//l的使用
		System.out.printf("2位数字12时制的小时（前面不补0）:%tl%n", date);
		//M的使用
		System.out.printf("2位数字的分钟（不足2位前面补0）:%tM%n", date);
		//S的使用
		System.out.printf("2位数字的秒（不足2位前面补0）:%tS%n", date);
		//L的使用
		System.out.printf("3位数字的毫秒（不足3位前面补0）:%tL%n", date);
		//N的使用
		System.out.printf("9位数字的毫秒数（不足9位前面补0）:%tN%n", date);
		//p的使用
		String str = String.format(Locale.US, "小写字母的上午或下午标记(英)：%tp", date);
		System.out.println(str); 
		System.out.printf("小写字母的上午或下午标记（中）：%tp%n", date);
		//z的使用
		System.out.printf("相对于GMT的RFC822时区的偏移量:%tz%n", date);
		//Z的使用
		System.out.printf("时区缩写字符串:%tZ%n", date);
		//s的使用
		System.out.printf("1970-1-1 00:00:00 到现在所经过的秒数：%ts%n", date);
		//Q的使用
		System.out.printf("1970-1-1 00:00:00 到现在所经过的毫秒数：%tQ%n", date);
	}

输出结果：

2位数字24时制的小时（不足2位前面补0）:11
2位数字12时制的小时（不足2位前面补0）:11
2位数字24时制的小时（前面不补0）:11
2位数字12时制的小时（前面不补0）:11
2位数字的分钟（不足2位前面补0）:03
2位数字的秒（不足2位前面补0）:52
3位数字的毫秒（不足3位前面补0）:773
9位数字的毫秒数（不足9位前面补0）:773000000
小写字母的上午或下午标记(英)：am
小写字母的上午或下午标记（中）：上午
相对于GMT的RFC822时区的偏移量:+0800
时区缩写字符串:CST
1970-1-1 00:00:00 到现在所经过的秒数：1347246232
1970-1-1 00:00:00 到现在所经过的毫秒数：1347246232773

原文传送带：https://blog.csdn.net/lonely_fireworks/article/details/7962171/