继承体系
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {String实现了三个接口，前两个接口的作用应该比较明显了（序列化、比较）。
一个接口通常代表着一种抽象。而CharSequence希望实现类是一组有序的字符序列，提供标准化的访问接口。
public interface CharSequence {
int length();
char charAt(int index);
CharSequence subSequence(int start, int end);
public String toString();
}Java8以后，多了两个方法，与Stream相关，暂不讨论。
上面列的几个方法，分别是：获取字符序列的长度、按下标获取字符、获取子系列、以及转化成String。
CharSequence给String打了一个标签：其实String就是一组有序的字符（char）集合。
——————————————————————————————————————————
下面插个题外话，不感兴趣的跳过：
String实现了CharSequence，而CharSequence中居然又出现了String，有一种套娃的感觉
理论上积累（包括接口）不应该依赖子类，因为相对来说，子类是不稳定的、可能会变化的，而基类则相对稳定。
但是String类在Java中算是一种”基础设施“，运用广泛且必不可少，已经是一个比较稳定的点了。
其实在Java的Nio中也有类似的设计，ByteBuffer有如下子类
ByteBuffer作为抽象基类，却在源码混进了子类的足迹。这也是因为ByteBuffer的子类相对也是比较稳定的，
堆内存Buffer、直接内存Buffer，内存分配的方式有限，一般来说不会变。
——————————————————————————————————————————
成员变量
回归标题，先看一下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 */
private static final long serialVersionUID = -6849794470754667710L;
/**
* Class String is special cased within the Serialization Stream Protocol.
*
* A String instance is written into an ObjectOutputStream according to
* <a href="{@docRoot}/../platform/serialization/spec/output.html">
* Object Serialization Specification, Section 6.2, "Stream Elements"</a>
*/
private static final ObjectStreamField[] serialPersistentFields =
new ObjectStreamField[0];String用数组来存储有序字符，可以看到字符数组用了final修饰，被final修饰的变量，如果是基本类型，其值初始化后将不可改变。
正因如此，String类本身是线程安全的，可以在多线程环境使用。通过保持数据的不可变性，来换取线程安全的特点，注定会对性能有一定的影响。
正因为底层数组不可变，我们在对字符串做某些拼装、截取等操作时，会不断地new新的String对象，并涉及大量的数组拷贝。（当然，一般这种场景更推荐使用StringBuffer、StringBuilder）
String在序列化时与其他对象不同，需要特殊处理，所以这边定义了ObjectStreamField，ObjectStreamClass这个类后面也会单独写一篇分析。
构造函数
上面分析到，String是用一个final修饰的字符数组来存储数据的。
final类型的成员变量需要在构造函数中进行初始化
public String() {
this.value = "".value;
}
public String(char value[]) {
this.value = Arrays.copyOf(value, value.length);
}其中有一个构造方法比较特殊
public String(int[] codePoints, int offset, int count) {
if (offset < 0) {
throw new StringIndexOutOfBoundsException(offset);
}
if (count <= 0) {
if (count < 0) {
throw new StringIndexOutOfBoundsException(count);
}
if (offset <= codePoints.length) {
this.value = "".value;
return;
}
}
// Note: offset or count might be near -1>>>1.
if (offset > codePoints.length - count) {
throw new StringIndexOutOfBoundsException(offset + count);
}
final int end = offset + count;
// Pass 1: Compute precise size of char[]
int n = count;
for (int i = offset; i < end; i++) {
int c = codePoints[i];
if (Character.isBmpCodePoint(c))
continue;
else if (Character.isValidCodePoint(c))
n++;
else throw new IllegalArgumentException(Integer.toString(c));
}
// Pass 2: Allocate and fill in char[]
final char[] v = new char[n];
for (int i = offset, j = 0; i < end; i++, j++) {
int c = codePoints[i];
if (Character.isBmpCodePoint(c))
v[j] = (char)c;
else
Character.toSurrogates(c, v, j++);
}
this.value = v;
}java中的char占两个字节的大小，而一个Unicode字符的范围是：0x000000~0X10FFFF
其中一部分字符只用一个char是存储不了的（所以codePoints的类型是int），需要特殊处理，比如经典的emoji表情。
字符串编码这一块，工作中一般情况下不会涉及，除非用到网络编程，需要自己造轮子，针对字节流进行一些编码和解码操作。
以下面的构造函数为例，debug String在构造过程中是如何处理编码问题的。
public String(byte bytes[], int offset, int length, String charsetName)
throws UnsupportedEncodingException {
if (charsetName == null)
throw new NullPointerException("charsetName");
checkBounds(bytes, offset, length);
this.value = StringCoding.decode(charsetName, bytes, offset, length);
}测试入口
public class Main {
public static void main(String[] args) {
String a = "hello";
}
}运行上述的代码，idea界面直接跳到了断点处
说明编译器对我们的代码做了处理，隐式地调用了String的构造函数，并将编码默认设置为“UTF8”
检查过边界后，调用了StringCoding的decode方法。
先是检查传入的编码名是否合法
如果合法，则会返回一个Charset对象。
这个Charset方法也比较有意思，它里面有一个二级缓存，缓存近期返回的字符集编码
而真正存储字符集的是StandardCharsets这个类，存储了1015个字符编码名称
回到主线，准备好解码器后，最后调用decode方法进行解码操作。
成员方法
length()
String的静态方法比较少，作为一个包装类，String更适合用方法作为外界的窗口。
知道这一点后，就明白返回String的长度，要用length()方法。
public int length() {
return value.length;
}equals()
因为final修饰了String中的char数组，所以数组拷贝这一操作在String中格外的常见
void getChars(char dst[], int dstBegin) {
System.arraycopy(value, 0, dst, dstBegin, value.length);
}String重写了equals方法，比较两个String是否相等一般情况下是比较其内容（char数组）是否相等。
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;
}这段代码应该还是比较好读的，一个字节一个字节的比较两个数组，equals可以放心使用了。
String与String之间是可以放心的比较的，毕竟底层的char数组都不会改变。
但如果和StringBuffer这些包装类比较的时候，就需要考虑同步问题了。
compareTo(String) 、compareToIgnoreCase(String)
String 实现了接口Comparable，重写了compareTo方法，用于字符串之间的比较（不区分大小）。
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;
}在某些情况下，大小写并不那么重要，我们想要无视大小写进行compare时，就需要提供另外的接口了。
如果是我们自己写代码，可能会直接定义一个public方法，名为compareToIgnoreCase，直接在方法内部写对应的逻辑。
但是jdk是这么实现的：定义一个内部类，同样也实现了Comparable接口，只不过换了套逻辑。
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) {
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) {
c1 = Character.toUpperCase(c1);
c2 = Character.toUpperCase(c2);
if (c1 != c2) {
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; }
}
public int compareToIgnoreCase(String str) {
return CASE_INSENSITIVE_ORDER.compare(this, str);
}这么做有啥好处呢？
通常来说，内部类在某些场合，可以为所在的类提供更丰富的特性，弥补Java不能多继承的短板（虽然这里只是个接口）。
这个内部类实现了Comparable接口（Comparable比较通用），同时，他的唯一实例CASE_INSENSITIVE_ORDER还是public类型，可以配合很多api使用。
比如我们需要忽略字符串大小写，对字符串数组进行排序时，可以这么用：
public class Main {
public static void main(String[] args) {
String[]arr = new String[]{"abc", "Def", "cBa", "zhong", "Guo"};
Arrays.sort(arr, String.CASE_INSENSITIVE_ORDER);
for (String s : arr) {
System.out.println(s);
}
}
}substring(int)
底层的char数组final修饰过，不可变。
想要截取字串，肯定不能在原来的数组上修改，只能重新new一个String对象。
public String substring(int beginIndex) {
if (beginIndex < 0) {
throw new StringIndexOutOfBoundsException(beginIndex);
}
int subLen = value.length - beginIndex;
if (subLen < 0) {
throw new StringIndexOutOfBoundsException(subLen);
}
return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
}此道理同样适用于字符串的连接（concat）、替换（replace）
Locale
某些方法传进了一个Locale，看着有点突兀。
Locale表示地区，每一个Locale对象代表着一个一个地区的风俗文化。
看代码实现
不同地区的大小写字符区分方式不太一样，故可以传入一个Locale对象。（注意，是字符，不仅仅是26个字母）
trim()
只能去除字符串首尾的空格，不能去除中间的字符，代码看起来还是比较直观的。
public String trim() {
int len = value.length;
int st = 0;
char[] val = value; /* avoid getfield opcode */
while ((st < len) && (val[st] <= ' ')) {
st++;
}
while ((st < len) && (val[len - 1] <= ' ')) {
len--;
}
return ((st > 0) || (len < value.length)) ? substring(st, len) : this;
}intern()
native修饰的方法，底层用C或者C++写的，我们看不到具体的实现。
我觉得这里可以暂且忽略Java的内存模型，不用纠结这个String Pool究竟分配在JVM的哪个区，而应该先读清楚作者写这个接口的意图。
那自然应该翻译一波注释了，毕竟人家幸幸苦苦地写了那么一大段。
/**
* Returns a canonical representation for the string object.
* <p>
* A pool of strings, initially empty, is maintained privately by the
* class {@code String}.
* <p>
* When the intern method is invoked, if the pool already contains a
* string equal to this {@code String} object as determined by
* the {@link #equals(Object)} method, then the string from the pool is
* returned. Otherwise, this {@code String} object is added to the
* pool and a reference to this {@code String} object is returned.
* <p>
* It follows that for any two strings {@code s} and {@code t},
* {@code s.intern() == t.intern()} is {@code true}
* if and only if {@code s.equals(t)} is {@code true}.
* <p>
* All literal strings and string-valued constant expressions are
* interned. String literals are defined in section 3.10.5 of the
* <cite>The Java™ Language Specification</cite>.
*
* @return a string that has the same contents as this string, but is
* guaranteed to be from a pool of unique strings.
*/
public native String intern();首先，返回值是字符串对象的规范表示形式。有一个专门存放字符串的池子，一开始是空的，由String类私有维护。
当调用这个方法时，jvm会先去String Pool中看看有没有相等的字符串。
什么样的两个字符串才算是相等？调用equals方法比较时，返回true。equals的实现已经讨论过了，就不提了。
假如池子里存在相同的字符串，返回池子中字符串的引用。如果池子里没有，则把这个字符串放进池子里。
所以说要想 满足 a.intern() = b.intern()， 就必须也满足 a.equals(b)。
看完注释大概也明白这个方法的作用了，无非就是引入的一个“String缓存池”的结构，用于提高String对象的利用率，避免对象无意义地重复创建。
线程池，数据库连接池等也同样利用这种“池化”思想。
如有错误，欢迎批评指正！
