（一）前言
我在阅读一个类的时候习惯把一个类剖析为以下五个部分，因此我在阅读或者写博客的时候都是按照这个思路进行的：
1.类定义
2.属性字段
3.构造方法
4.普通方法
5.更多扩展
String类同样是lang包下的一个类，也是我们编程中最经常使用的一个类，了解它的内部构造则显得尤其重要。
（二）类定义
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence{ }
我们先来看看它实现的这三个接口的作用：
- java.io.Serializable：可被序列化的标志接口
- Comparable：作用是比较两个字符串的大小（按顺序比较单个字符的ASCII码）
- CharSequence：用来表示一个有序字符的集合
我们看到它是一个被final修饰的常量类，常量类的特性为不可被任何类所继承，一旦String对象被创建，该对象是无法被改变的，直至该对象被销毁（特殊情况除外：如暴力反射，文末讲解）。
（三）字段属性
/** The value is used for character storage.（存储字段串） */
private final char value[];
/** Cache the hash code for the string（缓存哈希值） */
private int hash; // Default to 0
/** use serialVersionUID from JDK 1.0.2 for interoperability（用于序列化和反序列化之间的ID比对） */
private static final long serialVersionUID = -6849794470754667710L;
从上面的第一个字段属性我们可以看出，字符串内部是拿字符数组进行存储的，一个String字符串就是一个cahr数组。
（四）构造方法
我们可以看到String类的构造方法非常之多，可以通过传入一个字符串，字符数组，字节数组等等来初始化一个String对象，这里不过多的赘述。
（五）equals(Object anObject)方法
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = value.length;
if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
while (n-- != 0) {
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}
String类里重写了Object里的equals方法，首先比较对象地址判断是否是两个相等的对象，若不相等再通过instanceof关键字比对传入对象是否是String的实例，若是则一一比对字符串的每一个字符。
（六）hashCode()方法
public int hashCode() {
int h = hash;
if (h == 0 && value.length > 0) {
char val[] = value;
for (int i = 0; i < value.length; i++) {
h = 31 * h + val[i];
}
hash = h;
}
return h;
}
String类的hashCode算法很简单，但是这里面涉及到一个很有趣的问题，为什么使用数字31作为乘数，有兴趣的可以看看这篇文章了解了解。
（七）charAt(int index) 方法
public char charAt(int index) {
if ((index < 0) || (index >= value.length)) {
throw new StringIndexOutOfBoundsException(index);
}
return value[index];
}
该方法的作用是得到字符串的指定索引位置的字符元素。
（八）compareTo(String anotherString)方法
public int compareTo(String anotherString) {
int len1 = value.length;
int len2 = anotherString.value.length;
int lim = Math.min(len1, len2);
char v1[] = value;
char v2[] = anotherString.value;
int k = 0;
while (k < lim) {
char c1 = v1[k];
char c2 = v2[k];
if (c1 != c2) {
return c1 - c2;
}
k++;
}
return len1 - len2;
}
该方法是按字母顺序比较两个字符串中每个字符的 Unicode 值，当两个字符串某个位置的字符不同时，返回的是这一位置的字符 Unicode 值之差，当两个字符串都相同时，返回两个字符串长度之差。
此外还有个compareToIgnoreCase()方法，该方法是在 compareTo() 方法的基础上忽略大小写。
（九）concat(String str)方法
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);
str.getChars(buf, len);
return new String(buf, true);
}
该方法的作用的将指定字符串拼接到原字符串末尾，首先判断要拼接字符串长度，若长度为0则返回原字符串，不为0则利用工具类Arrays中的静态方法copyOf来构建一个长度为原字符串和要拼接字符串的之和的字符数组 ，并将原字符串填充到字符数组前面，后面为空，再利用getChars方法将要拼接字符串放入字符数组后面为空的位置，最后返回一个拼接后的新字符串。
（十）indexOf(int ch, int fromIndex) 方法
public int indexOf(int ch, int fromIndex) {
final int max = value.length;
// 指定索引值小于0，默认从0开始搜索
if (fromIndex < 0) {
fromIndex = 0;
} else if (fromIndex >= max) {
// 指定索引值大于等于字符串长度，直接返回-1
return -1;
}
// 一个char占用两个字节，如果ch小于2的16次方（65536），绝大多数字符都在此范围内
if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) {
final char[] value = this.value;
for (int i = fromIndex; i < max; i++) {
if (value[i] == ch) {
return i;
}
}
return -1;
} else {
//当字符大于 65536时，处理的少数情况，该方法会首先判断是否是有效字符，然后依次进行比较
return indexOfSupplementary(ch, fromIndex);
}
}
该方法的作用是从指定索引位置开始查找指定字符第一次出现的位置，首先进行一系列的逻辑判断，最后for循环逐一判断对比，相等返回下标索引值，循环结束没有相等的就返回-1。
（十一）split(String regex, int limit) 方法
public String[] split(String regex, int limit) {
/* 1、单个字符，且不是".$|()[{^?*+\\"其中一个
* 2、两个字符，第一个是"\"，第二个大小写字母或者数字
*/
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;//大于0，limited==true,反之limited==false
ArrayList<String> list = new ArrayList<>();
while ((next = indexOf(ch, off)) != -1) {
//当参数limit<=0 或者 集合list的长度小于 limit-1
if (!limited || list.size() < limit - 1) {
list.add(substring(off, next));
off = next + 1;
} else {//判断最后一个list.size() == limit - 1
list.add(substring(off, value.length));
off = value.length;
break;
}
}
//如果没有一个能匹配的，返回一个新的字符串，内容和原来的一样
if (off == 0)
return new String[]{this};
// 当 limit<=0 时，limited==false,或者集合的长度 小于 limit是，截取添加剩下的字符串
if (!limited || list.size() < limit)
list.add(substring(off, value.length));
// 当 limit == 0 时，如果末尾添加的元素为空（长度为0），则集合长度不断减1，直到末尾不为空
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);
}
该方法的作用是将字符串分隔成指定正则表达式匹配后的字符串数组，limit的取值存在三种情况：
- limit>0，拆分limit-1次
String str = "a,b,c";
String[] c1 = str.split(",", 2);
System.out.println(c1.length);//2
System.out.println(Arrays.toString(c1));//{"a","b,c"}
- limit=0,拆分无限次且忽略原字符串后面的空白部分
String str = "a,b,c,,";
String[] c1 = str.split(",", 0);
System.out.println(c1.length);//3
System.out.println(Arrays.toString(c1));//{"a","b","c"}
- limit<0,拆分无限次
String str = "a,b,c,,";
String[] c1 = str.split(",", 0);
System.out.println(c1.length);//5
System.out.println(Arrays.toString(c1));//{"a","b","c","",""}
（十二）String replaceAll(String regex, String replacement) 方法
public String replaceAll(String regex, String replacement) {
return Pattern.compile(regex).matcher(this).replaceAll(replacement);
}
该方法的作用是将原字符串中符合正则表达式的都替换成指定的字符串，此外还有个replace(char oldChar, char newChar)方法，作用是将所有olfChar都替换成newCher。
（十三）substring(int beginIndex, int endIndex) 方法
public String substring(int beginIndex, int endIndex) {
if (beginIndex < 0) {//起始索引小于0抛出异常
throw new StringIndexOutOfBoundsException(beginIndex);
}
if (endIndex > value.length) {//起始索引大于字符串长度抛出异常
throw new StringIndexOutOfBoundsException(endIndex);
}
int subLen = endIndex - beginIndex;
//起始索引大于截止索引抛出异常
if (subLen < 0) {
throw new StringIndexOutOfBoundsException(subLen);
}
return ((beginIndex == 0) && (endIndex == value.length)) ? this
: new String(value, beginIndex, subLen);
}
该方法的作用是返回从索引 beginIndex 到 endIndex 的子字符串，此外还有个重载方法substring(int beginIndex)，作用是返回从索引 beginIndex 开始一直到结尾的子字符串。
（十四）常量池
JVM里有一块区域叫做常量池，常量池中的数据是那些在编译期间被确定，并被保存在已编译的.class文件中的一些数据。除了包含所有的8种基本数据类型（char、byte、short、int、long、float、double、boolean）外，还有String及其数组的常量值，另外还有一些以文本形式出现的符号引用。
我们声明字符串对象有两种常用的方式：
- 通过"字面值"的形式直接赋值
String str="abc";
- 通过构造函数构建对象
String str=new String("abc");
那么这两种方式有什么区别呢？我们来测试一下：
String str1 = "hello";
String str2 = "hello";
String str3 = new String("hello");
String str4 = new String("hello");
System.out.println(str1==str2);//true
System.out.println(str1==str3);//fasle
System.out.println(str2==str3);//fasle
System.out.println(str3==str4);//fasle
通过上面这个例子充分说明了以下规律：
①、字面量创建字符串会先在字符串池中找，看是否有相等的对象，没有的话就在字符串池创建该对象；有的话则直接用池中的引用，避免重复创建对象。
②、new关键字创建时，直接在堆中创建一个新对象，变量所引用的都是这个新对象的地址。
实际在日常我们也很经常用表达式来拼接字符串，这些的字符串对象又是怎么得到的呢？
String str1 = "hello";
String str2 = "helloworld";
String str3 = str1+"world";//编译器不能确定为常量(会在堆区创建一个String对象)
String str4 = "hello"+"world";//编译器确定为常量，直接到常量池中引用
System.out.println(str2==str3);//fasle
System.out.println(str2==str4);//true
System.out.println(str3==str4);//fasle
从开头我们可以知道常量池保存的是在编译期间被确定一些数据，这些数据绝对不能是变量，因此我们可以很清楚的知道上面的这些例子为什么是这样的结果了。
（十五）关于String不可变
从开始我们就知道String类被final修饰，因此我们把它当做是不可变对象，它的值是同样被final修饰的字符数组：
private final char value[];
那么什么不可以被改变呢，是变量的引用？还是变量里面的内容？还是两者都不可以被改变？实际上结论是：不可变的是变量的引用而非引用指向对象的内容，有兴趣可以看看仓颉大神的这篇博客，个人认为写的非常到位。
那么我们既然知道了value 被 final 修饰，只能保证引用不被改变，那么我们改变引用指向的堆的内容，依旧可以改变数据，我们用暴力反射来试试：
String str = "vae";
//打印原字符串
System.out.println(str);//vae
//获取String类中的value字段
Field fieldStr = String.class.getDeclaredField("value");
//因为value是private声明的，这里修改其访问权限
fieldStr.setAccessible(true);
//获取str对象上的value属性的值
char[] value = (char[]) fieldStr.get(str);
//将第一个字符修改为 V(小写改大写)
value[0] = 'V';
//打印修改之后的字符串
System.out.println(str);//Vae
通过前后两次打印的结果，我们可以看到 String 被改变了，但是在代码里，几乎不会使用反射的机制去操作 String 字符串，所以，我们会认为 String 类型是不可变的。
那么，String类为什么要被设置成不可变呢？
-
安全
- 引发安全问题，譬如，数据库的用户名、密码都是以字符串的形式传入来获得数据库的连接，或者在socket编程中，主机名和端口都是以字符串的形式传入。因为字符串是不可变的，所以它的值是不可改变的，否则黑客们可以钻到空子，改变字符串指向的对象的值，造成安全漏洞。
- 保证线程安全，在并发场景下，多个线程同时读写资源时，会引竞态条件，由于 String 是不可变的，不会引发线程的问题而保证了线程。
- HashCode，当 String 被创建出来的时候，hashcode也会随之被缓存，hashcode的计算与value有关，若 String 可变，那么 hashcode 也会随之变化，针对于 Map、Set 等容器，他们的键值需要保证唯一性和一致性，因此，String 的不可变性使其比其他对象更适合当容器的键值。
-
性能
- 当字符串是不可变时，字符串常量池才有意义。字符串常量池的出现，可以减少创建相同字面量的字符串，让不同的引用指向池中同一个字符串，为运行时节约很多的堆内存。若字符串可变，字符串常量池失去意义，基于常量池的String.intern()方法也失效，每次创建新的 String 将在堆内开辟出新的空间，占据更多的内存。
参考文档：
https://docs.oracle.com/javase/8/docs/api/java/lang/String.html
https://segmentfault.com/a/1190000009914328
