devbox
2023面试高手
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

java的NumberFormat、DecimalFormat、MessageFormat类源码详解_dontcarefieldposition.instance

作者：2023面试高手 | 2024-03-06 22:10:44

赞

踩

dontcarefieldposition.instance

java的NumberFormat、DecimalFormat、MessageFormat类源码详解

NumberFormat类的定义

  1. public abstract class NumberFormat extends Format  {
  2.  
  3.     protected NumberFormat() {
  4.     }
  5.  
  6.     @Override
  7.     public StringBuffer format(Object number,
  8.                                StringBuffer toAppendTo,
  9.                                FieldPosition pos) {
  10.         if (number instanceof Long || number instanceof Integer ||
  11.             number instanceof Short || number instanceof Byte ||
  12.             number instanceof AtomicInteger || number instanceof AtomicLong ||
  13.             (number instanceof BigInteger &&
  14.              ((BigInteger)number).bitLength() < 64)) {
  15.             return format(((Number)number).longValue(), toAppendTo, pos);
  16.         } else if (number instanceof Number) {
  17.             return format(((Number)number).doubleValue(), toAppendTo, pos);
  18.         } else {
  19.             throw new IllegalArgumentException("Cannot format given Object as a Number");
  20.         }
  21.     }
  22.  
  23.     @Override
  24.     public final Object parseObject(String source, ParsePosition pos) {
  25.         return parse(source, pos);
  26.     }
  27.  
  28.     public final String format(double number) {
  29.         // Use fast-path for double result if that works
  30.         String result = fastFormat(number);
  31.         if (result != null)
  32.             return result;
  33.  
  34.         return format(number, new StringBuffer(),
  35.                       DontCareFieldPosition.INSTANCE).toString();
  36.     }
  37.  
  38.  
  39.     String fastFormat(double number) { return null; }
  40.  
  41.     public final String format(long number) {
  42.         return format(number, new StringBuffer(),
  43.                       DontCareFieldPosition.INSTANCE).toString();
  44.     }
  45.  
  46.     public abstract StringBuffer format(double number,
  47.                                         StringBuffer toAppendTo,
  48.                                         FieldPosition pos);
  49.  
  50.     public abstract StringBuffer format(long number,
  51.                                         StringBuffer toAppendTo,
  52.                                         FieldPosition pos);
  53.  
  54.     public abstract Number parse(String source, ParsePosition parsePosition);
  55.  
  56.     public Number parse(String source) throws ParseException {
  57.         ParsePosition parsePosition = new ParsePosition(0);
  58.         Number result = parse(source, parsePosition);
  59.         if (parsePosition.index == 0) {
  60.             throw new ParseException("Unparseable number: \"" + source + "\"",
  61.                                      parsePosition.errorIndex);
  62.         }
  63.         return result;
  64.     }
  65.  
  66.     public boolean isParseIntegerOnly() {
  67.         return parseIntegerOnly;
  68.     }
  69.  
  70.     public void setParseIntegerOnly(boolean value) {
  71.         parseIntegerOnly = value;
  72.     }
  73.  
  74.     //============== Locale Stuff =====================
  75.     public final static NumberFormat getInstance() {
  76.         return getInstance(Locale.getDefault(Locale.Category.FORMAT), NUMBERSTYLE);
  77.     }
  78.  
  79.     public static NumberFormat getInstance(Locale inLocale) {
  80.         return getInstance(inLocale, NUMBERSTYLE);
  81.     }
  82.  
  83.     public final static NumberFormat getNumberInstance() {
  84.         return getInstance(Locale.getDefault(Locale.Category.FORMAT), NUMBERSTYLE);
  85.     }
  86.  
  87.     public static NumberFormat getNumberInstance(Locale inLocale) {
  88.         return getInstance(inLocale, NUMBERSTYLE);
  89.     }
  90.  
  91.     public final static NumberFormat getIntegerInstance() {
  92.         return getInstance(Locale.getDefault(Locale.Category.FORMAT), INTEGERSTYLE);
  93.     }
  94.  
  95.     public static NumberFormat getIntegerInstance(Locale inLocale) {
  96.         return getInstance(inLocale, INTEGERSTYLE);
  97.     }
  98.  
  99.     public final static NumberFormat getCurrencyInstance() {
  100.         return getInstance(Locale.getDefault(Locale.Category.FORMAT), CURRENCYSTYLE);
  101.     }
  102.  
  103.     public static NumberFormat getCurrencyInstance(Locale inLocale) {
  104.         return getInstance(inLocale, CURRENCYSTYLE);
  105.     }
  106.  
  107.     public final static NumberFormat getPercentInstance() {
  108.         return getInstance(Locale.getDefault(Locale.Category.FORMAT), PERCENTSTYLE);
  109.     }
  110.  
  111.     public static NumberFormat getPercentInstance(Locale inLocale) {
  112.         return getInstance(inLocale, PERCENTSTYLE);
  113.     }
  114.  
  115.     /*public*/ final static NumberFormat getScientificInstance() {
  116.         return getInstance(Locale.getDefault(Locale.Category.FORMAT), SCIENTIFICSTYLE);
  117.     }
  118.  
  119.     /*public*/ static NumberFormat getScientificInstance(Locale inLocale) {
  120.         return getInstance(inLocale, SCIENTIFICSTYLE);
  121.     }
  122.  
  123.     public static Locale[] getAvailableLocales() {
  124.         LocaleServiceProviderPool pool =
  125.             LocaleServiceProviderPool.getPool(NumberFormatProvider.class);
  126.         return pool.getAvailableLocales();
  127.     }
  128.  
  129.     @Override
  130.     public int hashCode() {
  131.         return maximumIntegerDigits * 37 + maxFractionDigits;
  132.         // just enough fields for a reasonable distribution
  133.     }
  134.  
  135.     @Override
  136.     public boolean equals(Object obj) {
  137.         if (obj == null) {
  138.             return false;
  139.         }
  140.         if (this == obj) {
  141.             return true;
  142.         }
  143.         if (getClass() != obj.getClass()) {
  144.             return false;
  145.         }
  146.         NumberFormat other = (NumberFormat) obj;
  147.         return (maximumIntegerDigits == other.maximumIntegerDigits
  148.             && minimumIntegerDigits == other.minimumIntegerDigits
  149.             && maximumFractionDigits == other.maximumFractionDigits
  150.             && minimumFractionDigits == other.minimumFractionDigits
  151.             && groupingUsed == other.groupingUsed
  152.             && parseIntegerOnly == other.parseIntegerOnly);
  153.     }
  154.  
  155.     @Override
  156.     public Object clone() {
  157.         NumberFormat other = (NumberFormat) super.clone();
  158.         return other;
  159.     }
  160. }

  1. import java.text.* ; 
  2. public class NumberFormatDemo01{ 
  3.   public static void main(String args[]){ 
  4.     NumberFormat nf = null ;    // 声明一个NumberFormat对象 
  5.     nf = NumberFormat.getInstance() ;  // 得到默认的数字格式化显示 
  6.     System.out.println("格式化之后的数字：" + nf.format(10000000)) ; 
  7.     System.out.println("格式化之后的数字：" + nf.format(1000.345)) ; 
  8.   } 
  9. };

