原文：https://zq99299.gitbooks.io/jdk7-source-code-note/content/content/lang/string.html

三个顶层接口

Serializable : 类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段，仅用于标识可序列化的语义。Comparable : 此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法。CharSequence : CharSequence 是 char 值的一个可读序列。此接口对许多不同种类的 char 序列提供统一的只读访问。char 值表示 Basic Multilingual Plane (BMP) 或代理项中的一个字符。有关详细信息，请参阅 Unicode 字符表示形式。

三个顶层接口表示String至少拥有这几个接口的方法实现。

开始测试

String hello = new String("你好hee"); System.out.println(hello.charAt(0)); hello.compareTo("你"); hello.compareToIgnoreCase("你好Hee"); // 使用char数组存储字符串的值 private final char value[]; /** Cache the hash code for the string */ private int hash; // Default to 0 public String(String original) { this.value = original.value; this.hash = original.hash; } // 获取指定索引位置的char public char charAt(int index) { // 做了一个索引越界判断 if ((index < 0) || (index >= value.length)) { throw new StringIndexOutOfBoundsException(index); } return value[index]; }

compareTo(String anotherString)

按字典顺序比较两个字符串。

那么什么是字典顺序呢?先来看看Unicode 字符表示形式

char 数据类型（和 Character 对象封装的值）基于原始的 Unicode 规范，将字符定义为固定宽度的 16 位实体。 char 值表示 Basic Multilingual Plane (BMP) 代码点，其中包括代理项代码点，或 UTF-16 编码的代码单元。int 值表示所有 Unicode 代码点，包括增补代码点。

也就是说一个char类型对应一个整数。这个整数的大小就是字典顺序

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++; } // 如果短串相等，那么直接返回 // 如：len1 = abc,len2 = ab // 由于短串全部相等，那么这里长度相剪：3-2 = 1， 1串大于二串 // 如果：len1 = ab,len2 = abc, 2-3=-1, 1串小于二串 // 如果正好相等，那么返回0； return len1 - len2; }

compareToIgnoreCase(String str)

按字典顺序比较两个字符串。忽略大小写。

public int compareToIgnoreCase(String str) { return CASE_INSENSITIVE_ORDER.compare(this, str); } 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); // 和compareTo一样的套路，对比最小串长度 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) { // 还不相等，直接返回了。 对Unicode不熟悉，本人不知道在什么情况下会出现这种情况 // No overflow because of numeric promotion return c1 - c2; } } } } return n1 - n2; } }

* 总结下：* 写了一个自定义比较器。实现的思路是： 1. 循环对比短串的码点 2. 全部转换成大写对比 3. 全部转换成小写对比

concat(String str)

将指定字符串连接到此字符串的结尾。

