java基础---->String和MessageFormat的format方法

　　这里介绍一下String和MessageFormat中的format方法的差异以及实现原理。

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={}", , "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", );
    String message = MessageFormat.format("name={1}, age={0}, {1}", , "huhx");
    System.out.println(string);
    System.out.println(message);
  }
// name=huhx, age=25
// name=huhx, age=25, huhx

一、String.format的实现原理

String.format内部的实现是一个Formatter，使用了正则表达式来查找占位数据的。我们在这里贴出它实现的源代码。

 public Formatter format(Locale l, String format, Object ... args) {
     ensureOpen();
     // index of last argument referenced
     int last = -1;
     // last ordinary index
     int lasto = -1;

     FormatString[] fsa = parse(format);
     for (int i = 0; i < fsa.length; i++) {
         FormatString fs = fsa[i];
         int index = fs.index();
         try {
             switch (index) {
             case -2:  // fixed string, "%n", or "%%"
                 fs.print(null, l);
                 break;
             case -1:  // relative index
                 if (last < 0 || (args != null && last > args.length - 1))
                     throw new MissingFormatArgumentException(fs.toString());
                 fs.print((args == null ? null : args[last]), l);
                 break;
             case 0:  // ordinary index
                 lasto++;
                 last = lasto;
                 if (args != null && lasto > args.length - 1)
                     throw new MissingFormatArgumentException(fs.toString());
                 fs.print((args == null ? null : args[lasto]), l);
                 break;
             default:  // explicit index
                 last = index - 1;
                 if (args != null && last > args.length - 1)
                     throw new MissingFormatArgumentException(fs.toString());
                 fs.print((args == null ? null : args[last]), l);
                 break;
             }
         } catch (IOException x) {
             lastException = x;
         }
     }
     return this;
 }

以下是Formatter内部的正则表达式：

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

使用formatSpecifier的正则表达式应用于name=%s, age=%d，会生成一个列表，也就是上述第9行代码的执行结果。里面大概记录了以下的内容，大小为4。

、类型为FixedString，内容为name=
、类型为FormatSpecifier，内容为%s
、类型为FixedString，内容为, age=
、类型为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。

、类型为FixedString：使用的fs.print函数是把string内容写到Formatter类里面StringBuilder里。
、类型为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}", , "huhx");

首先它会调用一个applyPattern方法，这里我们先贴出代码。这一行代码执行完，会生成以下有用的信息。

其中offset是一个int数据，里面目前的数据是5，11，13分别代表{0}、{1}和{1}的位置。maxOffset为2代表上面的{n}有3个。argumentNumbers里面的1、0、1代表regex里面的{n}的n的值。这个过程具体可以看下面的代码。

 public void applyPattern(String pattern) {
      StringBuilder[] segments = new StringBuilder[];
      // Allocate only segments[SEG_RAW] here. The rest are
      // allocated on demand.
      segments[SEG_RAW] = new StringBuilder();

      int part = SEG_RAW;
      int formatNumber = ;
      boolean inQuote = false;
     int braceStack = ;
     maxOffset = -;
     for (int i = ; i < pattern.length(); ++i) {
         char ch = pattern.charAt(i);
         if (part == SEG_RAW) {
             if (ch == '\'') {
                 if (i +  < pattern.length()
                     && pattern.charAt(i+) == '\'') {
                     segments[part].append(ch);  // handle doubles
                     ++i;
                 } else {
                     inQuote = !inQuote;
                 }
             } else if (ch == '{' && !inQuote) {
                 part = SEG_INDEX;
                 if (segments[SEG_INDEX] == null) {
                     segments[SEG_INDEX] = new StringBuilder();
                 }
             } else {
                 segments[part].append(ch);
             }
         } else  {
             if (inQuote) {              // just copy quotes in parts
                 segments[part].append(ch);
                 if (ch == '\'') {
                     inQuote = false;
                 }
             } else {
                 switch (ch) {
                 case ',':
                     if (part < SEG_MODIFIER) {
                         if (segments[++part] == null) {
                             segments[part] = new StringBuilder();
                         }
                     } else {
                         segments[part].append(ch);
                     }
                     break;
                 case '{':
                     ++braceStack;
                     segments[part].append(ch);
                     break;
                 case '}':
                     if (braceStack == ) {
                         part = SEG_RAW;
                         makeFormat(i, formatNumber, segments);
                         formatNumber++;
                         // throw away other segments
                         segments[SEG_INDEX] = null;
                         segments[SEG_TYPE] = null;
                         segments[SEG_MODIFIER] = null;
                     } else {
                         --braceStack;
                         segments[part].append(ch);
                     }
                     break;
                 case ' ':
                     // Skip any leading space chars for SEG_TYPE.
                     if (part != SEG_TYPE || segments[SEG_TYPE].length() > ) {
                         segments[part].append(ch);
                     }
                     break;
                 case '\'':
                     inQuote = true;
                     // fall through, so we keep quotes in other parts
                 default:
                     segments[part].append(ch);
                     break;
                 }
             }
         }
     }
     if (braceStack ==  && part != ) {
         maxOffset = -;
         throw new IllegalArgumentException("Unmatched braces in the pattern.");
     }
     this.pattern = segments[].toString();
 }