import java.text.NumberFormat;

1。Decimalformat df1 = new Decimalformat("####.000"); 
　　 
      System.out.println(df1.format(1234.56));

     显示：1234.560

2。NumberFormat nf   =   NumberFormat.getPercentInstance();     
　 // nf.setMinimumFractionDigits( 2 );        保留到小数点后几位        显示：47.00%

　 System.out.println(nf.format(0.47));

     显示：47%

     (法二)

     DecimalFormat df1 = new DecimalFormat("##.00%");    //##.00%   百分比格式，后面不足2位的用0补齐
     baifenbi= df1.format(fen);  

     显示：47.00%

3。DecimalFormat   df   =   new   DecimalFormat("###,##0.00");

      System.out.println(nf.format(24.7));

     显示：24.70

      System.out.println(nf.format(23123.47));

    显示：123,23.47

补充：0.00、0.01; 0.00%、0.12%这样的数据，如果按照上面的格式可能会造成数据显示成：.00、.01; .00%、.12%，怎么办呢？只要把格式改成：

    DecimalFormat df1 = new DecimalFormat("0.00");    
    DecimalFormat df2 = new DecimalFormat("0.00%");

    df1.formatI（number）;df2.formatI（number）;

     显示：0.00、0.01; 0.00%、0.12%

  1. public class Test {
  2.  public static void main(String[] args) {
  3.   Double myNumber=23323.3323232323;
  4.   Double test=0.3434;
  5.   //getInstance() 
  6.   //返回当前缺省语言环境的缺省数值格式。
  7.   String myString = NumberFormat.getInstance().format(myNumber);
  8.   System.out.println(myString);
  9.   //getCurrencyInstance()返回当前缺省语言环境的通用格式
  10.   myString = NumberFormat.getCurrencyInstance().format(myNumber); 
  11.   System.out.println(myString);
  12.   //getNumberInstance() 返回当前缺省语言环境的通用数值格式。 
  13.   myString = NumberFormat.getNumberInstance().format(myNumber); 
  14.   System.out.println(myString);
  15.   //getPercentInstance()  返回当前缺省语言环境的百分比格式。
  16.   myString = NumberFormat.getPercentInstance().format(test); 
  17.   System.out.println(myString);
  18.   //setMaximumFractionDigits(int) 设置数值的小数部分允许的最大位数。 
  19.   //setMaximumIntegerDigits(int)  设置数值的整数部分允许的最大位数。 
  20.   //setMinimumFractionDigits(int) 设置数值的小数部分允许的最小位数。 
  21.   //setMinimumIntegerDigits(int)  设置数值的整数部分允许的最小位数.
  22.   NumberFormat format = NumberFormat.getInstance();
  23.   format.setMinimumFractionDigits( 3 );
  24.   format.setMaximumFractionDigits(5);
  25.   format.setMaximumIntegerDigits( 10 );
  26.   format.setMinimumIntegerDigits(0);
  27.   System.out.println(format.format(2132323213.23266666666));
  28.  }
  29.  
  30. }

