java源码分析-String类源码概要
1.简介
String类是我们java程序员使用频率非常大的类，我们都知道String类是不可变类，一旦定义就不可改变，那么它为什么不可变呢？它的内部做了什么处理呢？今天我们就好好研究一下String类。
先上源码：
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence通过上面我们能知道：
- String类被final修饰，所以是不可变类，或者说没有子类实现；
- 实现Serializable接口，表示该类可以序列化；序列化的目的是将一个实现了Serializable接口的对象可以转换成一个字节序列，保存对象的状态。
- 实现了Comparable接口，表示该实现类的对象会被整体排序（自然排序），实现Comparable接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自然排序。
- 实现了CharSequence接口，此接口是char值的一个可读序列，它对许多不同种类的char序列提供统一的制度访问。
2.重要属性
/** The value is used for character storage. */
private final char value[];用于存储字符串的字符数组，同样被final修饰，一旦创建就不可以被修改。
/** Cache the hash code for the string */
private int hash; // Default to 0String的hash值是一个int类型的数值，表示一个4字节32位的数据，默认值为0，具体的计算方法见hashCode()方法；
static final boolean COMPACT_STRINGS;COMPACT_STRINGS是字符串压缩标识，默认情况下，String是可压缩的。
在静态代码块中
static {
COMPACT_STRINGS = true;
}表示String可压缩。而该字段的值是由jvm传入。
3.构造函数
String的构造函数有多个，截图如下：
3.1使用字符串构造
/**
* Initializes a newly created {@code String} object so that it represents
* the same sequence of characters as the argument; in other words, the
* newly created string is a copy of the argument string. Unless an
* explicit copy of {@code original} is needed, use of this constructor is
* unnecessary since Strings are immutable.
*
* @param original
* A {@code String}
*/
public String(String original) {
this.value = original.value;
this.hash = original.hash;
}直接将实参字符串originall的value和hash值传给目标String，来构建一个新的String对象。简单说明，新创建的字符串是实参字符串的副本。
3.2使用数组构造
/**
* Allocates a new {@code String} so that it represents the sequence of
* characters currently contained in the character array argument. The
* contents of the character array are copied; subsequent modification of
* the character array does not affect the newly created string.
*
* @param value
* The initial value of the string
*/
public String(char value[]) {
this.value = Arrays.copyOf(value, value.length);
}通过拷贝字符数组中的值来生成一个新的String对象，后续实参字符数组中的改变不会影响新创建的字符串；
public static char[] copyOf(char[] original, int newLength) {
char[] copy = new char[newLength];//这里是创建了新的char数组
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}3.3使用字节数组构造
/**
* Constructs a new {@code String} by decoding the specified array of bytes
* using the platform's default charset. The length of the new {@code
* String} is a function of the charset, and hence may not be equal to the
* length of the byte array.
*
* <p> The behavior of this constructor when the given bytes are not valid
* in the default charset is unspecified. The {@link
* java.nio.charset.CharsetDecoder} class should be used when more control
* over the decoding process is required.
*
* @param bytes
* The bytes to be decoded into characters
*
* @since JDK1.1
*/
public String(byte bytes[]) {
this(bytes, 0, bytes.length);
}
public String(byte bytes[], int offset, int length) {
checkBounds(bytes, offset, length);
this.value = StringCoding.decode(bytes, offset, length);
}
public String(byte ascii[], int hibyte) {
this(ascii, hibyte, 0, ascii.length);
}
/* Common private utility method used to bounds check the byte array
* and requested offset & length values used by the String(byte[],..)
* constructors.
*/
private static void checkBounds(byte[] bytes, int offset, int length) {
if (length < 0)
throw new StringIndexOutOfBoundsException(length);
if (offset < 0)
throw new StringIndexOutOfBoundsException(offset);
if (offset > bytes.length - length)
throw new StringIndexOutOfBoundsException(offset + length);
}StringCodingstatic char[] decode(byte[] ba, int off, int len) {
String csn = Charset.defaultCharset().name(); //获取编码
try {
// use charset name decode() variant which provides caching.
return decode(csn, ba, off, len); //根据编码进行解码
} catch (UnsupportedEncodingException x) {
warnUnsupportedCharset(csn);
}
try {
return decode("ISO-8859-1", ba, off, len);
} catch (UnsupportedEncodingException x) {
// If this code is hit during VM initialization, MessageUtils is
// the only way we will be able to get any kind of error message.
MessageUtils.err("ISO-8859-1 charset not available: "
+ x.toString());
// If we can not find ISO-8859-1 (a required encoding) then things
// are seriously wrong with the installation.
System.exit(1);
return null;
}
}
static char[] decode(String charsetName, byte[] ba, int off, int len)
throws UnsupportedEncodingException
{
StringDecoder sd = deref(decoder);
String csn = (charsetName == null) ? "ISO-8859-1" : charsetName;
if ((sd == null) || !(csn.equals(sd.requestedCharsetName())
|| csn.equals(sd.charsetName()))) {
sd = null;
try {
Charset cs = lookupCharset(csn);
if (cs != null)
sd = new StringDecoder(cs, csn);
} catch (IllegalCharsetNameException x) {}
if (sd == null)
throw new UnsupportedEncodingException(csn);
set(decoder, sd);
}
return sd.decode(ba, off, len);
}在Java中，String实例中保存有一个char[]字符数组，char[]字符数组是以unicode码来存储的，String 和 char 为内存形式，byte是网络传输或存储的序列化形式。所以在很多传输和存储的过程中需要将byte[]数组和String进行相互转化。所以，String提供了一系列重载的构造方法来将一个字符数组转化成String，提到byte[]和String之间的相互转换就不得不关注编码问题。
String(byte[] bytes, Charset charset) 是指通过charset来解码指定的byte数组，将其解码成unicode的char[]数组，够造成新的String。
- 这里的bytes字节流是使用charset进行编码的，想要将他转换成unicode的char[]数组，而又保证不出现乱码，那就要指定其解码方式。
如果我们在使用byte[]构造String的时候，会使用StringCoding.decode方法进行解码，使用的解码的字符集就是我们指定的charsetName或者charset。 我们在使用byte[]构造String的时候，如果没有指明解码使用的字符集的话，那么StringCoding的decode方法首先调用系统的默认编码格式，如果没有指定编码格式则默认使用ISO-8859-1编码格式进行编码操作。
4.内部类
CaseInsensitiveComparator内部类
public static final Comparator<String> CASE_INSENSITIVE_ORDER
= new CaseInsensitiveComparator();
private static class CaseInsensitiveComparator
implements Comparator<String>, java.io.Serializable {
// use serialVersionUID from JDK 1.2.2 for interoperability
private static final long serialVersionUID = 8575799808933029326L;
public int compare(String s1, String s2) {//比较两个字符串大小。（同时比较了UpperCase和LowerCase，是为了兼容Georgian字符）
int n1 = s1.length();
int n2 = s2.length();
int min = Math.min(n1, n2);
for (int i = 0; i < min; i++) {
char c1 = s1.charAt(i);
char c2 = s2.charAt(i);
if (c1 != c2) { //1.同位字符比较
c1 = Character.toUpperCase(c1);
c2 = Character.toUpperCase(c2);
if (c1 != c2) { //2.全转为转为大写再比较
c1 = Character.toLowerCase(c1);
c2 = Character.toLowerCase(c2);
if (c1 != c2) {//全部转为小写再比较
// No overflow because of numeric promotion
return c1 - c2;
}
}
}
}
return n1 - n2;
}
/** Replaces the de-serialized object. */
private Object readResolve() { return CASE_INSENSITIVE_ORDER; }
}这个内部类主要是用于比较两个字符串的大小。（对大小写不敏感）
这里有人会问，为什么转换为大写之后判断不相等了，怎么还要判断小写，是不是多次一举？
其实不是的，在String类的regionMatches()方法的注释中已经说明了：
public boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) { char ta[] = value; int to = toffset; char pa[] = other.value; int po = ooffset; // Note: toffset, ooffset, or len might be near -1>>>1. if ((ooffset < 0) || (toffset < 0) || (toffset > (long)value.length - len) || (ooffset > (long)other.value.length - len)) { return false; } while (len-- > 0) { char c1 = ta[to++]; char c2 = pa[po++]; if (c1 == c2) { continue; } if (ignoreCase) { // If characters don't match but case may be ignored, // try converting both characters to uppercase. // If the results match, then the comparison scan should // continue. char u1 = Character.toUpperCase(c1); char u2 = Character.toUpperCase(c2); if (u1 == u2) { continue; } // Unfortunately, conversion to uppercase does not work properly // for the Georgian alphabet, which has strange rules about case // conversion. So we need to make one last check before // exiting. //这里已经说明！！！ if (Character.toLowerCase(u1) == Character.toLowerCase(u2)) { continue; } } return false; } return true; }
注释的意思是：转换为大写不能正常工作的Georgian字母表，它有关于大小写转换的奇怪规则。所以我们得在离开前做最后一次检查。
5.常见方法
5.1length方法
该方法用户用去字符串长度。
public int length() {
return value.length;
}String类获取字符串长度实际上就是获取char[]数组中的个数，也就是value的值。
5.2isEmpty方法
判断一个字符串是否为空字符串，也就是""。
public boolean isEmpty() {
return value.length == 0;
}通过判断value的值是否为0，也就是char[]数组长度是否为0.
5.3charAt方法
该方法是获取指定下标处的字符。
public char charAt(int index) {
if ((index < 0) || (index >= value.length)) {
throw new StringIndexOutOfBoundsException(index);
}
return value[index];
}通过获取char数组的指定下边的元素。
5.4codePoint方法
该方法是获取某个下标字符的编码值。
public int codePointAt(int index) {
if ((index < 0) || (index >= value.length)) {
throw new StringIndexOutOfBoundsException(index);
}
return Character.codePointAtImpl(value, index, value.length);
}
//---------------------Character---------------------------------
static int codePointAtImpl(char[] a, int index, int limit) {
char c1 = a[index];
if (isHighSurrogate(c1) && ++index < limit) {
char c2 = a[index];
if (isLowSurrogate(c2)) {
return toCodePoint(c1, c2);
}
}
return c1;
}
public static int toCodePoint(char high, char low) {
// Optimized form of:
// return ((high - MIN_HIGH_SURROGATE) << 10)
// + (low - MIN_LOW_SURROGATE)
// + MIN_SUPPLEMENTARY_CODE_POINT;
return ((high << 10) + low) + (MIN_SUPPLEMENTARY_CODE_POINT
- (MIN_HIGH_SURROGATE << 10)
- MIN_LOW_SURROGATE);
}5.5getChars
该方法用于拷贝字符串。
void getChars(char dst[], int dstBegin) {
System.arraycopy(value, 0, dst, dstBegin, value.length);
}
public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {
if (srcBegin < 0) {
throw new StringIndexOutOfBoundsException(srcBegin);
}
if (srcEnd > value.length) {
throw new StringIndexOutOfBoundsException(srcEnd);
}
if (srcBegin > srcEnd) {
throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);
}
System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
}这个方法是将调用者字符串的第srcBegin开始，到srcEnd结束的字符拷贝到char[]数组中，从dstBegin开始替换。
String str = "abc";
char[] endCh = {'1', '2', '3'};
str.getChars(1, 2, endCh, 0);
System.out.println(endCh);查看结果：
5.6concat方法
该方法用于拼接字符串。
public String concat(String str) { //拼接字符串
int otherLen = str.length(); //获取待拼接字符串长度
if (otherLen == 0) {
return this;
}
int len = value.length; //获取原字符串长度
char buf[] = Arrays.copyOf(value, len + otherLen);//使用拷贝的方式，创建新的char数组，并赋值
str.getChars(buf, len); //相当于将参数字符串拷贝到原字符串尾部，返回字符数组
return new String(buf, true);//通过字符数组创建String对象返回
}5.7getBytes方法
public byte[] getBytes(String charsetName)
throws UnsupportedEncodingException {
if (charsetName == null) throw new NullPointerException();
return StringCoding.encode(charsetName, value, 0, value.length);
}
public byte[] getBytes(Charset charset) {
if (charset == null) throw new NullPointerException();
return StringCoding.encode(charset, value, 0, value.length);
}
public byte[] getBytes() {
return StringCoding.encode(value, 0, value.length);
}三个方法都是用来获取某个字符串中每个字符的byte值。有参数的是根据指定编码进行解码后转为byte，无参数的是根据默认编码进行解码后转换。
5.8split
该方法用于分割字符串。
public String[] split(String regex) {
return split(regex, 0);
}
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.value.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;
boolean limited = limit > 0;
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);
list.add(substring(off, value.length));
off = value.length;
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, value.length));
// Construct result
int resultSize = list.size();
if (limit == 0) {
while (resultSize > 0 && list.get(resultSize - 1).length() == 0) {
resultSize--;
}
}
String[] result = new String[resultSize];
return list.subList(0, resultSize).toArray(result);
}
return Pattern.compile(regex).split(this, limit);
}
