Java-String 类深入理解
String 类基本上是使用最多的类，好好理解细节是很有必要的。
基本结构图：
1.java 八大基本类型
| 类型 | 占用字节 | 存储宽度 | 存储数据范围 | 注意点 |
|---|---|---|---|---|
| byte | 1 | 8 | -2^7 ~ 2^7 - 1 | |
| char | 2 | 16 | 存储 unicode 码，理论上范围是 -2^15 ~ 2^15 - 1 | |
| short | 2 | 16 | -2^15 ~ 2^15 - 1 | |
| int | 4 | 32 | -2^31 ~ 2^31 - 1 | |
| long | 8 | 64 | -2^63 ~ 2^63 - 1 | |
| float | 4 | 32 | 约 3.4e-45 ~ 1.4e38 | 直接复制时，末尾需要加上 f 或 F |
| double | 8 | 64 | 约 4.9e-324 ~ 1.8e308 | 直接赋值时，可以加 d 或 D 或不加。 |
| boolean | 1 或 4 | true， false | 在 JVM 实现中，直接 boolean b = true , 是用 int 存储的，所以占 4字节，但 boolean[] bArr = new boolean[], 则是用 byte 存储，每个boolean 占用1字节。 |
2.String 常见的方法罗列：
public class StringDemo {
public static void main(String[] args) throws Exception {
String str1 = "Hello World";
String str2 = "Hello World";
String str3 = "hello world";
String str4 = " hello world ";
// 返回字符串长度
System.out.println("r1: " + str1.length()); // r1: 11
// 比较两个字符串的大小 compareTo(返回的是 int), 0相等，正数大于，负数小于
System.out.println("r2: " + str1.compareTo(str2)); // r2: 0
System.out.println("r3: " + str1.compareTo(str3)); // r3: -32
System.out.println("r4: " + str1.compareToIgnoreCase(str3)); // r4: 0
System.out.println("r5: " + str1.indexOf("o")); // r5: 4
System.out.println("r6: " + str1.lastIndexOf("o")); // r6: 7
System.out.println("r7: " + str1.substring(0, 5) + str1.substring(6)); // r7: HelloWorld
System.out.println("r8: " + str1.replace("o", "h")); // r8: Hellh Whrld
System.out.println("r9: " + str1.replaceAll("o", "h")); // r9: Hellh Whrld
System.out.println("r10: " + str1.replaceFirst("o", "h")); // r10: Hellh World
System.out.println("r11: " + new StringBuffer(str1).reverse()); // r11: dlroW olleH
System.out.println("r12: " + new StringBuffer(str1).reverse()); // r12: dlroW olleH
String[] temp = str1.split("\\ ");
for (String str: temp) {
System.out.println("r13: " + str);
// r13: Hello
// r13: World
}
System.out.println("r14: " + str1.toUpperCase()); // r14: HELLO WORLD
System.out.println("r15: " + str1.toLowerCase()); // r15: hello world
System.out.println("r16: " + str1.trim()); // r16: Hello World
System.out.println("r17: " + str1.contains("World")); // r17: true
System.out.println("r18: " + str1.charAt(4)); // r18: o
System.out.println("r19: " + str1.endsWith("d")); // r19: true
System.out.println("r20: " + str1.startsWith("H")); // r20: true
System.out.println("r21: " + str1.startsWith("ll", 2)); // r21: true
System.out.println("r22: " + str1.concat("haha")); // r22: Hello Worldhaha
System.out.println("r23: " + str1.equals(str2)); // r23: true
System.out.println("r24: " + str1.equalsIgnoreCase(str2)); // r24: true
System.out.println("r25: " + str1.isEmpty()); // r25: false
}
}
3.String 类核心源码理解：
public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
// ...
}
所以 String 类 实现的接口关系为：
注意 String 类是 final 的，所以 String 不可继承（String 字符串的内容也是 不可修改，因为内部字符数组属性 final char[]）。
String 类继承这三个接口，分别代表了重要的作用：
- 实现 Serializable，所以 String 类可以被序列化
- 实现 Comparable，所以字符串之间可以比较大小（实际是挨个比较 ASCII码，返回第一个同位置差异字符的 ASCII 码之差。）
- 实现 CharSequence，所以可以和 char[] 互相转换，同时说明底层存储的其实是字符数组。
回顾下 final 的作用：
- final class: 表示类不可被继承
- final method: 表示继承类不可修改此方法
- final 基本变量：表示赋值后不可修改其值。
String 类重要属性
// 存储 String 内容
private final char value[];
// 存储字符串哈希值，默认为0
private int hash;
// 实现序列化的标识
private static final long serialVersionUID = -6849794470754667710L;
所以 String 的内容是不可修改的。
构造方法
// 无参构造
public String() {
this.value = "".value;
}
// 用 String 类赋值 String
public String(String original) {
this.value = original.value;
this.hash = original.hash;
}
// 用 char[] 赋值 String
public String(char value[]) {
this.value = Arrays.copyOf(value, value.length);
}
// Arrays.copyOf 位于 java.util.Arrays 类
public static char[] copyOf(char[] original, int newLength) {
// 创建新 char[]
char[] copy = new char[newLength];
// System.arraycopy() 方法拷贝 char[]
System.arraycopy(original, 0, copy, 0, newLength);
// 返回 char[] 副本
return copy;
}
// 用 StringBuffer 赋值 String类
public String(StringBuffer buffer) {
synchronized(buffer) {
this.value = Arrays.copyOf(buffer.getValue(), buffer.length());
}
}
// 注：由于 StringBuffer 本身线程安全，所以这里 String 类也加上 同步锁保证线程安全特性。
// 用 StringBuilder 赋值 String 类
public String(StringBuilder builder) {
this.value = Arrays.copyOf(builder.getValue(), buffer.length());
}
// 注：这就是我们平常用的比较多的赋值方式。由于 StringBuilder 本身不满足线程安全，所以这里也不加同步锁，保证初始化的效率高
4.String 类常用方法分析：
hashCode() 方法
hashCode() 是在 Object 类定义的，String 类进行了重写。
源码：
public int hashCode() {
int h = hash;
if (h == 0 && value.length > 0) {
char val[] = value;
// hash算法，s[0]*31^(n - 1) + s[1]*31^(n - 2) + ... + s[n - 1]; n 为字符串长度
for (int i = 0; i < value.length; i++) {
h = 31 * h + val[i];
}
hash = h;
}
return h;
}
由于所有对象都可以转为字符串，所以 hashCode() 通用于所有类的求 hash 操作。
equals() 方法
equals() 也是 Object 类中定义的，
源码：
public boolean equals(Object object) {
if (this == object) {
return true;
}
if (object instanceof String) {
String anotherString = (String)object;
int n = value.length;
if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
// 从 index 0 开始, 逐个字符比较
while (n-- > 0) {
if (v1[i] != v2[i]) {
return false;
}
i++;
}
return true;
}
}
return false;
}
补充：== 的比较，一是作用于八大基本类型，判断常量值是否相等，一是作用于引用，判断引用地址是否相同。
substring() 方法
截取一段字符串
其中第一个重载方法源码：
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);
}
intern() 方法
intern() 方法是 native 修饰的，即本地方法。
/*
* 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.
*/
public native String intern();
intern() 的作用是，直接去检查常量池，如果常量池存在这个基本变量，则直接将值的引用返回，而不再去创建新对象再赋值引用。
看个例子：
public class StringDemo {
public static void main(String[] args) throws Exception {
String str1 = "a";
String str2 = "b";
String str3 = "ab";
String str4 = str1 + str2;
String str5 = new String("ab");
System.out.println(str5 == str3);//堆内存比较字符串池
//intern如果常量池有当前String的值,就返回这个值,没有就加进去,返回这个值的引用
// false
System.out.println(str5.intern() == str3);//引用的是同一个字符串池里的
// true
System.out.println(str5.intern() == str4);//变量相加给一个新值，所以str4引用的是个新的
// false
System.out.println(str4 == str3);//变量相加给一个新值，所以str4引用的是个新的
// false
}
}
length()
public int length() {
return value.length;
}
isEmpty()
public boolean isEmpty() {
return value.length == 0;
}
charAt(int index)
public char charAt(int index) {
//索引小于0或者索引大于字符数组长度，则抛出越界异常
if ((index < 0) || (index >= value.length)) {
throw new StringIndexOutOfBoundsException(index);
}
//返回字符数组指定位置字符
return value[index];
}
getBytes()
public byte[] getBytes() {
return StringCoding.encode(value, 0, value.length);
}
compareTo()方法
这个方法写的很巧妙，先从0开始判断字符大小。如果两个对象能比较字符的地方比较完了还相等，就直接返回自身长度减被比较对象长度，如果两个字符串长度相等，则返回的是0，巧妙地判断了三种情况。
public int compareTo(String anotherString) {
//自身对象字符串长度len1
int len1 = value.length;
//被比较对象字符串长度len2
int len2 = anotherString.value.length;
//取两个字符串长度的最小值lim
int lim = Math.min(len1, len2);
char v1[] = value;
char v2[] = anotherString.value;
int k = 0;
//从value的第一个字符开始到最小长度lim处为止，如果字符不相等，
//返回自身（对象不相等处字符-被比较对象不相等字符）
while (k < lim) {
char c1 = v1[k];
char c2 = v2[k];
if (c1 != c2) {
return c1 - c2;
}
k++;
}
//如果前面都相等，则返回（自身长度-被比较对象长度）
return len1 - len2;
}
startsWith()方法
public boolean startsWith(String prefix, int toffset) {
char ta[] = value;
int to = toffset;
char pa[] = prefix.value;
int po = 0;
int pc = prefix.value.length;
// Note: toffset might be near -1>>>1.
//如果起始地址小于0或者（起始地址+所比较对象长度）大于自身对象长度，返回假
if ((toffset < 0) || (toffset > value.length - pc)) {
return false;
}
//从所比较对象的末尾开始比较
while (--pc >= 0) {
if (ta[to++] != pa[po++]) {
return false;
}
}
return true;
}
public boolean startsWith(String prefix) {
return startsWith(prefix, 0);
}
public boolean endsWith(String suffix) {
return startsWith(suffix, value.length - suffix.value.length);
}
起始比较和末尾比较都是比较经常用得到的方法，例如：在判断一个字符串是不是http协议的，或者初步判断一个文件是不是mp3文件，都可以采用这个方法进行比较。
concat()方法
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);
}
concat方法也是经常用的方法之一，它先判断被添加字符串是否为空来决定要不要创建新的对象。
replace()方法
public String replace(char oldChar, char newChar) {
//新旧值先对比
if (oldChar != newChar) {
int len = value.length;
int i = -1;
char[] val = value;
//找到旧值最开始出现的位置
while (++i < len) {
if (val[i] == oldChar) {
break;
}
}
//从那个位置开始，直到末尾，用新值代替出现的旧值
if (i < len) {
char buf[] = new char[len];
for (int j = 0; j < i; j++) {
buf[j] = val[j];
}
while (i < len) {
char c = val[i];
buf[i] = (c == oldChar) ? newChar : c;
i++;
}
return new String(buf, true);
}
}
return this;
}
这个方法也有讨巧的地方，例如最开始先找出旧值出现的位置，这样节省了一部分对比的时间。replace(String oldStr,String newStr)方法通过正则表达式来判断。
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;
}
trim方法就是将字符串中的空白字符串删掉。
valueOf()方法
public static String valueOf(boolean b) {
//如果b为true就返回"true"否则返回"false"
return b ? "true" : "false";
}
public static String valueOf(char c) {
//创建data[]数组 并把c添加进去
char data[] = {c};
//创建一个新的String对象并进行返回
return new String(data, true);
}
public static String valueOf(int i) {
//调用Integer对象的toString()方法并进行返回
return Integer.toString(i);
}
//Integer类中的toString(i)方法
public static String toString(int i) {
//是否为Integer最小数，是直接返回
if (i == Integer.MIN_VALUE)
return "-2147483648";
//这个i有多少位
int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);
//创建一个char数组
char[] buf = new char[size];
//把i内容方法char数组中区
getChars(i, size, buf);
//返回一个String对象
return new String(buf, true);
}
split() 方法
public String[] split(String regex) {
return split(regex, 0);
}
//使用到了正则表达式
public String[] split(String regex, int limit) {
//....
//源码有点多了，反正就是里面使用到了正则表达式，进行切分
}
split() 方法用于把一个字符串分割成字符串数组，返回一个字符串数组返回的数组中的字串不包括 regex自身。可选的“limit”是一个整数，第一个方法中默认是0，允许各位指定要返回的最大数组的元素个数。
常见方法源码分析就这么多了，下面我们再回顾到使用场景中来，尤其是面试中。
常见问题点：
如何比较字符串相同？
在java中比较对象是否相同，通常有两种方法：
==equals方法
注意==用于基本数据类型的比较和用于引用类型的比较的区别。
==比较基本数据类型，比较的是值
==比较引用数据类型，比较的是地址值
另外，String对equals方法进行了重写，所以比较字符串咱们还是要使用equals方法来比较。主要是String的equals方法里包含了==的判断（请看前面源码分析部分）。
案例
public class StringDemo {
public static void main(String[] args) {
String st1 = "abc";
String st2 = "abc";
System.out.println(st1 == st2);
System.out.println(st1.equals(st2));
}
}
输出
true
true
String str=new String("abc");这行代码创建了几个对象？
看下面这段代码：
String str1 = "abc"; // 在常量池中
String str2 = new String("abc"); // 在堆上
关于这段代码，创建了几个对象，网上答案有多重，1个，2个还有3个的。下面我们就来聊聊到底是几个？
首先，我们需要明确的是；不管是str1还是str2，他们都是String类型的变量，不是对象，平时，可能我们会叫str2对象，那只是为了便于理解，本质上来说str2、str1都不是对象。
其次，String str="abc"；的时候，字符串“abc”会被存储在字符串常量池中，只有1份，此时的赋值操作等于是创建0个或1个对象。如果常量池中已经存在了“abc”，那么不会再创建对象，直接将引用赋值给str1；如果常量池中没有“abc”，那么创建一个对象，并将引用赋值给str1。
那么，通过new String("abc");的形式又是如何呢？
答案是1个或2个。
当JVM遇到上述代码时，会先检索常量池中是否存在“abc”，如果不存在“abc”这个字符串，则会先在常量池中创建这个一个字符串。然后再执行new操作，会在堆内存中创建一个存储“abc”的String对象，对象的引用赋值给str2。此过程创建了2个对象。
当然，如果检索常量池时发现已经存在了对应的字符串，那么只会在堆内创建一个新的String对象，此过程只创建了1个对象。
最后，如果单独问String str=new String("abc");创建了几个对象，切记：常量池中是否存在"abc"，存在，创建一个对象；不存在创建两个对象。
String 和 StringBuilder、StringBuffer 的区别
线程安全性
String 中的对象是不可变的，也就可以理解为常量，线程安全。AbstractStringBuilder 是 StringBuilder 与 StringBuffer 的公共父类，定义了一些字符串的基本操作，如 expandCapacity、append、insert、indexOf 等公共方法。StringBuffer 对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder 并没有对方法进行加同步锁，所以是非线程安全的。
性能
每次对 String 类型进行改变的时候，都会生成一个新的 String 对象，然后将 指针指向新的 String 对象。StringBuffer 每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用。相同情况下使用 StringBuilder 相比使用 StringBuffer 仅能获得 10%~15% 左右的性能提升，但却要冒多线程不安全的风险。
对于三者使用的总结：
- 操作少量的数据 ，推荐使用
String - 单线程操作字符串缓冲区下操作大量数据，推荐使用
StringBuilder - 多线程操作字符串缓冲区下操作大量数据 ，推荐使用
StringBuffer
String 和 JVM有什么关系？
String 常见的创建方式有两种，new String() 的方式和直接赋值的方式，直接赋值的方式会先去字符串常量池中查找是否已经有此值，如果有则把引用地址直接指向此值，否则会先在常量池中创建，然后再把引用指向此值；而 new String() 的方式一定会先在堆上创建一个字符串对象，然后再去常量池中查询此字符串的值是否已经存在，如果不存在会先在常量池中创建此字符串，然后把引用的值指向此字符串。
JVM中的常量池
字面量—文本字符串，也就是我们举例中的 public String s = " abc "; 中的 "abc"。
用 final 修饰的成员变量，包括静态变量、实例变量和局部变量。
请看下面这段代码：
String s1 = new String("Java");
String s2 = s1.intern();
String s3 = "Java";
System.out.println(s1 == s2); // false
System.out.println(s2 == s3); // true
它们在 JVM 存储的位置，如下图所示：
注意：JDK 1.7 之后把永生代换成的元空间，把字符串常量池从方法区移到了 Java 堆上。
除此之外编译器还会对 String 字符串做一些优化，例如以下代码：
String s1 = "Ja" + "va";
String s2 = "Java";
System.out.println(s1 == s2);
虽然 s1 拼接了多个字符串，但对比的结果却是 true，我们使用反编译工具，看到的结果如下：
Compiled from "StringExample.java"
public class com.lagou.interview.StringExample {
public com.lagou.interview.StringExample();
Code:
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: return
LineNumberTable:
line 3: 0
public static void main(java.lang.String[]);
Code:
0: ldc #2 // String Java
2: astore_1
3: ldc #2 // String Java
5: astore_2
6: getstatic #3 // Field java/lang/System.out:Ljava/io/PrintStream;
9: aload_1
10: aload_2
11: if_acmpne 18
14: iconst_1
15: goto 19
18: iconst_0
19: invokevirtual #4 // Method java/io/PrintStream.println:(Z)V
22: return
LineNumberTable:
line 5: 0
line 6: 3
line 7: 6
line 8: 22
}
从编译代码 #2 可以看出，代码 "Ja"+"va" 被直接编译成了 "Java" ，因此 s1==s2 的结果才是 true，这就是编译器对字符串优化的结果。
如何判断两个字符串中含有几个相同字符
- 将字符串转化成数组
- HashMap 方法
- 字符串直接进行比较
- 正则表达式
- HashSet 方法
String有没有长度限制？是多少？为什么？
下面先看看length方法源码：
private final char value[];
public int length() {
return value.length;
}
length()方法返回的是int类型，那可以得知String类型的长度肯定不能超过Integer.MAX_VALUE的。
答：首先字符串的内容是由一个字符数组 char[] 来存储的，由于数组的长度及索引是整数，且String类中返回字符串长度的方法length() 的返回值也是int ，所以通过查看java源码中的类Integer我们可以看到Integer的最大范围是2^31 -1,由于数组是从0开始的，所以**数组的最大长度可以使【0~2^31】**通过计算是大概4GB。
但是通过翻阅java虚拟机手册对class文件格式的定义以及常量池中对String类型的结构体定义我们可以知道对于索引定义了u2，就是无符号占2个字节，2个字节可以表示的最大范围是2^16 -1 = 65535。
但是由于JVM需要1个字节表示结束指令，所以这个范围就为65534了。超出这个范围在编译时期是会报错的，但是运行时拼接或者赋值的话范围是在整形的最大范围。
字符串对象能否用在switch表达式中？
从JDK7开始的话，我们就可以在switch条件表达式中使用字符串了，也就是说7之前的版本是不可以的。
switch (str.toLowerCase()) {
case "tian":
value = 1;
break;
case "jiang":
value = 2;
break;
}
说说String中intern方法
在JDK7之前的版本，调用这个方法的时候，会去常量池中查看是否已经存在这个常量了，如果已经存在，那么直接返回这个常量在常量池中的地址值，如果不存在，则在常量池中创建一个，并返回其地址值。
但是在JDK7以及之后的版本中，常量池从perm区搬到了heap区。intern检测到这个常量在常量池中不存在的时候，不会直接在常量池中创建该对象了，而是将堆中的这个对象的引用直接存到常量池中，减少内存开销。
下面的案例
public class InternTest {
public static void main(String[] args) {
String str1 = new String("hello") + new String("world");
str1.intern();
String str2 = "helloworld";
System.out.println(str1 == str2);//true
System.out.println(str1.intern() == str2);//true
}
}