"hello".concat("hee"); public String concat(String str) { int otherLen = str.length(); // 如果str为空串，则直接返回自己，也就是不连接 if (otherLen == 0) { return this; } int len = value.length; // 把旧值扩容到一个新数组中去，没有值的下标索引处用 0 补充 char buf[] = Arrays.copyOf(value, len + otherLen); // 把要链接的字符串填充到新的数组中。 str.getChars(buf, len); // 返回一个新串 return new String(buf, true); } /** @param dst 新数组容器 @param dstBegin 开始索引 */ void getChars(char dst[], int dstBegin) { // 从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。 // 要注意这里的 value，已经不是连接前的字符串了（hello），这个方法而是“hee”对象里面的了 System.arraycopy(value, 0, dst, dstBegin, value.length); }

boolean contains(CharSequence s)

当且仅当此字符串包含指定的 char 值序列时，返回 true。

public boolean contains(CharSequence s) { return indexOf(s.toString()) > -1; } // 返回指定字符在此字符串中第一次出现处的索引。 public int indexOf(String str) { return indexOf(str, 0); } // 返回指定字符在此字符串中第一次出现处的索引。在指定位置开始搜索 public int indexOf(String str, int fromIndex) { return indexOf(value, 0, value.length, str.value, 0, str.value.length, fromIndex); } // shared by String and StringBuffer 该方法是一个共享方法 // 在源数组中搜索目标数组 static int indexOf(char[] source, int sourceOffset, int sourceCount, char[] target, int targetOffset, int targetCount, int fromIndex) { // 由于是共享方法，应该是避免某种bug的判断吧 if (fromIndex >= sourceCount) { return (targetCount == 0 ? sourceCount : -1); } // 这里还要做健壮性判断，难道是明白该方法只能在某处为使用吗？ if (fromIndex < 0) { fromIndex = 0; } if (targetCount == 0) { return fromIndex; } // 获取第一个要搜索的字符 char first = target[targetOffset]; // max = 0 + (源长度 - 目标长度) int max = sourceOffset + (sourceCount - targetCount); for (int i = sourceOffset + fromIndex; i <= max; i++) { /* Look for first character. */ // 如果从索引开始处（对于string来说，都是从0开始） // 不等于第一个字符，那么就死循环对比 if (source[i] != first) { while (++i <= max && source[i] != first); } /* Found first character, now look at the rest of v2 */ // 如果 i <= max 说明 第一个字符找到了。接下来寻找后面的所有字符 if (i <= max) { int j = i + 1; // 从第一个字符后面一个开始找起 int end = j + targetCount - 1; // 因为已经找到了一个字符，所以还需要寻找targetCount - 1 次 // for (int k = targetOffset + 1; j < end && source[j] == target[k]; j++, k++); if (j == end) { /* Found whole string. */ return i - sourceOffset; } } } return -1; }

上面的代码在源数组中搜索目标数组是具体的实现，因为是和StringBuffer 公用，看起来很费劲，下面把它简化抽取出来：

public class Demo { @Test public void test1() throws UnsupportedEncodingException { System.out.println(indexOf("我是中国人", "中国c")); } private int indexOf(String sourceStr, String targetStr) { char[] source = sourceStr.toCharArray(); char[] target = targetStr.toCharArray(); int sourceCount = source.length; int targetCount = target.length; // 第一个字符 char first = target[0]; int max = 0 + (sourceCount - targetCount); for (int i = 0; i <= max; i++) { // 先找第一个字符 if (source[i] != first) { while (++i <= max && source[i] != first) ; } if (i <= max) { int j = i + 1; // 源数组索引开始处(从找到的后一个字符开始) int k = 1; // 目标数组索引开始处（因为已经找到一个字符） int end = j + targetCount - 1; // 循环跳出条件 // s:我是中国人 // t: 中国 // 那么 j = 3；s数组整个长度是５；　end = 3+2-1 = 4 // 也就是说：3 < 4; 也就是只能循环一次，能把剩下的 国 遍历完成。 // 原理是：两个数组都要同时匹配下一个索引所在处的值 // 所以需要两个变量来递增索引 // 需要注意的是：j和k的起始索引不同，end既能控制循环的次数(刚好是剩下未完成的字符次数) // 又能让源数组的索引获取到正确的值 while (j < end && source[j] == target[k]) { j++; k++; } // 如果 两个相等，就表示上面的循环中取到的每一个值 都是相等的 // 否则就标识后面的字符有不相等的 if (j == end) { /* Found whole string. */ // 返回第一个字符所在的索引位置 return i - 0; } } } return -1; } }

来看下搜索的原理图：

先找第一个字符，如果找到了再找后面的字符。也就是 j 和 k 只要匹配就都+1，往后匹配下一对。最难的就是 end，循环多少次了。j和k的起始索引不同，end既能控制循环的次数(刚好是剩下未完成的字符次数),又能让源数组的索引获取到正确的值

int hashCode()

原来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; }

boolean equals(Object anObject)

public boolean equals(Object anObject) { if (this == anObject) { // 先对比内存地址，这里和 Object中的对比一致 return true; } // 然后指对比String类型 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; }

总结如下： 1. 先比较内存地址 2. 再比较字符串长度 3. 再挨个比较内容（码点）

intern

返回字符串对象的规范化表示形式。 一个初始为空的字符串池，它由类 String 私有地维护。

当调用 intern 方法时，如果池已经包含一个等于此 String 对象的字符串（用 equals(Object) 方法确定），则返回池中的字符串。否则，将此 String 对象添加到池中，并返回此 String 对象的引用。

它遵循以下规则：对于任意两个字符串 s 和 t，当且仅当 s.equals(t) 为 true 时，s.intern() == t.intern() 才为 true。

所有字面值字符串和字符串赋值常量表达式都使用 intern 方法进行操作。字符串字面值在 Java Language Specification 的 §3.10.5 定义。

返回： 一个字符串，内容与此字符串相同，但一定取自具有唯一字符串的池。

class TestDemo { public static void main(String[] args) { String hello = "Hello", lo = "lo"; System.out.print((hello == "Hello") + " "); System.out.print((Other.hello == hello) + " "); // System.out.print((other.Other.hello == hello) + " "); System.out.print((hello == ("Hel"+"lo")) + " "); System.out.print((hello == ("Hel"+lo)) + " "); System.out.println(hello == ("Hel"+lo).intern()); } } class Other { static String hello = "Hello"; } true true true false false

http://docs.oracle.com/javase/specs/jls/se7/html/jls-3.html#d5e1287

文档里面的说明部分英文没看懂是啥意思：但是有以下几点： 1. 字面量 相加是在编译事情合并的。因此相等 2. 字面量 + 变量 是在运行事情创建的，因此是不等的。

String 不可变说明

看了源码还是对于常听见的回答有些疑惑，一般人的回答就是String是被Final修饰的所以不可变。

于是知乎上的回答： https://www.zhihu.com/question/20618891 知乎上的回答。

解决了我的疑惑，根据源码情况总结如下：

String 被 final 修饰private final char value[]; 存储的数据容器被final修饰。操作字符串的api都是返回new String（除了不改变字符的api）字面量被底层管理支持

类被final修饰，断了String有子类的后路、存储容器被final，断了容器变量被修改的后路、内部api和底层不触碰数组内引用地址的值，断了被修改的后路

总结

底层使用Char数组存储字面量字符串相+，在编译时期合并，放入常量池中字面量+变量，总是在运行时期new String。intern 函数将把词字符串放入常量池并返回常量池的引用，但是不是改变当前变量的引用hashCode 是根据h = 31 * h + val[i];循环该字符串的长度次数累加码点得到的compareTo 按字典顺序比较，两两比较char的Unicode码点大小实现的。compareToIgnoreCase 忽略大小写是内部定义了一个比较器，比较器实现内部实现为:把马点转换为全大写，全小写对比api操作数据后基本上都是new string返回。

结束语

这一章节看下来，发下里面很多方法都是偏底层的。复杂度很高。基本上我就放弃了。看了几个常用的方法。