后面做format工作，根据上述applyPattern分析出来的重要信息。大概的过程就是循环maxOffset，得到对应的offset下标。然后把参数插入到对应的位置。比如第一个的参数数字25会插入到pattern的第12位置，而huhx字符串会插入到pattern的第6和第14的位置。组装的一个string返回。以下是format的源码。

 private StringBuffer subformat(Object[] arguments, StringBuffer result,
                                FieldPosition fp, List<AttributedCharacterIterator> characterIterators) {
     // note: this implementation assumes a fast substring & index.
     // if this is not true, would be better to append chars one by one.
     int lastOffset = ;
     int last = result.length();
     for (int i = ; i <= maxOffset; ++i) {
         result.append(pattern.substring(lastOffset, offsets[i]));
         lastOffset = offsets[i];
         int argumentNumber = argumentNumbers[i];
         if (arguments == null || argumentNumber >= arguments.length) {
             result.append('{').append(argumentNumber).append('}');
             continue;
         }
         // int argRecursion = ((recursionProtection >> (argumentNumber*2)) & 0x3);
         if (false) { // if (argRecursion == 3){
             // prevent loop!!!
             result.append('\uFFFD');
         } else {
             Object obj = arguments[argumentNumber];
             String arg = null;
             Format subFormatter = null;
             if (obj == null) {
                 arg = "null";
             } else if (formats[i] != null) {
                 subFormatter = formats[i];
                 if (subFormatter instanceof ChoiceFormat) {
                     arg = formats[i].format(obj);
                     if (arg.indexOf('{') >= ) {
                         subFormatter = new MessageFormat(arg, locale);
                         obj = arguments;
                         arg = null;
                     }
                 }
             } else if (obj instanceof Number) {
                 // format number if can
                 subFormatter = NumberFormat.getInstance(locale);
             } else if (obj instanceof Date) {
                 // format a Date if can
                 subFormatter = DateFormat.getDateTimeInstance(
                          DateFormat.SHORT, DateFormat.SHORT, locale);//fix
             } else if (obj instanceof String) {
                 arg = (String) obj;

             } else {
                 arg = obj.toString();
                 if (arg == null) arg = "null";
             }

             // At this point we are in two states, either subFormatter
             // is non-null indicating we should format obj using it,
             // or arg is non-null and we should use it as the value.

             if (characterIterators != null) {
                 // If characterIterators is non-null, it indicates we need
                 // to get the CharacterIterator from the child formatter.
                 if (last != result.length()) {
                     characterIterators.add(
                         createAttributedCharacterIterator(result.substring
                                                           (last)));
                     last = result.length();
                 }
                 if (subFormatter != null) {
                     AttributedCharacterIterator subIterator =
                                subFormatter.formatToCharacterIterator(obj);

                     append(result, subIterator);
                     if (last != result.length()) {
                         characterIterators.add(
                                      createAttributedCharacterIterator(
                                      subIterator, Field.ARGUMENT,
                                      Integer.valueOf(argumentNumber)));
                         last = result.length();
                     }
                     arg = null;
                 }
                 if (arg != null && arg.length() > ) {
                     result.append(arg);
                     characterIterators.add(
                              createAttributedCharacterIterator(
                              arg, Field.ARGUMENT,
                              Integer.valueOf(argumentNumber)));
                     last = result.length();
                 }
             }
             else {
                 if (subFormatter != null) {
                     arg = subFormatter.format(obj);
                 }
                 last = result.length();
                 result.append(arg);
                 if (i ==  && fp != null && Field.ARGUMENT.equals(
                               fp.getFieldAttribute())) {
                     fp.setBeginIndex(last);
                     fp.setEndIndex(result.length());
                 }
                 last = result.length();
             }
         }
     }
     result.append(pattern.substring(lastOffset, pattern.length()));
     if (characterIterators != null && last != result.length()) {
         characterIterators.add(createAttributedCharacterIterator(
                                result.substring(last)));
     }
     return result;
 }

友情链接