深入学习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本身不实现区域设置特定的行为。 任何特定于语言环境的行为都由您提供的模式以及用于插入参数的子格式定义。
voidapplyPattern(String pattern) 设置此消息格式使用的模式。
Objectclone() 创建并返回此对象的副本。
booleanequals(Object obj) 两个消息格式对象之间的平等比较
StringBufferformat(Object[] arguments, StringBuffer result, FieldPosition pos) 格式化一个对象数组，并将 MessageFormat的格式（格式化元素替换为格式化对象）附加到提供的 StringBuffer 。
StringBufferformat(Object arguments, StringBuffer result, FieldPosition pos) 格式化一组对象，并将 MessageFormat的格式（格式化元素替换为格式化对象）附加到提供的 StringBuffer 。
static Stringformat(String pattern, Object... arguments) 使用给定的模式创建一个MessageFormat，并使用它来格式化给定的参数。
AttributedCharacterIteratorformatToCharacterIterator(Object arguments) 格式化一组对象，并将它们插入到 MessageFormat的模式中，生成一个 AttributedCharacterIterator 。
Format[]getFormats() 获取用于先前设置的模式字符串中的格式元素的格式。
Format[]getFormatsByArgumentIndex() 获取用于传递到 format方法的值或从 parse方法返回的 parse 。
LocalegetLocale() 获取创建或比较子格式时使用的区域设置。
inthashCode() 生成消息格式对象的哈希码。
Object[]parse(String source) 从给定字符串的开头解析文本以产生一个对象数组。
Object[]parse(String source, ParsePosition pos) 解析字符串。
ObjectparseObject(String source, ParsePosition pos) 从字符串中解析文本以生成对象数组。
voidsetFormat(int formatElementIndex, Format newFormat) 设置在先前设置的模式字符串中使用具有给定格式元素索引的格式元素的格式。
voidsetFormatByArgumentIndex(int argumentIndex, Format newFormat) 设置使用给定参数索引的先前设置的模式字符串中的格式元素的格式。
voidsetFormats(Format[] newFormats) 设置用于先前设置的模式字符串中的格式元素的格式。
voidsetFormatsByArgumentIndex(Format[] newFormats) 设置用于传递到 format方法的值或从 parse方法返回的 parse 。
voidsetLocale(Locale locale) 设置创建或比较子格式时要使用的区域设置。
StringtoPattern() 返回表示消息格式的当前状态的模式。
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 = 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 + 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 (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无法确定哪个数字属于哪个数字。
Objectclone() 创建并返回此对象的副本。
Stringformat(Object obj) 格式化一个对象来生成一个字符串。
abstract StringBufferformat(Object obj, StringBuffer toAppendTo, FieldPosition pos) 格式化对象并将生成的文本附加到给定的字符串缓冲区。
AttributedCharacterIteratorformatToCharacterIterator(Object obj) 格式化一个对象，生成一个 AttributedCharacterIterator 。
ObjectparseObject(String source) 从给定字符串的开头解析文本以产生一个对象。
abstract ObjectparseObject(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为例。
booleanequals(Object obj) 覆盖等于
intgetBeginIndex() 检索请求字段中第一个字符的索引。
intgetEndIndex() 检索请求字段中最后一个字符后的字符索引。
intgetField() 检索字段标识符。
Format.FieldgetFieldAttribute() 从 Field子类之一返回字段标识符作为属性常量。
inthashCode() 返回此FieldPosition的哈希码。
voidsetBeginIndex(int bi) 设置开始索引。
voidsetEndIndex(int ei) 设置结束索引。
StringtoString() 返回此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
关注
打赏
![]()
1665965058
查看更多评论
最近更新
- 深拷贝和浅拷贝的区别（重点）
- 【Vue】走进Vue框架世界
- 【云服务器】项目部署—搭建网站—vue电商后台管理系统
- 【React介绍】 一文带你深入React
- 【React】React组件实例的三大属性之state，props，refs（你学废了吗）
- 【脚手架VueCLI】从零开始，创建一个VUE项目
- 【React】深入理解React组件生命周期----图文详解（含代码）
- 【React】DOM的Diffing算法是什么？以及DOM中key的作用----经典面试题
- 【React】1_使用React脚手架创建项目步骤--------详解(含项目结构说明)
- 【React】2_如何使用react脚手架写一个简单的页面？
