String與MessageFormat的說明

一、兩者的使用場景

String.format：for layout justification and alignment, common formats for numeric, string, and date/time data, and locale-specific output.

MessageFormat.format：to produce concatenated messages in language-neutral way.

二、兩者的性能比較

MeesageFormat由於是一個在先分析的指定位置插入相應的值，性能要好於采用正則表達式查找占位符的String.format方法。MessageFormat > String

三、以下是異常的情況

String message = MessageFormat.format("name={0}, age={}", 25, "huhx"); // java.lang.IllegalArgumentException: can't parse argument number: 
String string = String.format("name=%s, age=%d", "huhx");              // java.util.MissingFormatArgumentException: Format specifier '%d'

兩者的實現原理

我們通過下面的簡單的例子來分析兩者的原理：

public void messageFormat() {
    String string = String.format("name=%s, age=%d", "huhx", 25);
    String message = MessageFormat.format("name={1}, age={0}, {1}", 25, "huhx");
    System.out.println(string);
    System.out.println(message);
  }
// name=huhx, age=25
// name=huhx, age=25, huhx

一、String.format的實現原理

String.format內部的實現是一個Formatter，使用了正則表達式來查找占位數據的。我們在這里貼出它實現的源代碼。

 1 public Formatter format(Locale l, String format, Object ... args) {
 2     ensureOpen();
 3     // index of last argument referenced
 4     int last = -1;
 5     // last ordinary index
 6     int lasto = -1;
 7 
 8     FormatString[] fsa = parse(format);
 9     for (int i = 0; i < fsa.length; i++) {
10         FormatString fs = fsa[i];
11         int index = fs.index();
12         try {
13             switch (index) {
14             case -2:  // fixed string, "%n", or "%%"
15                 fs.print(null, l);
16                 break;
17             case -1:  // relative index
18                 if (last < 0 || (args != null && last > args.length - 1))
19                     throw new MissingFormatArgumentException(fs.toString());
20                 fs.print((args == null ? null : args[last]), l);
21                 break;
22             case 0:  // ordinary index
23                 lasto++;
24                 last = lasto;
25                 if (args != null && lasto > args.length - 1)
26                     throw new MissingFormatArgumentException(fs.toString());
27                 fs.print((args == null ? null : args[lasto]), l);
28                 break;
29             default:  // explicit index
30                 last = index - 1;
31                 if (args != null && last > args.length - 1)
32                     throw new MissingFormatArgumentException(fs.toString());
33                 fs.print((args == null ? null : args[last]), l);
34                 break;
35             }
36         } catch (IOException x) {
37             lastException = x;
38         }
39     }
40     return this;
41 }

以下是Formatter內部的正則表達式：

private static final String formatSpecifier = "%(\\d+\\$)?([-#+ 0,(\\<]*)?(\\d+)?(\\.\\d+)?([tT])?([a-zA-Z%])";

使用formatSpecifier的正則表達式應用於name=%s, age=%d，會生成一個列表，也就是上述第9行代碼的執行結果。里面大概記錄了以下的內容，大小為4。

1、類型為FixedString，內容為name=
2、類型為FormatSpecifier，內容為%s
3、類型為FixedString，內容為, age=
4、類型為FormatSpecifier，內容為%d

這里對FixedString和FormatSpecifier做一個簡單的說明。兩者都是實現了FormatString接口。其中FormatString暴露了以下的三個方法。

private interface FormatString {
    int index();
    void print(Object arg, Locale l) throws IOException;
    String toString();
}

如果是FixedString類型的，index為-2。如果是FormatSpecifier類型的，index為0。

1、類型為FixedString：使用的fs.print函數是把string內容寫到Formatter類里面StringBuilder里。
2、類型為FormatSpecifier：使用fs.print里面的實現比較復雜，處理各種精度、對齊、布局調整等問題。

最后調用Formatter的toString方法，返回內容維護的StringBuilder內容。

public String toString() {
    ensureOpen();
    return a.toString();
}

二、MessageFormat.format的實現原理

MessageFormat的原理簡單來說就是遍歷第一個字符，維護一個{}數組，並且記錄了{}的各個位置，各個位置還對應着index(參數的下標)。還是以下面的代碼做分析

