String 源码分析
String 类代表字符序列，Java 中所有的字符串字面量都作为此类的实例。
String 对象是不可变的，它们的值在创建之后就不能改变，因此 String 是线程安全的。
/**
* 用于存储字符的字节数组
*/
@Stable
private final byte[] value;
/**
* 用于对 value 字节数组进行编码的编码标识，支持 LATIN1、UTF16
*/
private final byte coder;
/** 缓存的哈希值 */
private int hash; // Default to 0
/** use serialVersionUID from JDK 1.0.2 for interoperability */
private static final long serialVersionUID = -6849794470754667710L;
/**
* 如果字符串压缩被禁用，则总是使用 UTF16 编码 {@code value} 字节数组。
*
* 是否启用字符串压缩，默认为 true
*/
static final boolean COMPACT_STRINGS;
static {
COMPACT_STRINGS = true;
}
@Native static final byte LATIN1 = 0;
@Native static final byte UTF16 = 1;
/**
* 创建一个空字符串
*/
public String() {
value = "".value;
coder = "".coder;
}
/**
* 基于目标字符数组创建字符串对象
*
* @param value 目标字符数组
*/
public String(char value[]) {
this(value, 0, value.length, null);
}
/**
* 基于目标字符数组的子数组创建字符串对象
*
* @param value 源目标字符数组
* @param offset 起始字符索引，从 0 开始
* @param count 连续截取的字符个数
*/
public String(char value[], int offset, int count) {
this(value, offset, count, rangeCheck(value, offset, count));
}
/**
* 基于指定字节数组的子数组创建字符串实例
*
* @param bytes 需要解码的字节数组
* @param offset 起始字节索引
* @param length 截取的元素个数
* @param charsetName 字符集名称
*/
public String(byte bytes[], int offset, int length, String charsetName)
throws UnsupportedEncodingException {
if (charsetName == null) {
throw new NullPointerException("charsetName");
}
checkBoundsOffCount(offset, length, bytes.length);
// 使用目标字符集解码字节数组
final StringCoding.Result ret =
StringCoding.decode(charsetName, bytes, offset, length);
value = ret.value;
coder = ret.coder;
}
/**
* 基于指定字节数组的子数组创建字符串实例
*
* @param bytes 需要解码的字节数组
* @param offset 起始字节索引
* @param length 截取的元素个数
* @param Charset 字符集
*/
public String(byte bytes[], int offset, int length, Charset charset) {
if (charset == null) {
throw new NullPointerException("charset");
}
checkBoundsOffCount(offset, length, bytes.length);
final StringCoding.Result ret =
StringCoding.decode(charset, bytes, offset, length);
value = ret.value;
coder = ret.coder;
}
/**
* 基于目标字节数组创建字符串实例。
*
* @param bytes 需要解码的字节数组
* @param charsetName 字符集名称
*/
public String(byte bytes[], String charsetName)
throws UnsupportedEncodingException {
this(bytes, 0, bytes.length, charsetName);
}
/**
* 基于目标字节数组创建字符串实例。
*
* @param bytes 需要解码的字节数组
* @param Charset 字符集
*/
public String(byte bytes[], Charset charset) {
this(bytes, 0, bytes.length, charset);
}
/**
* 使用平台默认的字符集解码字节数组，创建字符实例
*
* @param bytes 目标字节数组
*/
public String(byte[] bytes) {
this(bytes, 0, bytes.length);
}
/**
* 返回字符串的长度
*/
@Override
public int length() {
return value.length >> coder();
}
/**
* 字符串是否为空
*/
public boolean isEmpty() {
return value.length == 0;
}
/**
* 获取指定索引处的字符
*
* @param index 目标索引
*/
@Override
public char charAt(int index) {
if (isLatin1()) {
return StringLatin1.charAt(value, index);
} else {
return StringUTF16.charAt(value, index);
}
}
- 读取指定索引处的目标字符的 Unicode 代码点
/**
* 读取指定索引处的目标字符的 Unicode 代码点
*
* @param index 目标索引
* @return
*/
public int codePointAt(int index) {
if (isLatin1()) {
checkIndex(index, value.length);
return value[index] & 0xff;
}
// UTF16 编码的代码点可能占用多个字节
final int length = value.length >> 1;
checkIndex(index, length);
return StringUTF16.codePointAt(value, index, length);
}
/**
* 使用指定的字符集将此字符串编码为字节数组并返回。
*
* @param charsetName 目标字符集名称
*/
public byte[] getBytes(String charsetName)
throws UnsupportedEncodingException {
if (charsetName == null) {
throw new NullPointerException();
}
return StringCoding.encode(charsetName, coder(), value);
}
/**
* 使用指定的字符集将此字符串编码为字节数组并返回。
*
* @param Charset 目标字符集
*/
public byte[] getBytes(Charset charset) {
if (charset == null) {
throw new NullPointerException();
}
return StringCoding.encode(charset, coder(), value);
}
- 使用平台默认的字符集将此字符串编码为字节数组并返回
/**
* 使用平台默认的字符集将此字符串编码为字节数组并返回。
*/
public byte[] getBytes() {
return StringCoding.encode(coder(), value);
}
/**
* 此字符串的内容是否和目标字符串一致
*/
public boolean contentEquals(CharSequence cs) {
// 参数是一个 StringBuffer, StringBuilder
if (cs instanceof AbstractStringBuilder) {
if (cs instanceof StringBuffer) {
synchronized(cs) {
return nonSyncContentEquals((AbstractStringBuilder)cs);
}
} else {
return nonSyncContentEquals((AbstractStringBuilder)cs);
}
}
// 参数是一个 String
if (cs instanceof String) {
return equals(cs);
}
// 参数是一个普通的字符序列 CharSequence
final int n = cs.length();
if (n != length()) {
return false;
}
final byte[] val = value;
if (isLatin1()) {
for (int i = 0; i < n; i++) {
if ((val[i] & 0xff) != cs.charAt(i)) {
return false;
}
}
} else {
if (!StringUTF16.contentEquals(val, cs, n)) {
return false;
}
}
return true;
}
/**
* 将此字符串和目标字符串进行比较，忽略大小写
*/
public boolean equalsIgnoreCase(String anotherString) {
// 先比较长度，再比较内容
return this == anotherString ? true
: anotherString != null
&& anotherString.length() == length()
&& regionMatches(true, 0, anotherString, 0, length());
}
- 此字符串指定索引开始的子字符串是否以 prefix 开头
/**
* 此字符串指定索引开始的子字符串是否以 prefix 开头
*
* @param prefix 前缀
* @param toffset 起始索引
*/
public boolean startsWith(String prefix, int toffset) {
// Note: toffset might be near -1>>>1.
if (toffset < 0 || toffset > length() - prefix.length()) {
return false;
}
final byte ta[] = value;
final byte pa[] = prefix.value;
int po = 0;
final int pc = pa.length;
if (coder() == prefix.coder()) {
int to = isLatin1() ? toffset : toffset << 1;
while (po < pc) {
if (ta[to++] != pa[po++]) {
return false;
}
}
} else {
if (isLatin1()) { // && pcoder == UTF16
return false;
}
// coder == UTF16 && pcoder == LATIN1)
while (po < pc) {
if (StringUTF16.getChar(ta, toffset++) != (pa[po++] & 0xff)) {
return false;
}
}
}
return true;
}
/**
* 此字符串是否以指定的前缀开头
*
* @param prefix 目标前缀
*/
public boolean startsWith(String prefix) {
return startsWith(prefix, 0);
}
/**
* 此字符串是否以指定的后缀结尾
*
* @param suffix 目标后缀
*/
public boolean endsWith(String suffix) {
return startsWith(suffix, length() - suffix.length());
}
/**
* 指定字符在此字符串中第一次出现的索引
*
* @param ch 目标字符
*/
public int indexOf(int ch) {
return indexOf(ch, 0);
}
/**
* 从 fromIndex 开始，指定字符在此字符串中第一次出现的索引
*
* @param ch 目标字符
* @param fromIndex 查找的起始索引
*/
public int indexOf(int ch, int fromIndex) {
return isLatin1() ? StringLatin1.indexOf(value, ch, fromIndex)
: StringUTF16.indexOf(value, ch, fromIndex);
}
/**
* 目标字符在此字符串中最后一次出现的索引
*
* @param ch 目标字符
*/
public int lastIndexOf(int ch) {
return lastIndexOf(ch, length() - 1);
}
/**
* 从 fromIndex 开始，目标字符在此字符串中最后一次出现的索引
*
* @param ch 目标字符
* @param fromIndex 查找的起始索引
*/
public int lastIndexOf(int ch, int fromIndex) {
return isLatin1() ? StringLatin1.lastIndexOf(value, ch, fromIndex)
: StringUTF16.lastIndexOf(value, ch, fromIndex);
}
/**
* 目标字符串 str 在此字符串中的起始索引
*
* @param str 目标字符串
*/
public int indexOf(String str) {
if (coder() == str.coder()) {
return isLatin1() ? StringLatin1.indexOf(value, str.value)
: StringUTF16.indexOf(value, str.value);
}
if (coder() == LATIN1) { // str.coder == UTF16
return -1;
}
return StringUTF16.indexOfLatin1(value, str.value);
}
/**
* 从起始索引 fromIndex 开始，目标字符串 str 在此字符串中的起始索引
*
* @param str 目标字符串
* @param fromIndex 查找的起始索引
*/
public int indexOf(String str, int fromIndex) {
return indexOf(value, coder(), length(), str, fromIndex);
}
- 目标字符串 str 在此字符串中最后一次出现的索引
/**
* 目标字符串 str 在此字符串中最后一次出现的索引
*
* @param str 目标字符串
*/
public int lastIndexOf(String str) {
return lastIndexOf(str, length());
}
/**
* 从起始索引 fromIndex 开始，目标字符串 str 在此字符串中最后一次出现的索引
*
* @param str 目标字符串
* @param fromIndex 查找的起始索引
*/
public int lastIndexOf(String str, int fromIndex) {
return lastIndexOf(value, coder(), length(), str, fromIndex);
}
- 截取此字符串指定索引 beginIndex 处开始到尾部的子字符串
/**
* 截取此字符串指定索引 beginIndex 处开始到尾部的子字符串
*
* @param beginIndex 截取的起始索引
*/
public String substring(int beginIndex) {
// 1）起始索引为负数
if (beginIndex < 0) {
throw new StringIndexOutOfBoundsException(beginIndex);
}
final int subLen = length() - beginIndex;
// 2）起始索引超出最大索引
if (subLen < 0) {
throw new StringIndexOutOfBoundsException(subLen);
}
// 3）起始索引为 0
if (beginIndex == 0) {
return this;
}
// 4）截取子字符串
return isLatin1() ? StringLatin1.newString(value, beginIndex, subLen)
: StringUTF16.newString(value, beginIndex, subLen);
}
- 截取起始索引和结束索引之间的子字符串，包括起始索引，但不包括结束索引
/**
* 截取起始索引 beginIndex 和结束索引 endIndex 之间的子字符串，包括起始索引，但不包括结束索引
*
* @param beginIndex 起始索引【包含】
* @param endIndex 结束索引【不包含】
*/
public String substring(int beginIndex, int endIndex) {
final int length = length();
// 1）索引非法
checkBoundsBeginEnd(beginIndex, endIndex, length);
final int subLen = endIndex - beginIndex;
// 2）特殊情况
if (beginIndex == 0 && endIndex == length) {
return this;
}
// 3）截取子字符串
return isLatin1() ? StringLatin1.newString(value, beginIndex, subLen)
: StringUTF16.newString(value, beginIndex, subLen);
}
/**
* 将目标字符串 str 连接到此字符串的尾部
*
* @param str 目标字符串
*/
public String concat(String str) {
final int olen = str.length();
// 1）目标字符串为空
if (olen == 0) {
return this;
}
// 2）编码方式相同，则直接进行字符数组拷贝
if (coder() == str.coder()) {
final byte[] val = value;
final byte[] oval = str.value;
final int len = val.length + oval.length;
final byte[] buf = Arrays.copyOf(val, len);
System.arraycopy(oval, 0, buf, val.length, oval.length);
return new String(buf, coder);
}
// 3）将两个字符解码并拷贝到目标字节数组中
final int len = length();
final byte[] buf = StringUTF16.newBytesFor(len + olen);
getBytes(buf, 0, UTF16);
str.getBytes(buf, len, UTF16);
return new String(buf, UTF16);
}
- 将此字符串中所有的 oldChar 字符，替换为 newChar 字符
/**
* 将此字符串中所有的 oldChar 字符，替换为 newChar 字符
*
* @param oldChar 旧字符
* @param newChar 新字符
*/
public String replace(char oldChar, char newChar) {
if (oldChar != newChar) {
final String ret = isLatin1() ? StringLatin1.replace(value, oldChar, newChar)
: StringUTF16.replace(value, oldChar, newChar);
if (ret != null) {
return ret;
}
}
return this;
}
/**
* 此字符串是否匹配目标正则表达式 regex
*
* @param regex 目标正则表达式
*/
public boolean matches(String regex) {
return Pattern.matches(regex, this);
}
/**
* 此字符串是否包含目标字符序列 s
*
* @param s 待搜索的目标字符序列
*/
public boolean contains(CharSequence s) {
return indexOf(s.toString()) >= 0;
}
- 将第一个匹配指定正则表达式 regex 的子字符串替换为 replacement
/**
* 将第一个匹配指定正则表达式 regex 的子字符串替换为 replacement
*
* @param regex 目标正则表达式
* @param replacement 替换字符串
*/
public String replaceFirst(String regex, String replacement) {
return Pattern.compile(regex).matcher(this).replaceFirst(replacement);
}
- 将所有匹配指定正则表达式 regex 的子字符串替换为 replacement
/**
* 将所有匹配指定正则表达式 regex 的子字符串替换为 replacement
*
* @param regex 目标正则表达式
* @param replacement 替换字符串
*/
public String replaceAll(String regex, String replacement) {
return Pattern.compile(regex).matcher(this).replaceAll(replacement);
}
- 将此字符串中所有的子字符串 target 替换为目标字符串 replacement
/**
* 将此字符串中所有的子字符串 target 替换为目标字符串 replacement
*
* @param target 待替换字符串
* @param replacement 替换字符串
*/
public String replace(CharSequence target, CharSequence replacement) {
final String tgtStr = target.toString();
final String replStr = replacement.toString();
int j = indexOf(tgtStr);
if (j < 0) {
return this;
}
final int tgtLen = tgtStr.length();
final int tgtLen1 = Math.max(tgtLen, 1);
final int thisLen = length();
final int newLenHint = thisLen - tgtLen + replStr.length();
if (newLenHint < 0) {
throw new OutOfMemoryError();
}
final StringBuilder sb = new StringBuilder(newLenHint);
int i = 0;
do {
sb.append(this, i, j).append(replStr);
i = j + tgtLen;
} while (j < thisLen && (j = indexOf(tgtStr, j + tgtLen1)) > 0);
return sb.append(this, i, thisLen).toString();
}
- 使用指定的正则表达式 regex 将此字符串分割为字符串数组
/**
* 使用指定的正则表达式 regex 将此字符串分割为字符串数组
*
* @param regex 目标正则表达式
* @param limit 字符串数组的最大长度
*/
public String[] split(String regex, int limit) {
/* fastpath if the regex is a
(1)one-char String and this character is not one of the
RegEx's meta characters ".$|()[{^?*+\", or
(2)two-char String and the first char is the backslash and
the second is not the ascii digit or ascii letter.
*/
char ch = 0;
if ((regex.length() == 1 &&
".$|()[{^?*+\".indexOf(ch = regex.charAt(0)) == -1 ||
regex.length() == 2 &&
regex.charAt(0) == '\' &&
((ch = regex.charAt(1))-'0'|'9'-ch) < 0 &&
(ch-'a'|'z'-ch) < 0 &&
(ch-'A'|'Z'-ch) < 0) &&
(ch < Character.MIN_HIGH_SURROGATE ||
ch > Character.MAX_LOW_SURROGATE))
{
int off = 0;
int next = 0;
final boolean limited = limit > 0;
final ArrayList<String> list = new ArrayList<>();
while ((next = indexOf(ch, off)) != -1) {
if (!limited || list.size() < limit - 1) {
list.add(substring(off, next));
off = next + 1;
} else { // last one
//assert (list.size() == limit - 1);
final int last = length();
list.add(substring(off, last));
off = last;
break;
}
}
// If no match was found, return this
if (off == 0) {
return new String[]{this};
}
// Add remaining segment
if (!limited || list.size() < limit) {
list.add(substring(off, length()));
}
// Construct result
int resultSize = list.size();
if (limit == 0) {
while (resultSize > 0 && list.get(resultSize - 1).length() == 0) {
resultSize--;
}
}
final String[] result = new String[resultSize];
return list.subList(0, resultSize).toArray(result);
}
return Pattern.compile(regex).split(this, limit);
}
/**
* 使用指定的正则表达式 regex 将此字符串分割为字符串数组
*
* @param regex 目标正则表达式
*/
public String[] split(String regex) {
return split(regex, 0);
}
- 使用指定的连接符 delimiter 顺序连接可变目标字符序列数组 elements 的所有元素
/**
* 使用指定的连接符 delimiter 顺序连接可变目标字符序列数组 elements 的所有元素
*/
public static String join(CharSequence delimiter, CharSequence... elements) {
Objects.requireNonNull(delimiter);
Objects.requireNonNull(elements);
// Number of elements not likely worth Arrays.stream overhead.
final StringJoiner joiner = new StringJoiner(delimiter);
for (final CharSequence cs: elements) {
joiner.add(cs);
}
return joiner.toString();
}
- 使用指定的连接符 delimiter 顺序连接迭代器中的所有字符序列
/**
* 使用指定的连接符 delimiter 顺序连接迭代器中的所有字符序列
*/
public static String join(CharSequence delimiter,
Iterable<? extends CharSequence> elements) {
Objects.requireNonNull(delimiter);
Objects.requireNonNull(elements);
final StringJoiner joiner = new StringJoiner(delimiter);
for (final CharSequence cs: elements) {
joiner.add(cs);
}
return joiner.toString();
}
- 使用指定的区域将此字符串的所有字符都转换为小写字符
/**
* 使用指定的区域将此字符串的所有字符都转换为小写字符
*
* @param locale 目标区域
*/
public String toLowerCase(Locale locale) {
return isLatin1() ? StringLatin1.toLowerCase(this, value, locale)
: StringUTF16.toLowerCase(this, value, locale);
}
/**
* 使用默认的区域将此字符串的所有字符都转换为小写字符
*/
public String toLowerCase() {
return toLowerCase(Locale.getDefault());
}
- 使用指定的区域将此字符串的所有字符都转换为大写字符
/**
* 使用指定的区域将此字符串的所有字符都转换为大写字符
*
* @param locale 目标区域
*/
public String toUpperCase(Locale locale) {
return isLatin1() ? StringLatin1.toUpperCase(this, value, locale)
: StringUTF16.toUpperCase(this, value, locale);
}
/**
* 使用默认的区域将此字符串的所有字符都转换为大写字符
*/
public String toUpperCase() {
return toUpperCase(Locale.getDefault());
}
/**
* 移除此字符串前后的所有空白符
*/
public String trim() {
final String ret = isLatin1() ? StringLatin1.trim(value)
: StringUTF16.trim(value);
return ret == null ? this : ret;
}
/**
* 基于此字符串的所有字符创建整形流
* @since 9
*/
@Override
public IntStream chars() {
return StreamSupport.intStream(
isLatin1() ? new StringLatin1.CharsSpliterator(value, Spliterator.IMMUTABLE)
: new StringUTF16.CharsSpliterator(value, Spliterator.IMMUTABLE),
false);
}
- 基于此字符串的所有 Unicode 代码点创建整形流
/**
* 基于此字符串的所有 Unicode 代码点创建整形流
* @since 9
*/
@Override
public IntStream codePoints() {
return StreamSupport.intStream(
isLatin1() ? new StringLatin1.CharsSpliterator(value, Spliterator.IMMUTABLE)
: new StringUTF16.CodePointsSpliterator(value, Spliterator.IMMUTABLE),
false);
}
/**
* 将此字符串转换为字符数组
*/
public char[] toCharArray() {
return isLatin1() ? StringLatin1.toChars(value)
: StringUTF16.toChars(value);
}
- 使用指定的参数列表 args 格式化目标字符串 format
/**
* 使用指定的参数列表 args 格式化目标字符串 format
*/
public static String format(String format, Object... args) {
return new Formatter().format(format, args).toString();
}
/**
* 将目标对象 obj 转换为字符串
*
* @param obj 目标对象
*/
public static String valueOf(Object obj) {
return obj == null ? "null" : obj.toString();
}
- 返回此字符串的规范表示形式，将此字符串加入由 String 类管理的字符串常量池中，所有的字符串字面量和字符串常量都缓存在字符串常量池中。
public native String intern();