结果为:
23,323.332
￥23,323.33
23,323.332
34%
2,132,323,213.23267

 

MessageFormat

  1. public class MessageFormat extends Format {
  2.  
  3.     private static final long serialVersionUID = 6479157306784022952L;
  4.  
  5.     public MessageFormat(String pattern) {
  6.         this.locale = Locale.getDefault(Locale.Category.FORMAT);
  7.         applyPattern(pattern);
  8.     }
  9.  
  10.     public MessageFormat(String pattern, Locale locale) {
  11.         this.locale = locale;
  12.         applyPattern(pattern);
  13.     }
  14.  
  15.     public void setLocale(Locale locale) {
  16.         this.locale = locale;
  17.     }
  18.  
  19.     public Locale getLocale() {
  20.         return locale;
  21.     }
  22.  
  23.     @SuppressWarnings("fallthrough") // fallthrough in switch is expected, suppress it
  24.     public void applyPattern(String pattern) {
  25.             StringBuilder[] segments = new StringBuilder[4];
  26.             // Allocate only segments[SEG_RAW] here. The rest are
  27.             // allocated on demand.
  28.             segments[SEG_RAW] = new StringBuilder();
  29.  
  30.             int part = SEG_RAW;
  31.             int formatNumber = 0;
  32.             boolean inQuote = false;
  33.             int braceStack = 0;
  34.             maxOffset = -1;
  35.             for (int i = 0; i < pattern.length(); ++i) {
  36.                 char ch = pattern.charAt(i);
  37.                 if (part == SEG_RAW) {
  38.                     if (ch == '\'') {
  39.                         if (i + 1 < pattern.length()
  40.                             && pattern.charAt(i+1) == '\'') {
  41.                             segments[part].append(ch);  // handle doubles
  42.                             ++i;
  43.                         } else {
  44.                             inQuote = !inQuote;
  45.                         }
  46.                     } else if (ch == '{' && !inQuote) {
  47.                         part = SEG_INDEX;
  48.                         if (segments[SEG_INDEX] == null) {
  49.                             segments[SEG_INDEX] = new StringBuilder();
  50.                         }
  51.                     } else {
  52.                         segments[part].append(ch);
  53.                     }
  54.                 } else  {
  55.                     if (inQuote) {              // just copy quotes in parts
  56.                         segments[part].append(ch);
  57.                         if (ch == '\'') {
  58.                             inQuote = false;
  59.                         }
  60.                     } else {
  61.                         switch (ch) {
  62.                         case ',':
  63.                             if (part < SEG_MODIFIER) {
  64.                                 if (segments[++part] == null) {
  65.                                     segments[part] = new StringBuilder();
  66.                                 }
  67.                             } else {
  68.                                 segments[part].append(ch);
  69.                             }
  70.                             break;
  71.                         case '{':
  72.                             ++braceStack;
  73.                             segments[part].append(ch);
  74.                             break;
  75.                         case '}':
  76.                             if (braceStack == 0) {
  77.                                 part = SEG_RAW;
  78.                                 makeFormat(i, formatNumber, segments);
  79.                                 formatNumber++;
  80.                                 // throw away other segments
  81.                                 segments[SEG_INDEX] = null;
  82.                                 segments[SEG_TYPE] = null;
  83.                                 segments[SEG_MODIFIER] = null;
  84.                             } else {
  85.                                 --braceStack;
  86.                                 segments[part].append(ch);
  87.                             }
  88.                             break;
  89.                         case ' ':
  90.                             // Skip any leading space chars for SEG_TYPE.
  91.                             if (part != SEG_TYPE || segments[SEG_TYPE].length() > 0) {
  92.                                 segments[part].append(ch);
  93.                             }
  94.                             break;
  95.                         case '\'':
  96.                             inQuote = true;
  97.                             // fall through, so we keep quotes in other parts
  98.                         default:
  99.                             segments[part].append(ch);
  100.                             break;
  101.                         }
  102.                     }
  103.                 }
  104.             }
  105.             if (braceStack == 0 && part != 0) {
  106.                 maxOffset = -1;
  107.                 throw new IllegalArgumentException("Unmatched braces in the pattern.");
  108.             }
  109.             this.pattern = segments[0].toString();
  110.     }
  111.  
  112.     public String toPattern() {
  113.         // later, make this more extensible
  114.         int lastOffset = 0;
  115.         StringBuilder result = new StringBuilder();
  116.         for (int i = 0; i <= maxOffset; ++i) {
  117.             copyAndFixQuotes(pattern, lastOffset, offsets[i], result);
  118.             lastOffset = offsets[i];
  119.             result.append('{').append(argumentNumbers[i]);
  120.             Format fmt = formats[i];
  121.             if (fmt == null) {
  122.                 // do nothing, string format
  123.             } else if (fmt instanceof NumberFormat) {
  124.                 if (fmt.equals(NumberFormat.getInstance(locale))) {
  125.                     result.append(",number");
  126.                 } else if (fmt.equals(NumberFormat.getCurrencyInstance(locale))) {
  127.                     result.append(",number,currency");
  128.                 } else if (fmt.equals(NumberFormat.getPercentInstance(locale))) {
  129.                     result.append(",number,percent");
  130.                 } else if (fmt.equals(NumberFormat.getIntegerInstance(locale))) {
  131.                     result.append(",number,integer");
  132.                 } else {
  133.                     if (fmt instanceof DecimalFormat) {
  134.                         result.append(",number,").append(((DecimalFormat)fmt).toPattern());
  135.                     } else if (fmt instanceof ChoiceFormat) {
  136.                         result.append(",choice,").append(((ChoiceFormat)fmt).toPattern());
  137.                     } else {
  138.                         // UNKNOWN
  139.                     }
  140.                 }
  141.             } else if (fmt instanceof DateFormat) {
  142.                 int index;
  143.                 for (index = MODIFIER_DEFAULT; index < DATE_TIME_MODIFIERS.length; index++) {
  144.                     DateFormat df = DateFormat.getDateInstance(DATE_TIME_MODIFIERS[index],
  145.                                                                locale);
  146.                     if (fmt.equals(df)) {
  147.                         result.append(",date");
  148.                         break;
  149.                     }
  150.                     df = DateFormat.getTimeInstance(DATE_TIME_MODIFIERS[index],
  151.                                                     locale);
  152.                     if (fmt.equals(df)) {
  153.                         result.append(",time");
  154.                         break;
  155.                     }
  156.                 }
  157.                 if (index >= DATE_TIME_MODIFIERS.length) {
  158.                     if (fmt instanceof SimpleDateFormat) {
  159.                         result.append(",date,").append(((SimpleDateFormat)fmt).toPattern());
  160.                     } else {
  161.                         // UNKNOWN
  162.                     }
  163.                 } else if (index != MODIFIER_DEFAULT) {
  164.                     result.append(',').append(DATE_TIME_MODIFIER_KEYWORDS[index]);
  165.                 }
  166.             } else {
  167.                 //result.append(", unknown");
  168.             }
  169.             result.append('}');
  170.         }
  171.         copyAndFixQuotes(pattern, lastOffset, pattern.length(), result);
  172.         return result.toString();
  173.     }
  174.  
  175.    public final StringBuffer format(Object[] arguments, StringBuffer result,
  176.                                      FieldPosition pos)
  177.     {
  178.         return subformat(arguments, result, pos, null);
  179.     }
  180.  
  181.     public static String format(String pattern, Object ... arguments) {
  182.         MessageFormat temp = new MessageFormat(pattern);
  183.         return temp.format(arguments);
  184.     }
  185.  
  186.     // Overrides
  187.     public final StringBuffer format(Object arguments, StringBuffer result,
  188.                                      FieldPosition pos)
  189.     {
  190.         return subformat((Object[]) arguments, result, pos, null);
  191.     }
  192.  
  193.     public Object[] parse(String source, ParsePosition pos) {
  194.         if (source == null) {
  195.             Object[] empty = {};
  196.             return empty;
  197.         }
  198.  
  199.         int maximumArgumentNumber = -1;
  200.         for (int i = 0; i <= maxOffset; i++) {
  201.             if (argumentNumbers[i] > maximumArgumentNumber) {
  202.                 maximumArgumentNumber = argumentNumbers[i];
  203.             }
  204.         }
  205.         Object[] resultArray = new Object[maximumArgumentNumber + 1];
  206.  
  207.         int patternOffset = 0;
  208.         int sourceOffset = pos.index;
  209.         ParsePosition tempStatus = new ParsePosition(0);
  210.         for (int i = 0; i <= maxOffset; ++i) {
  211.             // match up to format
  212.             int len = offsets[i] - patternOffset;
  213.             if (len == 0 || pattern.regionMatches(patternOffset,
  214.                                                   source, sourceOffset, len)) {
  215.                 sourceOffset += len;
  216.                 patternOffset += len;
  217.             } else {
  218.                 pos.errorIndex = sourceOffset;
  219.                 return null; // leave index as is to signal error
  220.             }
  221.  
  222.             // now use format
  223.             if (formats[i] == null) {   // string format
  224.                 // if at end, use longest possible match
  225.                 // otherwise uses first match to intervening string
  226.                 // does NOT recursively try all possibilities
  227.                 int tempLength = (i != maxOffset) ? offsets[i+1] : pattern.length();
  228.  
  229.                 int next;
  230.                 if (patternOffset >= tempLength) {
  231.                     next = source.length();
  232.                 }else{
  233.                     next = source.indexOf(pattern.substring(patternOffset, tempLength),
  234.                                           sourceOffset);
  235.                 }
  236.  
  237.                 if (next < 0) {
  238.                     pos.errorIndex = sourceOffset;
  239.                     return null; // leave index as is to signal error
  240.                 } else {
  241.                     String strValue= source.substring(sourceOffset,next);
  242.                     if (!strValue.equals("{"+argumentNumbers[i]+"}"))
  243.                         resultArray[argumentNumbers[i]]
  244.                             = source.substring(sourceOffset,next);
  245.                     sourceOffset = next;
  246.                 }
  247.             } else {
  248.                 tempStatus.index = sourceOffset;
  249.                 resultArray[argumentNumbers[i]]
  250.                     = formats[i].parseObject(source,tempStatus);
  251.                 if (tempStatus.index == sourceOffset) {
  252.                     pos.errorIndex = sourceOffset;
  253.                     return null; // leave index as is to signal error
  254.                 }
  255.                 sourceOffset = tempStatus.index; // update
  256.             }
  257.         }
  258.         int len = pattern.length() - patternOffset;
  259.         if (len == 0 || pattern.regionMatches(patternOffset,
  260.                                               source, sourceOffset, len)) {
  261.             pos.index = sourceOffset + len;
  262.         } else {
  263.             pos.errorIndex = sourceOffset;
  264.             return null; // leave index as is to signal error
  265.         }
  266.         return resultArray;
  267.     }
  268.  
  269.     public Object[] parse(String source) throws ParseException {
  270.         ParsePosition pos  = new ParsePosition(0);
  271.         Object[] result = parse(source, pos);
  272.         if (pos.index == 0)  // unchanged, returned object is null
  273.             throw new ParseException("MessageFormat parse error!", pos.errorIndex);
  274.  
  275.         return result;
  276.     }
  277.  
  278.     public Object parseObject(String source, ParsePosition pos) {
  279.         return parse(source, pos);
  280.     }
  281.  
  282.     public Object clone() {
  283.         MessageFormat other = (MessageFormat) super.clone();
  284.  
  285.         // clone arrays. Can't do with utility because of bug in Cloneable
  286.         other.formats = formats.clone(); // shallow clone
  287.         for (int i = 0; i < formats.length; ++i) {
  288.             if (formats[i] != null)
  289.                 other.formats[i] = (Format)formats[i].clone();
  290.         }
  291.         // for primitives or immutables, shallow clone is enough
  292.         other.offsets = offsets.clone();
  293.         other.argumentNumbers = argumentNumbers.clone();
  295.         return other;
  296.     }
  298.     public boolean equals(Object obj) {
  299.         if (this == obj)                      // quick check
  300.             return true;
  301.         if (obj == null || getClass() != obj.getClass())
  302.             return false;
  303.         MessageFormat other = (MessageFormat) obj;
  304.         return (maxOffset == other.maxOffset
  305.                 && pattern.equals(other.pattern)
  306.                 && ((locale != null && locale.equals(other.locale))
  307.                  || (locale == null && other.locale == null))
  308.                 && Arrays.equals(offsets,other.offsets)
  309.                 && Arrays.equals(argumentNumbers,other.argumentNumbers)
  310.                 && Arrays.equals(formats,other.formats));
  311.     }
  313.     public static class Field extends Format.Field {
  315.         // Proclaim serial compatibility with 1.4 FCS
  316.         private static final long serialVersionUID = 7899943957617360810L;
  318.         protected Field(String name) {
  319.             super(name);
  320.         }
  322.         protected Object readResolve() throws InvalidObjectException {
  323.             if (this.getClass() != MessageFormat.Field.class) {
  324.                 throw new InvalidObjectException("subclass didn't correctly implement readResolve");
  325.             }
  327.             return ARGUMENT;
  328.         }
  330.         //
  331.         // The constants
  332.         //
  333.         public final static Field ARGUMENT =
  334.                            new Field("message argument field");
  335.     }
  336. }