String message = MessageFormat.format("name={1}, age={0}, {1}", 25, "huhx");

首先它會調用一個applyPattern方法，這里我們先貼出代碼。這一行代碼執行完，會生成以下有用的信息。

其中offset是一個int數據，里面目前的數據是5，11，13分別代表{0}、{1}和{1}的位置。maxOffset為2代表上面的{n}有3個。argumentNumbers里面的1、0、1代表regex里面的{n}的n的值。這個過程具體可以看下面的代碼。

1 public void applyPattern(String pattern) {
 2     StringBuilder[] segments = new StringBuilder[4];
 3     // Allocate only segments[SEG_RAW] here. The rest are
 4     // allocated on demand.
 5     segments[SEG_RAW] = new StringBuilder();
 6 
 7     int part = SEG_RAW;
 8     int formatNumber = 0;
 9     boolean inQuote = false;
10     int braceStack = 0;
11     maxOffset = -1;
12     for (int i = 0; i < pattern.length(); ++i) {
13         char ch = pattern.charAt(i);
14         if (part == SEG_RAW) {
15             if (ch == '\'') {
16                 if (i + 1 < pattern.length()
17                     && pattern.charAt(i+1) == '\'') {
18                     segments[part].append(ch);  // handle doubles
19                     ++i;
20                 } else {
21                     inQuote = !inQuote;
22                 }
23             } else if (ch == '{' && !inQuote) {
24                 part = SEG_INDEX;
25                 if (segments[SEG_INDEX] == null) {
26                     segments[SEG_INDEX] = new StringBuilder();
27                 }
28             } else {
29                 segments[part].append(ch);
30             }
31         } else  {
32             if (inQuote) {              // just copy quotes in parts
33                 segments[part].append(ch);
34                 if (ch == '\'') {
35                     inQuote = false;
36                 }
37             } else {
38                 switch (ch) {
39                 case ',':
40                     if (part < SEG_MODIFIER) {
41                         if (segments[++part] == null) {
42                             segments[part] = new StringBuilder();
43                         }
44                     } else {
45                         segments[part].append(ch);
46                     }
47                     break;
48                 case '{':
49                     ++braceStack;
50                     segments[part].append(ch);
51                     break;
52                 case '}':
53                     if (braceStack == 0) {
54                         part = SEG_RAW;
55                         makeFormat(i, formatNumber, segments);
56                         formatNumber++;
57                         // throw away other segments
58                         segments[SEG_INDEX] = null;
59                         segments[SEG_TYPE] = null;
60                         segments[SEG_MODIFIER] = null;
61                     } else {
62                         --braceStack;
63                         segments[part].append(ch);
64                     }
65                     break;
66                 case ' ':
67                     // Skip any leading space chars for SEG_TYPE.
68                     if (part != SEG_TYPE || segments[SEG_TYPE].length() > 0) {
69                         segments[part].append(ch);
70                     }
71                     break;
72                 case '\'':
73                     inQuote = true;
74                     // fall through, so we keep quotes in other parts
75                 default:
76                     segments[part].append(ch);
77                     break;
78                 }
79             }
80         }
81     }
82     if (braceStack == 0 && part != 0) {
83         maxOffset = -1;
84         throw new IllegalArgumentException("Unmatched braces in the pattern.");
85     }
86     this.pattern = segments[0].toString();
87 }

View Code

