深入学习java源码之MessageFormat.format()与与MessageFormat.parse()
new创建数组
java语言使用new操作符来创建数组，语法如下：
arrayRefVar = new dataType[arraySize];
上面的语法语句做了两件事：
一、使用dataType[arraySize]创建了一个数组。
二、把新创建的数组的引用赋值给变量 arrayRefVar。
数组变量的声明，和创建数组可以用一条语句完成，如下所示：
dataType[] arrayRefVar = new dataType[arraySize];
另外，你还可以使用如下的方式创建数组。
dataType[] arrayRefVar = {value0, value1, ..., valuek};
数组的元素是通过索引访问的。数组索引从0开始，所以索引值从0到arrayRefVar.length-1。
创建了一个包含10个double类型元素的数组
// 数组大小
int size = 10;
// 定义数组
double[] myList = new double[size];
myList[0] = 5.6;
myList[1] = 4.5;
myList[2] = 3.3;
myList[4] = 4.0;
myList[5] = 34.33;
myList[6] = 34.0;
myList[7] = 45.45;
myList[8] = 99.993;
myList[9] = 11123;
// 计算所有元素的总和
double total = 0;
for (int i = 0; i < size; i++) {
total += myList[i];
}
StringBuilder与StringBuffer的区别
String : 是java.lang包中的immutable类，String里面所有的属性几乎也是final,由于它的不可变性，类似拼接，裁剪字符串等动作都会产生大量无用的中间对象。由于字符串操作在项目中很常见，所以对String的操作对项目的性能往往有很明显的影响。
StringBuffer : 这个类是为了解决String拼接产生多余对象的问题而提供的一个类。StringBuffer保证了线程的安全，也带来了多余的开销。
StringBuilder : StringBuilder的功能与StringBuffer一样。但是区别是StringBuilder没有处理线程安全，减少了开销。
1.StringBuffer算是String的敷生的一个类，而StringBuilder却又是Oracle公司为了减少线程开销，而诞生的一个类。(这个区别有点扯….)
2.字符串的主要操作还是String，StringBuffer与StringBuilder主要还是用来拼接字符串的。
3.StringBuffer与StringBuilder的长度是可以定义的，而String不能(因为String是个对象)。
1. String：它被用于裁剪，拼接。(当然如果拼接过多的话还是建议用StringBuffer,或者StringBuild)搜索字符串，比较字符串，截取字符串，转换大小写等。在项目中不经常发生变化的业务场景中，优先使用String
2. StringBuffer：用于拼接，替换，删除。在项目多线程环境下运行，如:XML解析，HTTP参数解析与封装等。
3. StringBuilder:它同StringBuffer使用方式一样，不过在项目中使用的地方建议是单线程的环境下，如：SQL拼接，JSON封装等。
1.String JDK9后大改：将数据存储方式从char[]数组修改为byte[]数组在加上一个标示编码，然后重写所有相关的类，以保证没有任何性能上的损失。
2.StringBuffer与StringBuilder两者都是由byte[]数组(在JDK 9 以后)，所以能定义长度，但是如果不定义的话那默认为16。如果当前对象操作，使得数组长度超过了16，那么数组就会创建新的，还要进行arraycopy，丢弃原来数组。
3.讲String的时候必须得讲一下字符串的缓存。字符串的缓存核心方法就是intern();这个方法了。这个方法主要逻辑是判断当前字符串是否存在于StringTable,如果存在则取出来，如果不存在则添加进去。
4.如果看完链接想使用字符串的intern();这个方法。然而每次都要调用，这未免太过于麻烦，考虑到这个因素，博主给诸位提供一个不用掉用也能使用intern();的方法。那就是配置GC,且要使用G1 GC,GC配置是 ‘-XX:+UseStringDeduplication’ 。
5.在使用了intern();方法的情况下，尽量不要使用new 方法来创建新的字符串，因为new 方法是直接在堆中创建一个对象，不会去字符串常量池中，进行操作。
//.java文件:
public static void main(String args[]){
String c = "12241241242";
String b = UUID.randomUUID().toString().intern();
String a = "sda"+"123"+"sss"c;
}
//.class文件反编译后
public static void main(String[] args) {
String c = "12241241242";
String b = UUID.randomUUID().toString().intern();
(new StringBuilder()).append("sda123sss").append(b).append(c).toString();
}
MessageFormat提供了一种以语言中立的方式产生连接消息的方法。 使用它来构建为最终用户显示的消息。
MessageFormat采取一组对象，对它们进行格式化，然后将格式化的字符串插入到适当位置的模式中。
注意： MessageFormat与其他Format类别不同之处在于，您创建一个MessageFormat对象，其中一个构造函数（不是以getInstance样式工厂方法）。 工厂方法不是必需的，因为MessageFormat本身不实现区域设置特定的行为。 任何特定于语言环境的行为都由您提供的模式以及用于插入参数的子格式定义。
| Modifier and Type | Method and Description |
|---|---|
void | applyPattern(String pattern) 设置此消息格式使用的模式。 |
Object | clone() 创建并返回此对象的副本。 |
boolean | equals(Object obj) 两个消息格式对象之间的平等比较 |
StringBuffer | format(Object[] arguments, StringBuffer result, FieldPosition pos) 格式化一个对象数组，并将 |
StringBuffer | format(Object arguments, StringBuffer result, FieldPosition pos) 格式化一组对象，并将 |
static String | format(String pattern, Object... arguments) 使用给定的模式创建一个MessageFormat，并使用它来格式化给定的参数。 |
AttributedCharacterIterator | formatToCharacterIterator(Object arguments) 格式化一组对象，并将它们插入到 |
Format[] | getFormats() 获取用于先前设置的模式字符串中的格式元素的格式。 |
Format[] | getFormatsByArgumentIndex() 获取用于传递到 |
Locale | getLocale() 获取创建或比较子格式时使用的区域设置。 |
int | hashCode() 生成消息格式对象的哈希码。 |
Object[] | parse(String source) 从给定字符串的开头解析文本以产生一个对象数组。 |
Object[] | parse(String source, ParsePosition pos) 解析字符串。 |
Object | parseObject(String source, ParsePosition pos) 从字符串中解析文本以生成对象数组。 |
void | setFormat(int formatElementIndex, Format newFormat) 设置在先前设置的模式字符串中使用具有给定格式元素索引的格式元素的格式。 |
void | setFormatByArgumentIndex(int argumentIndex, Format newFormat) 设置使用给定参数索引的先前设置的模式字符串中的格式元素的格式。 |
void | setFormats(Format[] newFormats) 设置用于先前设置的模式字符串中的格式元素的格式。 |
void | setFormatsByArgumentIndex(Format[] newFormats) 设置用于传递到 |
void | setLocale(Locale locale) 设置创建或比较子格式时要使用的区域设置。 |
String | toPattern() 返回表示消息格式的当前状态的模式。 |
java源码
logger.info(MessageFormat.format("====sys worker {0} sys success:{1}====", code,.toString()));
int planet = 7;
String event = "a disturbance in the Force";
String result = MessageFormat.format(
"At {1,time} on {1,date}, there was {2} on planet {0,number,integer}.",
planet, new Date(), event);
输出为：
At 12:30 PM on Jul 3, 2053, there was a disturbance in the Force on planet 7.
int fileCount = 1273;
String diskName = "MyDisk";
Object[] testArgs = {new Long(fileCount), diskName};
MessageFormat form = new MessageFormat(
"The disk \"{1}\" contains {0} file(s).");
System.out.println(form.format(testArgs));
fileCount的输出值fileCount ：
The disk "MyDisk" contains 0 file(s).
The disk "MyDisk" contains 1 file(s).
The disk "MyDisk" contains 1,273 file(s).
MessageFormat form = new MessageFormat("The disk \"{1}\" contains {0}.");
double[] filelimits = {0,1,2};
String[] filepart = {"no files","one file","{0,number} files"};
ChoiceFormat fileform = new ChoiceFormat(filelimits, filepart);
form.setFormatByArgumentIndex(0, fileform);
int fileCount = 1273;
String diskName = "MyDisk";
Object[] testArgs = {new Long(fileCount), diskName};
System.out.println(form.format(testArgs));
具有不同值的输出为fileCount ：
The disk "MyDisk" contains no files.
The disk "MyDisk" contains one file.
The disk "MyDisk" contains 1,273 files.
package java.text;
import java.io.InvalidObjectException;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Locale;
public class MessageFormat extends Format {
private static final long serialVersionUID = 6479157306784022952L;
public MessageFormat(String pattern) {
this.locale = Locale.getDefault(Locale.Category.FORMAT);
applyPattern(pattern);
}
public MessageFormat(String pattern, Locale locale) {
this.locale = locale;
applyPattern(pattern);
}
public void setLocale(Locale locale) {
this.locale = locale;
}
public Locale getLocale() {
return locale;
}
@SuppressWarnings("fallthrough") // fallthrough in switch is expected, suppress it
public void applyPattern(String pattern) {
StringBuilder[] segments = new StringBuilder[4];
// Allocate only segments[SEG_RAW] here. The rest are
// allocated on demand.
segments[SEG_RAW] = new StringBuilder();
int part = SEG_RAW;
int formatNumber = 0;
boolean inQuote = false;
int braceStack = 0;
maxOffset = -1;
for (int i = 0; i < pattern.length(); ++i) {
char ch = pattern.charAt(i);
if (part == SEG_RAW) {
if (ch == '\'') {
if (i + 1 < pattern.length()
&& pattern.charAt(i+1) == '\'') {
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 == 0) {
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() > 0) {
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 == 0 && part != 0) {
maxOffset = -1;
throw new IllegalArgumentException("Unmatched braces in the pattern.");
}
this.pattern = segments[0].toString();
}
public String toPattern() {
// later, make this more extensible
int lastOffset = 0;
StringBuilder result = new StringBuilder();
for (int i = 0; i <= maxOffset; ++i) {
copyAndFixQuotes(pattern, lastOffset, offsets[i], result);
lastOffset = offsets[i];
result.append('{').append(argumentNumbers[i]);
Format fmt = formats[i];
if (fmt == null) {
// do nothing, string format
} else if (fmt instanceof NumberFormat) {
if (fmt.equals(NumberFormat.getInstance(locale))) {
result.append(",number");
} else if (fmt.equals(NumberFormat.getCurrencyInstance(locale))) {
result.append(",number,currency");
} else if (fmt.equals(NumberFormat.getPercentInstance(locale))) {
result.append(",number,percent");
} else if (fmt.equals(NumberFormat.getIntegerInstance(locale))) {
result.append(",number,integer");
} else {
if (fmt instanceof DecimalFormat) {
result.append(",number,").append(((DecimalFormat)fmt).toPattern());
} else if (fmt instanceof ChoiceFormat) {
result.append(",choice,").append(((ChoiceFormat)fmt).toPattern());
} else {
// UNKNOWN
}
}
} else if (fmt instanceof DateFormat) {
int index;
for (index = MODIFIER_DEFAULT; index < DATE_TIME_MODIFIERS.length; index++) {
DateFormat df = DateFormat.getDateInstance(DATE_TIME_MODIFIERS[index],
locale);
if (fmt.equals(df)) {
result.append(",date");
break;
}
df = DateFormat.getTimeInstance(DATE_TIME_MODIFIERS[index],
locale);
if (fmt.equals(df)) {
result.append(",time");
break;
}
}
if (index >= DATE_TIME_MODIFIERS.length) {
if (fmt instanceof SimpleDateFormat) {
result.append(",date,").append(((SimpleDateFormat)fmt).toPattern());
} else {
// UNKNOWN
}
} else if (index != MODIFIER_DEFAULT) {
result.append(',').append(DATE_TIME_MODIFIER_KEYWORDS[index]);
}
} else {
//result.append(", unknown");
}
result.append('}');
}
copyAndFixQuotes(pattern, lastOffset, pattern.length(), result);
return result.toString();
}
public void setFormatsByArgumentIndex(Format[] newFormats) {
for (int i = 0; i <= maxOffset; i++) {
int j = argumentNumbers[i];
if (j < newFormats.length) {
formats[i] = newFormats[j];
}
}
}
public void setFormats(Format[] newFormats) {
int runsToCopy = newFormats.length;
if (runsToCopy > maxOffset + 1) {
runsToCopy = maxOffset + 1;
}
for (int i = 0; i < runsToCopy; i++) {
formats[i] = newFormats[i];
}
}
public void setFormatByArgumentIndex(int argumentIndex, Format newFormat) {
for (int j = 0; j <= maxOffset; j++) {
if (argumentNumbers[j] == argumentIndex) {
formats[j] = newFormat;
}
}
}
public void setFormat(int formatElementIndex, Format newFormat) {
formats[formatElementIndex] = newFormat;
}
public Format[] getFormatsByArgumentIndex() {
int maximumArgumentNumber = -1;
for (int i = 0; i <= maxOffset; i++) {
if (argumentNumbers[i] > maximumArgumentNumber) {
maximumArgumentNumber = argumentNumbers[i];
}
}
Format[] resultArray = new Format[maximumArgumentNumber + 1];
for (int i = 0; i <= maxOffset; i++) {
resultArray[argumentNumbers[i]] = formats[i];
}
return resultArray;
}
public Format[] getFormats() {
Format[] resultArray = new Format[maxOffset + 1];
System.arraycopy(formats, 0, resultArray, 0, maxOffset + 1);
return resultArray;
}
public final StringBuffer format(Object[] arguments, StringBuffer result,
FieldPosition pos)
{
return subformat(arguments, result, pos, null);
}
public static String format(String pattern, Object ... arguments) {
MessageFormat temp = new MessageFormat(pattern);
return temp.format(arguments);
}
public final StringBuffer format(Object arguments, StringBuffer result,
FieldPosition pos)
{
return subformat((Object[]) arguments, result, pos, null);
}
public AttributedCharacterIterator formatToCharacterIterator(Object arguments) {
StringBuffer result = new StringBuffer();
ArrayList<AttributedCharacterIterator> iterators = new ArrayList<>();
if (arguments == null) {
throw new NullPointerException(
"formatToCharacterIterator must be passed non-null object");
}
subformat((Object[]) arguments, result, null, iterators);
if (iterators.size() == 0) {
return createAttributedCharacterIterator("");
}
return createAttributedCharacterIterator(
iterators.toArray(
new AttributedCharacterIterator[iterators.size()]));
}
public Object[] parse(String source, ParsePosition pos) {
if (source == null) {
Object[] empty = {};
return empty;
}
int maximumArgumentNumber = -1;
for (int i = 0; i <= maxOffset; i++) {
if (argumentNumbers[i] > maximumArgumentNumber) {
maximumArgumentNumber = argumentNumbers[i];
}
}
Object[] resultArray = new Object[maximumArgumentNumber + 1];
int patternOffset = 0;
int sourceOffset = pos.index;
ParsePosition tempStatus = new ParsePosition(0);
for (int i = 0; i <= maxOffset; ++i) {
// match up to format
int len = offsets[i] - patternOffset;
if (len == 0 || pattern.regionMatches(patternOffset,
source, sourceOffset, len)) {
sourceOffset += len;
patternOffset += len;
} else {
pos.errorIndex = sourceOffset;
return null; // leave index as is to signal error
}
// now use format
if (formats[i] == null) { // string format
// if at end, use longest possible match
// otherwise uses first match to intervening string
// does NOT recursively try all possibilities
int tempLength = (i != maxOffset) ? offsets[i+1] : pattern.length();
int next;
if (patternOffset >= tempLength) {
next = source.length();
}else{
next = source.indexOf(pattern.substring(patternOffset, tempLength),
sourceOffset);
}
if (next < 0) {
pos.errorIndex = sourceOffset;
return null; // leave index as is to signal error
} else {
String strValue= source.substring(sourceOffset,next);
if (!strValue.equals("{"+argumentNumbers[i]+"}"))
resultArray[argumentNumbers[i]]
= source.substring(sourceOffset,next);
sourceOffset = next;
}
} else {
tempStatus.index = sourceOffset;
resultArray[argumentNumbers[i]]
= formats[i].parseObject(source,tempStatus);
if (tempStatus.index == sourceOffset) {
pos.errorIndex = sourceOffset;
return null; // leave index as is to signal error
}
sourceOffset = tempStatus.index; // update
}
}
int len = pattern.length() - patternOffset;
if (len == 0 || pattern.regionMatches(patternOffset,
source, sourceOffset, len)) {
pos.index = sourceOffset + len;
} else {
pos.errorIndex = sourceOffset;
return null; // leave index as is to signal error
}
return resultArray;
}
public Object[] parse(String source) throws ParseException {
ParsePosition pos = new ParsePosition(0);
Object[] result = parse(source, pos);
if (pos.index == 0) // unchanged, returned object is null
throw new ParseException("MessageFormat parse error!", pos.errorIndex);
return result;
}
public Object parseObject(String source, ParsePosition pos) {
return parse(source, pos);
}
public Object clone() {
MessageFormat other = (MessageFormat) super.clone();
// clone arrays. Can't do with utility because of bug in Cloneable
other.formats = formats.clone(); // shallow clone
for (int i = 0; i < formats.length; ++i) {
if (formats[i] != null)
other.formats[i] = (Format)formats[i].clone();
}
// for primitives or immutables, shallow clone is enough
other.offsets = offsets.clone();
other.argumentNumbers = argumentNumbers.clone();
return other;
}
public boolean equals(Object obj) {
if (this == obj) // quick check
return true;
if (obj == null || getClass() != obj.getClass())
return false;
MessageFormat other = (MessageFormat) obj;
return (maxOffset == other.maxOffset
&& pattern.equals(other.pattern)
&& ((locale != null && locale.equals(other.locale))
|| (locale == null && other.locale == null))
&& Arrays.equals(offsets,other.offsets)
&& Arrays.equals(argumentNumbers,other.argumentNumbers)
&& Arrays.equals(formats,other.formats));
}
public int hashCode() {
return pattern.hashCode(); // enough for reasonable distribution
}
public static class Field extends Format.Field {
// Proclaim serial compatibility with 1.4 FCS
private static final long serialVersionUID = 7899943957617360810L;
protected Field(String name) {
super(name);
}
protected Object readResolve() throws InvalidObjectException {
if (this.getClass() != MessageFormat.Field.class) {
throw new InvalidObjectException("subclass didn't correctly implement readResolve");
}
return ARGUMENT;
}
public final static Field ARGUMENT =
new Field("message argument field");
}
private Locale locale;
private String pattern = "";
private static final int INITIAL_FORMATS = 10;
/**
* An array of formatters, which are used to format the arguments.
* @serial
*/
private Format[] formats = new Format[INITIAL_FORMATS];
private int[] offsets = new int[INITIAL_FORMATS];
private int[] argumentNumbers = new int[INITIAL_FORMATS];
private int maxOffset = -1;
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 = 0;
int last = result.length();
for (int i = 0; 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('{') >= 0) {
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() > 0) {
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 == 0 && 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;
}
private void append(StringBuffer result, CharacterIterator iterator) {
if (iterator.first() != CharacterIterator.DONE) {
char aChar;
result.append(iterator.first());
while ((aChar = iterator.next()) != CharacterIterator.DONE) {
result.append(aChar);
}
}
}
// Indices for segments
private static final int SEG_RAW = 0;
private static final int SEG_INDEX = 1;
private static final int SEG_TYPE = 2;
private static final int SEG_MODIFIER = 3; // modifier or subformat
// Indices for type keywords
private static final int TYPE_NULL = 0;
private static final int TYPE_NUMBER = 1;
private static final int TYPE_DATE = 2;
private static final int TYPE_TIME = 3;
private static final int TYPE_CHOICE = 4;
private static final String[] TYPE_KEYWORDS = {
"",
"number",
"date",
"time",
"choice"
};
// Indices for number modifiers
private static final int MODIFIER_DEFAULT = 0; // common in number and date-time
private static final int MODIFIER_CURRENCY = 1;
private static final int MODIFIER_PERCENT = 2;
private static final int MODIFIER_INTEGER = 3;
private static final String[] NUMBER_MODIFIER_KEYWORDS = {
"",
"currency",
"percent",
"integer"
};
// Indices for date-time modifiers
private static final int MODIFIER_SHORT = 1;
private static final int MODIFIER_MEDIUM = 2;
private static final int MODIFIER_LONG = 3;
private static final int MODIFIER_FULL = 4;
private static final String[] DATE_TIME_MODIFIER_KEYWORDS = {
"",
"short",
"medium",
"long",
"full"
};
// Date-time style values corresponding to the date-time modifiers.
private static final int[] DATE_TIME_MODIFIERS = {
DateFormat.DEFAULT,
DateFormat.SHORT,
DateFormat.MEDIUM,
DateFormat.LONG,
DateFormat.FULL,
};
private void makeFormat(int position, int offsetNumber,
StringBuilder[] textSegments)
{
String[] segments = new String[textSegments.length];
for (int i = 0; i < textSegments.length; i++) {
StringBuilder oneseg = textSegments[i];
segments[i] = (oneseg != null) ? oneseg.toString() : "";
}
// get the argument number
int argumentNumber;
try {
argumentNumber = Integer.parseInt(segments[SEG_INDEX]); // always unlocalized!
} catch (NumberFormatException e) {
throw new IllegalArgumentException("can't parse argument number: "
+ segments[SEG_INDEX], e);
}
if (argumentNumber < 0) {
throw new IllegalArgumentException("negative argument number: "
+ argumentNumber);
}
// resize format information arrays if necessary
if (offsetNumber >= formats.length) {
int newLength = formats.length * 2;
Format[] newFormats = new Format[newLength];
int[] newOffsets = new int[newLength];
int[] newArgumentNumbers = new int[newLength];
System.arraycopy(formats, 0, newFormats, 0, maxOffset + 1);
System.arraycopy(offsets, 0, newOffsets, 0, maxOffset + 1);
System.arraycopy(argumentNumbers, 0, newArgumentNumbers, 0, maxOffset + 1);
formats = newFormats;
offsets = newOffsets;
argumentNumbers = newArgumentNumbers;
}
int oldMaxOffset = maxOffset;
maxOffset = offsetNumber;
offsets[offsetNumber] = segments[SEG_RAW].length();
argumentNumbers[offsetNumber] = argumentNumber;
// now get the format
Format newFormat = null;
if (segments[SEG_TYPE].length() != 0) {
int type = findKeyword(segments[SEG_TYPE], TYPE_KEYWORDS);
switch (type) {
case TYPE_NULL:
// Type "" is allowed. e.g., "{0,}", "{0,,}", and "{0,,#}"
// are treated as "{0}".
break;
case TYPE_NUMBER:
switch (findKeyword(segments[SEG_MODIFIER], NUMBER_MODIFIER_KEYWORDS)) {
case MODIFIER_DEFAULT:
newFormat = NumberFormat.getInstance(locale);
break;
case MODIFIER_CURRENCY:
newFormat = NumberFormat.getCurrencyInstance(locale);
break;
case MODIFIER_PERCENT:
newFormat = NumberFormat.getPercentInstance(locale);
break;
case MODIFIER_INTEGER:
newFormat = NumberFormat.getIntegerInstance(locale);
break;
default: // DecimalFormat pattern
try {
newFormat = new DecimalFormat(segments[SEG_MODIFIER],
DecimalFormatSymbols.getInstance(locale));
} catch (IllegalArgumentException e) {
maxOffset = oldMaxOffset;
throw e;
}
break;
}
break;
case TYPE_DATE:
case TYPE_TIME:
int mod = findKeyword(segments[SEG_MODIFIER], DATE_TIME_MODIFIER_KEYWORDS);
if (mod >= 0 && mod < DATE_TIME_MODIFIER_KEYWORDS.length) {
if (type == TYPE_DATE) {
newFormat = DateFormat.getDateInstance(DATE_TIME_MODIFIERS[mod],
locale);
} else {
newFormat = DateFormat.getTimeInstance(DATE_TIME_MODIFIERS[mod],
locale);
}
} else {
// SimpleDateFormat pattern
try {
newFormat = new SimpleDateFormat(segments[SEG_MODIFIER], locale);
} catch (IllegalArgumentException e) {
maxOffset = oldMaxOffset;
throw e;
}
}
break;
case TYPE_CHOICE:
try {
// ChoiceFormat pattern
newFormat = new ChoiceFormat(segments[SEG_MODIFIER]);
} catch (Exception e) {
maxOffset = oldMaxOffset;
throw new IllegalArgumentException("Choice Pattern incorrect: "
+ segments[SEG_MODIFIER], e);
}
break;
default:
maxOffset = oldMaxOffset;
throw new IllegalArgumentException("unknown format type: " +
segments[SEG_TYPE]);
}
}
formats[offsetNumber] = newFormat;
}
private static final int findKeyword(String s, String[] list) {
for (int i = 0; i < list.length; ++i) {
if (s.equals(list[i]))
return i;
}
// Try trimmed lowercase.
String ls = s.trim().toLowerCase(Locale.ROOT);
if (ls != s) {
for (int i = 0; i < list.length; ++i) {
if (ls.equals(list[i]))
return i;
}
}
return -1;
}
private static final void copyAndFixQuotes(String source, int start, int end,
StringBuilder target) {
boolean quoted = false;
for (int i = start; i < end; ++i) {
char ch = source.charAt(i);
if (ch == '{') {
if (!quoted) {
target.append('\'');
quoted = true;
}
target.append(ch);
} else if (ch == '\'') {
target.append("''");
} else {
if (quoted) {
target.append('\'');
quoted = false;
}
target.append(ch);
}
}
if (quoted) {
target.append('\'');
}
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
in.defaultReadObject();
boolean isValid = maxOffset >= -1
&& formats.length > maxOffset
&& offsets.length > maxOffset
&& argumentNumbers.length > maxOffset;
if (isValid) {
int lastOffset = pattern.length() + 1;
for (int i = maxOffset; i >= 0; --i) {
if ((offsets[i] < 0) || (offsets[i] > lastOffset)) {
isValid = false;
break;
} else {
lastOffset = offsets[i];
}
}
}
if (!isValid) {
throw new InvalidObjectException("Could not reconstruct MessageFormat from corrupt stream.");
}
}
}
Format是用于格式化区域设置敏感信息（如日期，消息和数字）的抽象基类。
Format定义了将区域设置敏感对象格式化为String （ format方法）和用于将String s解析为对象（ parseObject方法）的parseObject 。
通常，格式的parseObject方法必须能够解析其format方法格式化的任何字符串。 但是，这是不可能的例外情况。 例如， format方法可能创建两个相邻的整数，其间没有分隔符，在这种情况下， parseObject无法确定哪个数字属于哪个数字。
| Modifier and Type | Method and Description |
|---|---|
Object | clone() 创建并返回此对象的副本。 |
String | format(Object obj) 格式化一个对象来生成一个字符串。 |
abstract StringBuffer | format(Object obj, StringBuffer toAppendTo, FieldPosition pos) 格式化对象并将生成的文本附加到给定的字符串缓冲区。 |
AttributedCharacterIterator | formatToCharacterIterator(Object obj) 格式化一个对象，生成一个 |
Object | parseObject(String source) 从给定字符串的开头解析文本以产生一个对象。 |
abstract Object | parseObject(String source, ParsePosition pos) 从字符串中解析文本以生成对象。 |
package java.text;
import java.io.Serializable;
public abstract class Format implements Serializable, Cloneable {
private static final long serialVersionUID = -299282585814624189L;
protected Format() {
}
public final String format (Object obj) {
return format(obj, new StringBuffer(), new FieldPosition(0)).toString();
}
public abstract StringBuffer format(Object obj,
StringBuffer toAppendTo,
FieldPosition pos);
public AttributedCharacterIterator formatToCharacterIterator(Object obj) {
return createAttributedCharacterIterator(format(obj));
}
public abstract Object parseObject (String source, ParsePosition pos);
public Object parseObject(String source) throws ParseException {
ParsePosition pos = new ParsePosition(0);
Object result = parseObject(source, pos);
if (pos.index == 0) {
throw new ParseException("Format.parseObject(String) failed",
pos.errorIndex);
}
return result;
}
public Object clone() {
try {
return super.clone();
} catch (CloneNotSupportedException e) {
// will never happen
throw new InternalError(e);
}
}
AttributedCharacterIterator createAttributedCharacterIterator(String s) {
AttributedString as = new AttributedString(s);
return as.getIterator();
}
AttributedCharacterIterator createAttributedCharacterIterator(
AttributedCharacterIterator[] iterators) {
AttributedString as = new AttributedString(iterators);
return as.getIterator();
}
AttributedCharacterIterator createAttributedCharacterIterator(
String string, AttributedCharacterIterator.Attribute key,
Object value) {
AttributedString as = new AttributedString(string);
as.addAttribute(key, value);
return as.getIterator();
}
AttributedCharacterIterator createAttributedCharacterIterator(
AttributedCharacterIterator iterator,
AttributedCharacterIterator.Attribute key, Object value) {
AttributedString as = new AttributedString(iterator);
as.addAttribute(key, value);
return as.getIterator();
}
public static class Field extends AttributedCharacterIterator.Attribute {
// Proclaim serial compatibility with 1.4 FCS
private static final long serialVersionUID = 276966692217360283L;
/**
* Creates a Field with the specified name.
*
* @param name Name of the attribute
*/
protected Field(String name) {
super(name);
}
}
interface FieldDelegate {
public void formatted(Format.Field attr, Object value, int start,
int end, StringBuffer buffer);
public void formatted(int fieldID, Format.Field attr, Object value,
int start, int end, StringBuffer buffer);
}
}
FieldPosition是由Format及其子类使用的简单类，用于标识格式化输出中的字段。 可以通过两种方式识别字段：
FieldPosition使用两个索引来跟踪格式化输出中的字段的位置：字段的第一个字符的索引和字段的最后一个字符的索引。
各种Format类中的format方法的一个版本需要一个FieldPosition对象作为参数。 您可以使用此format方法执行部分格式化或获取有关格式化输出的信息（例如字段的位置）。
一个整数常数，其名称通常以_FIELD 。 的常量在的不同子类中定义的Format 。
由Format.Field常数，见ERA_FIELD及其朋友在DateFormat为例。
| Modifier and Type | Method and Description |
|---|---|
boolean | equals(Object obj) 覆盖等于 |
int | getBeginIndex() 检索请求字段中第一个字符的索引。 |
int | getEndIndex() 检索请求字段中最后一个字符后的字符索引。 |
int | getField() 检索字段标识符。 |
Format.Field | getFieldAttribute() 从 |
int | hashCode() 返回此FieldPosition的哈希码。 |
void | setBeginIndex(int bi) 设置开始索引。 |
void | setEndIndex(int ei) 设置结束索引。 |
String | toString() 返回此FieldPosition的字符串表示形式。 |
package java.text;
public class FieldPosition {
int field = 0;
int endIndex = 0;
int beginIndex = 0;
private Format.Field attribute;
public FieldPosition(int field) {
this.field = field;
}
public FieldPosition(Format.Field attribute) {
this(attribute, -1);
}
public FieldPosition(Format.Field attribute, int fieldID) {
this.attribute = attribute;
this.field = fieldID;
}
public Format.Field getFieldAttribute() {
return attribute;
}
public int getField() {
return field;
}
public int getEndIndex() {
return endIndex;
}
public void setBeginIndex(int bi) {
beginIndex = bi;
}
public void setEndIndex(int ei) {
endIndex = ei;
}
Format.FieldDelegate getFieldDelegate() {
return new Delegate();
}
public boolean equals(Object obj)
{
if (obj == null) return false;
if (!(obj instanceof FieldPosition))
return false;
FieldPosition other = (FieldPosition) obj;
if (attribute == null) {
if (other.attribute != null) {
return false;
}
}
else if (!attribute.equals(other.attribute)) {
return false;
}
return (beginIndex == other.beginIndex
&& endIndex == other.endIndex
&& field == other.field);
}
public int hashCode() {
return (field << 24) | (beginIndex << 16) | endIndex;
}
public String toString() {
return getClass().getName() +
"[field=" + field + ",attribute=" + attribute +
",beginIndex=" + beginIndex +
",endIndex=" + endIndex + ']';
}
private boolean matchesField(Format.Field attribute) {
if (this.attribute != null) {
return this.attribute.equals(attribute);
}
return false;
}
private boolean matchesField(Format.Field attribute, int field) {
if (this.attribute != null) {
return this.attribute.equals(attribute);
}
return (field == this.field);
}
private class Delegate implements Format.FieldDelegate {
private boolean encounteredField;
public void formatted(Format.Field attr, Object value, int start,
int end, StringBuffer buffer) {
if (!encounteredField && matchesField(attr)) {
setBeginIndex(start);
setEndIndex(end);
encounteredField = (start != end);
}
}
public void formatted(int fieldID, Format.Field attr, Object value,
int start, int end, StringBuffer buffer) {
if (!encounteredField && matchesField(attr, fieldID)) {
setBeginIndex(start);
setEndIndex(end);
encounteredField = (start != end);
}
}
}
}
AttributedCharacterIterator允许通过文本和相关属性信息进行迭代。
属性是由键标识的键/值对。 给定字符上没有两个属性可以具有相同的键。
属性的值是不可变的，不能被客户机或存储设备突变。 它们总是通过引用传递，而不是被克隆。
关于属性的运行是一个最大文本范围：
相对于一组属性的运行是每个成员属性满足此条件的最大文本范围。
当获得没有指定明确属性的运行（即调用getRunStart()和getRunLimit() ）时，具有相同属性（同一组属性/值对）的任何连续文本段被视为单独的运行，如果属性已经被赋予了这些文本段分开。
返回的索引仅限于迭代器的范围。
返回的属性信息仅限于包含当前字符的运行。
属性为undefined或null为整个范围，或
属性值被定义并且具有与整个范围相同的非null值。
| Modifier and Type | Method and Description |
|---|---|
Set<AttributedCharacterIterator.Attribute> | getAllAttributeKeys() 返回在迭代器的文本范围上定义的所有属性的关键字。 |
Object | getAttribute(AttributedCharacterIterator.Attribute attribute) 返回当前字符的命名为 |
Map<AttributedCharacterIterator.Attribute,Object> | getAttributes() 返回当前字符中定义的属性的地图。 |
int | getRunLimit() 相对于包含当前字符的所有属性返回运行后第一个字符的索引。 |
int | getRunLimit(AttributedCharacterIterator.Attribute attribute) 相对于包含当前字符的给定 |
int | getRunLimit(Set<? extends AttributedCharacterIterator.Attribute> attributes) 相对于包含当前字符的给定 |
int | getRunStart() 相对于包含当前字符的所有属性返回运行的第一个字符的索引。 |
int | getRunStart(AttributedCharacterIterator.Attribute attribute) 相对于包含当前字符的给定 |
int | getRunStart(Set<? extends AttributedCharacterIterator.Attribute> attributes) 相对于包含当前字符的给定 |
package java.text;
import java.io.InvalidObjectException;
import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public interface AttributedCharacterIterator extends CharacterIterator {
public static class Attribute implements Serializable {
private String name;
// table of all instances in this class, used by readResolve
private static final Map<String, Attribute> instanceMap = new HashMap<>(7);
protected Attribute(String name) {
this.name = name;
if (this.getClass() == Attribute.class) {
instanceMap.put(name, this);
}
}
public final boolean equals(Object obj) {
return super.equals(obj);
}
public final int hashCode() {
return super.hashCode();
}
public String toString() {
return getClass().getName() + "(" + name + ")";
}
protected String getName() {
return name;
}
protected Object readResolve() throws InvalidObjectException {
if (this.getClass() != Attribute.class) {
throw new InvalidObjectException("subclass didn't correctly implement readResolve");
}
Attribute instance = instanceMap.get(getName());
if (instance != null) {
return instance;
} else {
throw new InvalidObjectException("unknown attribute name");
}
}
public static final Attribute LANGUAGE = new Attribute("language");
public static final Attribute READING = new Attribute("reading");
public static final Attribute INPUT_METHOD_SEGMENT = new Attribute("input_method_segment");
private static final long serialVersionUID = -9142742483513960612L;
};
public int getRunStart();
public int getRunStart(Attribute attribute);
public int getRunStart(Set<? extends Attribute> attributes);
public int getRunLimit();
public int getRunLimit(Attribute attribute);
public int getRunLimit(Set<? extends Attribute> attributes);
public Map<Attribute,Object> getAttributes();
public Object getAttribute(Attribute attribute);
public Set<Attribute> getAllAttributeKeys();
};
CharacterIterator 接口定义了一种用于文本双向迭代的协议。 迭代器遍历有界的字符序列。 字符的索引值以getBeginIndex（）返回的值开始，并继续执行getEndIndex（） - 1返回的值。
迭代器保持当前的字符索引，其有效范围是从getBeginIndex（）到getEndIndex（）; 包含值getEndIndex（）以允许处理零长度的文本范围以及出于历史原因。 可以通过调用getIndex（）并通过调用setIndex（），first（）和last（）直接设置当前索引。
方法previous（）和next（）用于迭代。 如果他们移动到从getBeginIndex（）到getEndIndex（）-1的范围之外，他们返回DONE，表示迭代器已经到达序列的末尾。 DONE也由其他方法返回，以指示当前索引超出此范围。
从头到尾遍历文字
public void traverseForward(CharacterIterator iter) { for(char c = iter.first(); c != CharacterIterator.DONE; c = iter.next()) { processChar(c); } }
从头到尾横向移动文字
public void traverseBackward(CharacterIterator iter) { for(char c = iter.last(); c != CharacterIterator.DONE; c = iter.previous()) { processChar(c); } }
从文本中的给定位置向前和向后移动。 此示例中对notBoundary（）的调用表示一些其他停止条件。
public void traverseOut(CharacterIterator iter, int pos) { for (char c = iter.setIndex(pos); c != CharacterIterator.DONE && notBoundary(c); c = iter.next()) { } int end = iter.getIndex(); for (char c = iter.setIndex(pos); c != CharacterIterator.DONE && notBoundary(c); c = iter.previous()) { } int start = iter.getIndex(); processSection(start, end); }
| Modifier and Type | Method and Description |
|---|---|
Object | clone() 创建一个这个迭代器的副本 |
char | current() 获取当前位置的字符（由getIndex（）返回）。 |
char | first() 将位置设置为getBeginIndex（），并返回该位置的字符。 |
int | getBeginIndex() 返回文本的起始索引。 |
int | getEndIndex() 返回文本的结束索引。 |
int | getIndex() 返回当前索引。 |
char | last() 将位置设置为getEndIndex（） - 1（如果文本为空，则为getEndIndex（）），并返回该位置处的字符。 |
char | next() 将迭代器的索引增加1，并返回新索引处的字符。 |
char | previous() 将迭代器的索引减去1，并返回新索引处的字符。 |
char | setIndex(int position) 将位置设置为文本中的指定位置，并返回该字符。 |
package java.text;
public interface CharacterIterator extends Cloneable
{
public static final char DONE = '\uFFFF';
public char first();
public char last();
public char current();
public char next();
public char previous();
public char setIndex(int position);
public int getBeginIndex();
public int getEndIndex();
public int getIndex();
public Object clone();
}
扫一扫
1391
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