为什么要使用静态内部类

  1. class Company {
  2.  
  3.     private String theCEO = "stupid";
  4.     private static String companyName = "STUPID COM";
  5.  
  6.     // 1
  7.     static class Employee {
  8.         public Employee() {
  9.             System.out.println("company name - " + companyName);
  10.             // 2
  11.             //System.out.println("CEO - " + theCEO);
  12.         }
  13.     }
  14.  
  15.     public Company(){
  16.         System.out.println("Company object is created");
  17.     }
  18. }
  19.  
  20. public class Main {
  21.  
  22.     public static void main(String[] args) {
  23. //        Company company = new Company();
  24. //        Company.Employee employee = company.new Employee();
  25.  
  26.         // 3
  27.         Company.Employee employee = new Company.Employee();
  28.     }
  29. }

如果内部类不是静态的。要用这个内部类就必须先初始化包裹类。也是，如果不初始化出来对应的包裹类，内部类对象怎么能访问这些包裹类对象的非静态实例对象呢。

  1. 加static，员工类变成静态内部类。
  2. 静态内部类不能再访问包裹类的非静态成员。
  3. 看起来正常的初始化方法：new Company.Employee()。

一般来说，内部类不需要访问包裹类的非静态成员的时候。或者只是做一个工具给外部调用，而这些工具需要按照功能区分为的时候使用静态内部类。

 