后面做format工作，根據上述applyPattern分析出來的重要信息。大概的過程就是循環maxOffset，得到對應的offset下標。然后把參數插入到對應的位置。比如第一個的參數數字25會插入到pattern的第12位置，而huhx字符串會插入到pattern的第6和第14的位置。組裝的一個string返回。以下是format的源碼。

  1 private StringBuffer subformat(Object[] arguments, StringBuffer result,
  2                                FieldPosition fp, List<AttributedCharacterIterator> characterIterators) {
  3     // note: this implementation assumes a fast substring & index.
  4     // if this is not true, would be better to append chars one by one.
  5     int lastOffset = 0;
  6     int last = result.length();
  7     for (int i = 0; i <= maxOffset; ++i) {
  8         result.append(pattern.substring(lastOffset, offsets[i]));
  9         lastOffset = offsets[i];
 10         int argumentNumber = argumentNumbers[i];
 11         if (arguments == null || argumentNumber >= arguments.length) {
 12             result.append('{').append(argumentNumber).append('}');
 13             continue;
 14         }
 15         // int argRecursion = ((recursionProtection >> (argumentNumber*2)) & 0x3);
 16         if (false) { // if (argRecursion == 3){
 17             // prevent loop!!!
 18             result.append('\uFFFD');
 19         } else {
 20             Object obj = arguments[argumentNumber];
 21             String arg = null;
 22             Format subFormatter = null;
 23             if (obj == null) {
 24                 arg = "null";
 25             } else if (formats[i] != null) {
 26                 subFormatter = formats[i];
 27                 if (subFormatter instanceof ChoiceFormat) {
 28                     arg = formats[i].format(obj);
 29                     if (arg.indexOf('{') >= 0) {
 30                         subFormatter = new MessageFormat(arg, locale);
 31                         obj = arguments;
 32                         arg = null;
 33                     }
 34                 }
 35             } else if (obj instanceof Number) {
 36                 // format number if can
 37                 subFormatter = NumberFormat.getInstance(locale);
 38             } else if (obj instanceof Date) {
 39                 // format a Date if can
 40                 subFormatter = DateFormat.getDateTimeInstance(
 41                          DateFormat.SHORT, DateFormat.SHORT, locale);//fix
 42             } else if (obj instanceof String) {
 43                 arg = (String) obj;
 44 
 45             } else {
 46                 arg = obj.toString();
 47                 if (arg == null) arg = "null";
 48             }
 49 
 50             // At this point we are in two states, either subFormatter
 51             // is non-null indicating we should format obj using it,
 52             // or arg is non-null and we should use it as the value.
 53 
 54             if (characterIterators != null) {
 55                 // If characterIterators is non-null, it indicates we need
 56                 // to get the CharacterIterator from the child formatter.
 57                 if (last != result.length()) {
 58                     characterIterators.add(
 59                         createAttributedCharacterIterator(result.substring
 60                                                           (last)));
 61                     last = result.length();
 62                 }
 63                 if (subFormatter != null) {
 64                     AttributedCharacterIterator subIterator =
 65                                subFormatter.formatToCharacterIterator(obj);
 66 
 67                     append(result, subIterator);
 68                     if (last != result.length()) {
 69                         characterIterators.add(
 70                                      createAttributedCharacterIterator(
 71                                      subIterator, Field.ARGUMENT,
 72                                      Integer.valueOf(argumentNumber)));
 73                         last = result.length();
 74                     }
 75                     arg = null;
 76                 }
 77                 if (arg != null && arg.length() > 0) {
 78                     result.append(arg);
 79                     characterIterators.add(
 80                              createAttributedCharacterIterator(
 81                              arg, Field.ARGUMENT,
 82                              Integer.valueOf(argumentNumber)));
 83                     last = result.length();
 84                 }
 85             }
 86             else {
 87                 if (subFormatter != null) {
 88                     arg = subFormatter.format(obj);
 89                 }
 90                 last = result.length();
 91                 result.append(arg);
 92                 if (i == 0 && fp != null && Field.ARGUMENT.equals(
 93                               fp.getFieldAttribute())) {
 94                     fp.setBeginIndex(last);
 95                     fp.setEndIndex(result.length());
 96                 }
 97                 last = result.length();
 98             }
 99         }
100     }
101     result.append(pattern.substring(lastOffset, pattern.length()));
102     if (characterIterators != null && last != result.length()) {
103         characterIterators.add(createAttributedCharacterIterator(
104                                result.substring(last)));
105     }
106     return result;
107 }

View Code

友情鏈接

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 Java中利用MessageFormat對象實現類似C# string.Format方法格式化 JAVA String.format 方法使用再探Java基礎——String.format(String format, Object… args)的使用 java基礎——String的常用方法在Java程序中做字符串拼接時一定要記得的MessageFormat.format JAVA String.format()的使用 String.format(String format, Object... args)方法詳解 C# String.Format方法 java的輸出寬度（String.format的用法） java中的String.format使用