FormatElement:
         { ArgumentIndex }
         { ArgumentIndex , FormatType }
         { ArgumentIndex , FormatType , FormatStyle }

FormatType: 
         number
         date
         time
         choice(需要使用ChoiceFormat)
FormatStyle:
         short
         medium
         long
         full
         integer
         currency
         percent
         SubformatPattern(子模式)

{0}、{1,number,short}、{2,number,#.#}属于FormatElement，0,1,2是ArgumentIndex

{1,number,short}里面的number属于FormatType，short则属于FormatStyle

{1,number,#.#}里面的#.#就属于子格式模式

  1.  
  2. import java.text.MessageFormat;
  3.  
  4. String str = "{0}{1}{2}{3}{4}{5}{6}{7}{8}{9}{10}{11}{12}{13}{14}{15}{16}";
  5. Object[] array = new Object[]{"A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q"};
  6. String value = MessageFormat.format(str, array);
  7. System.out.println(value); // ABCDEFGHIJKLMNOPQ
  8.  
  9.  
  10. String message = "oh, {0} is a person";
  11. Object[] array = new Object[]{"ZhangSan"};
  12. String value = MessageFormat.format(message, array);
  13. System.out.println(value); // oh, ZhangSan is a person
  14.  
  15.  
  16. String message = "oh, {0,number,#.#} is a number";
  17. Object[] array = new Object[]{new Double(3.1415)};
  18. String value = MessageFormat.format(message, array);
  19. System.out.println(value); // oh, 3.1 is a number
  20.  
  21.  
  22. // MessageFormat的format方法源码
  23. public static String format(String pattern, Object ... arguments) 
  24. {
  25.     MessageFormat temp = new MessageFormat(pattern);
  26.     return temp.format(arguments);
  27. }

对字符串的匹配比较智能

  1. String str = "{0} | {1} | {0} | {1}";
  2. Object[] array = new Object[] { "A", "B" };
  3. String value = MessageFormat.format(str, array);
  4. System.out.println(value); // A | B | A | B
  1.         StringBuilder sb=new StringBuilder();
  2.         sb.append("    insert into test_tb (");
  3.         sb.append("        createTime, ");
  4.         sb.append("        datefrom, ");
  5.         sb.append("        dateto, ");
  6.         sb.append("        name, ");
  7.         sb.append("        intranetid, ");
  8.         sb.append("        actualhour, ");
  9.         sb.append("        planhour, ");
  10.         sb.append("        status");
  11.         sb.append("    ) values (");
  12.         sb.append("        ''{0}'',");
  13.         sb.append("        ''{1}'',");
  14.         sb.append("        ''{2}'',");
  15.         sb.append("        ''{3}'',");
  16.         sb.append("        ''{4}'',");
  17.         sb.append("        ''{5}'',");
  18.         sb.append("        ''{6}'',");
  19.         sb.append("        ''{7}''");
  20.         sb.append("    )");
  21.         String result=sb.toString();
  22.         
  23.         Object[] arr={createTime,datefrom,dateto,name,intranetid,actualhour,planhour,status};
  24.         String sql=MessageFormat.format(result, arr);

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/2023面试高手/article/detail/201804
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号