【Java基础】String详解

来源：乌哈旅游

String

一、String 概述

1、基本特性

public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
    // jdk1.8及之前
    private final char value[];

    public String() {
        this.value = "".value;
    }
}

String 实现了 Serializable 接口：表示字符串是支持序列化的。
String 实现了 Comparable 接口：表示 String 可以比较大小。
String 声明为 final 的，不可被继承，一旦被创建就不会改变，对字符串的操作只是产生了一个新的字符串。
String 在 jdk8及以前 定义了 final char[] value 存储字符串数据，jdk9时 改为 final byte[] value

2、不可变性

String 声明为 final 的，一旦被创建就不会改变。String的每次操作都是生成一个新的对象，不改变原来的对象。

例1：重新赋值

@Test
public void test1() {
    String s1 = "abc";
    String s2 = s1;

    System.out.println(s1.hashCode()); // 96354
    System.out.println(s2.hashCode()); // 96354

    // 不会改变原来的对象（"abc"），只是新生成一个对象（"hello"），并指向新对象
    s2 = "hello";

    System.out.println(s1.hashCode()); // 96354
    System.out.println(s2.hashCode()); // 99162322

    System.out.println(s1); // abc
    System.out.println(s2); // hello        
}

例2：拼接操作

@Test
public void test2() {
    String s1 = "abc";
    String s2 = s1 + "def";

    System.out.println(s1); // abc
    System.out.println(s2); // abcdef
}

例3：replace() 方法

@Test
public void test3() {
    String s1 = "abc";
    String s2 = s1.replace('a', 'm');

    System.out.println(s1); // abc
    System.out.println(s2); // mbc
}

例4：方法参数传递

@Test
public void test4() {
    String str = "old";
    char[] ch = {'t', 'e', 's', 't'};
    
    change(str, ch);
    
    System.out.println(str); // old
    System.out.println(ch);  // best
}

public void change(String str, char ch[]) {
    // 拼接和replace同理
    str = "new";
    ch[0] = 'b';
}

3、String、StringBuilder、StringBuffer

可变性：

String：

使用字符数组 private final char value[] 保存字符串，因此String不可变。
StringBuilder 与 StringBuffer：

继承于 AbstractStringBuilder，使用字符数组 char[] value 保存字符串，因此这两种对象都是可变的。

线程安全性：

String：String对象是不可变的，一旦创建后其内容不能更改，线程安全。
StringBuffer：加了 synchronized 同步锁，线程安全。
StringBuilder：非线程安全。

性能：

String：每次对 String 类型进行改变的时候，都会生成一个新的String对象。
StringBuffer：每次都会对StringBuffer对象本身进行操作，而不是生成新的对象并改变对象引用。
StirngBuilder：没有加锁操作，比 StringBuffer 能获得 10%~15% 左右的性能提升。

使用场景：

操作少量数据：String
单线程操作大量数据：StringBuilder
多线程操作大量数据：StringBuffer

二、字符串创建与内存分配

1、字面量 / 双引号

public static void test() {
    String str = "ab";
}

0 ldc #2 <ab>
2 astore_0
3 return

使用双引号""创建字符串时，JVM会先去常量池中查找是否存在这个字符串对象。

不存在：在 字符串常量池 创建这个字符串对象，并返回地址。
存在：直接返回 字符串常量池 中字符串对象的地址。

2、new关键字

new 关键字声明的字符串，先在堆内存中创建一个字符串对象（new），然后在字符串常量池中创建一个字符串常量（ldc）。

public static void test() {
    String s1 = new String("ab");
    String s2 = "ab";
}

 0 new #3 <java/lang/String>
 3 dup
 4 ldc #2 <ab>
 6 invokespecial #4 <java/lang/String.<init> : (Ljava/lang/String;)V>
 9 astore_0
10 ldc #2 <ab>
12 astore_1
13 return

使用 new 创建字符串时，JVM也会先去常量池中查找是否存在这个字符串对象。

不存在：先在堆内存中创建一个字符串对象，然后在字符串常量池中创建一个字符串常量。
存在：直接在堆内存中创建另一个字符串对象。

public static void test() {
    String s1 = new String("ab");
    String s2 = "ab";
    System.out.println(s1 == s2); // false
}

3、StringBuilder.toString()

从下面的源码可以看到，StringBuilder的toString()其实会new一个String对象

public final class StringBuilder extends AbstractStringBuilder implements Serializable, CharSequence {
    @Override
    public String toString() {
        // Create a copy, don't share the array
        return new String(value, 0, count);
    }
}

需要注意的是，StringBuilder.toString() 不会在常量池中创建对象，下面写个例子分析一下。

public static void test() {
    StringBuilder stringBuilder = new StringBuilder("a");
    stringBuilder.append("b");
    String str = stringBuilder.toString();
}

 0 new #5 <java/lang/StringBuilder>
 3 dup
 4 ldc #6 <a>
 6 invokespecial #7 <java/lang/StringBuilder.<init> : (Ljava/lang/String;)V>
 9 astore_0
10 aload_0
11 ldc #8 <b>
13 invokevirtual #9 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
16 pop
17 aload_0
18 invokevirtual #10 <java/lang/StringBuilder.toString : ()Ljava/lang/String;>
21 astore_1
22 return

可以看到没有出现 ldc #x <ab>，可见StringBuilder.toString() 只在堆内存创建了一个字符串，并没有放到字符串常量池

4、intern() 方法

@Test
public void test() {
    String s1 = "nb";
    String s2 = "n";
    String s3 = s2 + "b";
    String s4 = s3.intern(); // 常量池中存在，返回常量池中的地址

    System.out.println(s1 == s3); // false
    System.out.println(s1 == s4); // true
}

关于intern()方法下面会详细展开。

5、小结

什么情况下，字符串会被放入字符串常量池呢？

注意：StringBuilder.toString()生成的字符串，是不会放到字符串常量池中的，只会在堆中创建一份。

三、字符串拼接

1、常量+常量

场景1：常量与常量拼接，拼接结果在字符串常量池，原理是编译期优化

public class AppendTest {
    public void test() {
        String s1 = "a" + "b" + "c";
        String s2 = "abc";
        System.out.println(s1 == s2); // true
    }
}

从 class文件的反编译结果可以看出：编译器做了优化，将 "a" + "b" + "c" 优化成了 "abc"

 0 ldc #2 <abc>
 2 astore_0
 3 ldc #2 <abc>
 5 astore_1
 6 getstatic #3 <java/lang/System.out : Ljava/io/PrintStream;>
 9 aload_0
10 aload_1
11 if_acmpne 18 (+7)
14 iconst_1
15 goto 19 (+4)
18 iconst_0
19 invokevirtual #4 <java/io/PrintStream.println : (Z)V>
22 return

从 IDEA 的 AppendTest.class 也可以直接看出来

public class AppendTest {
    public AppendTest() {}

    public void test() {
        String s1 = "abc";  // 显示 String s1 = "abc"; 说明做了代码优化
        String s2 = "abc";
        System.out.println(s1 == s2);
    }
}

2、变量拼接

场景2：拼接中只要有一个是变量，拼接结果就在堆中，原理是StringBuilder的append操作。

public void test2() {
    String s1 = "n";
    String s2 = "b";

    String s3 = "nb";
    String s4 = "n" + "b"; // 编译期优化
    String s5 = s1 + "b";
    String s6 = "n" + s2;
    String s7 = s1 + s2;

    System.out.println(s3 == s4); // true
    System.out.println(s3 == s5); // false
    System.out.println(s3 == s6); // false
    System.out.println(s3 == s7); // false
    System.out.println(s5 == s6); // false
    System.out.println(s5 == s7); // false
    System.out.println(s6 == s7); // false

    // 这里使用intern()，会返回常量池中"nb"的地址并赋给s8（这里先了解，具体用法后续会详细展开）
    String s8 = s7.intern();
    System.out.println(s3 == s8); // true
}

下面我们从 class文件的反编译结果进行分析

  0 ldc #5 <n>
  2 astore_1
  3 ldc #6 <b>
  5 astore_2
  6 ldc #7 <nb>
  8 astore_3
  9 ldc #7 <nb>
 11 astore 4

s4之前都是【例1】的内容，这里就不赘述了，主要看一下 s5、s6、s7 这三行

可以看出，都是先 new 了一个 StringBuilder 对象，然后使用 append() 拼接，最后调用了 toString() 创建 String对象并赋值

 13 new #8 <java/lang/StringBuilder>
 16 dup
 17 invokespecial #9 <java/lang/StringBuilder.<init> : ()V>
 20 aload_1
 21 invokevirtual #10 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
 24 ldc #6 <b>
 26 invokevirtual #10 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
 29 invokevirtual #11 <java/lang/StringBuilder.toString : ()Ljava/lang/String;>
 32 astore 5

 34 new #8 <java/lang/StringBuilder>
 37 dup
 38 invokespecial #9 <java/lang/StringBuilder.<init> : ()V>
 41 ldc #5 <n>
 43 invokevirtual #10 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
 46 aload_2
 47 invokevirtual #10 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
 50 invokevirtual #11 <java/lang/StringBuilder.toString : ()Ljava/lang/String;>
 53 astore 6

 55 new #8 <java/lang/StringBuilder>
 58 dup
 59 invokespecial #9 <java/lang/StringBuilder.<init> : ()V>
 62 aload_1
 63 invokevirtual #10 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
 66 aload_2
 67 invokevirtual #10 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
 70 invokevirtual #11 <java/lang/StringBuilder.toString : ()Ljava/lang/String;>
 73 astore 7

3、final变量拼接

场景3：final修饰的String变量，视作String常量。

public static void test3() {
    final String s1 = "n";
    final String s2 = "b";

    String s3 = "nb";
    String s4 = "n" + "b"; // 编译期优化
    String s5 = s1 + "b";
    String s6 = "n" + s2;
    String s7 = s1 + s2;

    System.out.println(s3 == s4); // true
    System.out.println(s3 == s5); // true
    System.out.println(s3 == s6); // true
    System.out.println(s3 == s7); // true
    System.out.println(s5 == s6); // true
    System.out.println(s5 == s7); // true
    System.out.println(s6 == s7); // true
}

可以看到，我们只是在String变量前加上final，结果就完全不同了。

下面我们看一下 class文件的反编译结果

  0 ldc #6 <n>
  2 astore_0
  3 ldc #7 <b>
  5 astore_1
  6 ldc #8 <nb>
  8 astore_2
  9 ldc #8 <nb>
 11 astore_3
 12 ldc #8 <nb>
 14 astore 4
 16 ldc #8 <nb>
 18 astore 5
 20 ldc #8 <nb>
 22 astore 6

可以看出，String变量被final修饰之后，所有的拼接操作都在编译期优化了，而没有使用StringBuilder

4、拼接小结

常量与常量拼接：
- 拼接结果在字符串常量池，原理是编译期优化
拼接中只要有一个是变量：
- 拼接结果在堆中，原理是先new 一个StringBuilder，然后用append()拼接，最后调用 toString() 返回结果
- 补充说明：在 jdk5 之前使用的是 StringBuffer，在 jdk5 之后，改为了 StringBuilder，
final修饰的String变量拼接：
- 拼接结果在字符串常量池，仍然使用编译期优化，而非StringBuilder。

因此，在开发中能使用上final的时候还是建议使用

5、+拼接 vs append拼接

public class StringAppendTest {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();

//        String s1 = append1(100000); // 1670ms
        String s2 = append2(100000);   // 4ms

        long end = System.currentTimeMillis();
        System.out.println("拼接花费的时间为：" + (end - start));
    }

    public static String append1(int highLevel) {
        String str = "";
        for (int i = 0; i < highLevel; i++) {
            str = str + "a";  // 每次循环都会创建一个StringBuilder、String
        }
        return str;
    }

    public static String append2(int highLevel) {
        StringBuilder strBuilder = new StringBuilder();
        for (int i = 0; i < highLevel; i++) {
            strBuilder.append("a"); // 只需要创建一个StringBuilder
        }
        return strBuilder.toString();
    }
}

结论：通过StringBuilder的append()的方式拼接字符串的效率，远远高于 + 拼接

原因：

StringBuilder的append()的方式：
- 自始至终中只创建过一个StringBuilder的对象。
+ 拼接的方式：
- 每一次字符串变量拼接的过程，都会new一个StringBuilder对象（这从之前的反编译结果中也可以看出来）

因此使用字符串变量+拼接会占用更大的内存，产生大量垃圾字符串，如果发生了GC，也会花费额外的时间。

6、StringBuilder的扩容

StringBuilder 空参构造器的初始化大小为16，超过该大小会进行扩容，涉及数组的copy操作

public StringBuilder() {    
    super(16);
}

如果提前知道需要拼接 String 的长度，就应该直接使用带参构造器指定capacity，以减少扩容的次数

public StringBuilder(int capacity) {    
    super(capacity);
}

7、优化小结

允许的情况下尽量使用final。这样拼接操作会在编译期优化，而不会创建StringBuilder对象去append。
使用StringBuilder的append()效率要高于使用+拼接。
如果知道最终的字符串长度，应该使用带容量的构造器创建StringBuilder，避免频繁扩容。

四、new String() 会创建几个对象

1、单独new

场景1：new String("ab") 会创建几个对象？（答案是2个）

 0: new           	#2                  // class java/lang/String
 3: dup
 4: ldc           	#3                  // String ab
 6: invokespecial 	#4                  // Method java/lang/String."<init>":(Ljava/lang/String;)V
 9: astore_1
10: return

对象1  new String("ab")
对象2  常量池中的"ab"

2、常量拼接 new

场景2："a" + new String("b") 会创建几个对象？（答案是5个）

 0: new            	#2                  // class java/lang/StringBuilder
 3: dup
 4: invokespecial  	#3                  // Method java/lang/StringBuilder."<init>":()V
 7: ldc            	#4                  // String a
 9: invokevirtual  	#5                  // Method java/lang/StringBuilder.append:
12: new           	#6                  // class java/lang/String
15: dup
16: ldc           	#7                  // String b
18: invokespecial 	#8                  // Method java/lang/String."<init>":(Ljava/lang/String;)V
21: invokevirtual 	#5                  // Method java/lang/StringBuilder.append:
24: invokevirtual 	#9                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
27: astore_1
28: return

对象1	 new StringBuilder()
对象2  常量池中的"a"
对象3  new String("b")
对象4  常量池中的"b"   
对象5  StringBuilder.toString() 会 new String("ab")

注意：StringBuilder.toString 不会在字符串常量池中生成 "ab"。

3、new 拼接 new

场景3：new String("a") + new String("b") 会创建几个对象？（答案是6个）

 0: new           	#2                  // class java/lang/StringBuilder
 3: dup
 4: invokespecial 	#3                  // Method java/lang/StringBuilder."<init>":()V
 7: new           	#4                  // class java/lang/String
10: dup
11: ldc           	#5                  // String a
13: invokespecial 	#6                  // Method java/lang/String."<init>":(Ljava/lang/String;)V
16: invokevirtual 	#7                  // Method java/lang/StringBuilder.append:
19: new           	#4                  // class java/lang/String
22: dup
23: ldc           	#8                  // String b
25: invokespecial 	#6                  // Method java/lang/String."<init>":(Ljava/lang/String;)V
28: invokevirtual 	#7                  // Method java/lang/StringBuilder.append:
31: invokevirtual 	#9                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
34: astore_1
35: return

对象1	 new StringBuilder()
对象2  new String("a")
对象3  常量池中的"a"
对象4  new String("b")
对象5  常量池中的"b"   
对象6  StringBuilder.toString() 会 new String("ab")

注意：StringBuilder.toString 不会在字符串常量池中生成 "ab"。

五、intern()

intern是一个native方法，底层调用的是C的方法

public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
    public native String intern();
}

1、intern() 的作用

调用intern()时，会判断字符串常量池中是否已存在当前字符串（通过equals()方法判断）

已存在：返回字符串常量池中已存在的该字符串对象的地址；
不存在：将该字符串放入字符串常量池，并返回字符串对象的地址（这里jdk7前后略有不同）
- JDK1.6中：会把调用对象复制一份（新的引用地址），放入常量池，并返回新的引用地址。
- JDK1.7起：会把调用对象的引用地址复制一份（相同的引用地址），放入常量池，并返回调用对象的引用地址。

也就是说，任意字符串调用intern() 返回结果所指向的那个类实例，必定和直接以常量形式出现的字符串实例完全相同。

 ("a"+"b"+"c").intern() == "abc" // true;

intern()可以确保字符串在内存里只有一份（即字符串常量池中的），可以节约内存空间，加快字符串操作任务的执行速度。

2、案例分析

1）案例1

public void test() {
    String s1 = new String("a");
    s1.intern();
    String s2 = "a";
    System.out.println(s1 == s2);  // jdk6/7/8 false
}

s1记录的是堆中new String("a")的地址
s2记录的是字符串常量池中"a"的地址

2）案例2

public void test() {
    String s1 = new String("a") + new String("b");
    s1.intern();
    String s2 = "ab";
    System.out.println(s1 == s2);  // jdk6 false ; jdk7/8 true
}

s1记录的是堆中"ab"的地址（注意，这个"ab"是StringBuilder.toString()生成的，没有往常量池里放）
s1.intern()调用这个方法之前，字符串常量池中并不存在"ab"，所以要把"ab"放入字符串常量池
- jdk6中：字符串常量池中的"ab"指向新的地址。
- jdk7起：字符串常量池中的"ab"指向的是调用intern()的s1的地址
s2记录的是字符串常量池中的"ab"指向的地址

3）案例3

public void test() {
    String s1 = new String("a") + new String("b");
    String s2 = s1.intern();		 // 常量池没有"ab"，会放入
    System.out.println(s1 == "ab");  // jdk6 false ; jdk7/8 true
    System.out.println(s2 == "ab");  // jdk6 true  ; jdk7/8 true       
}

public void test() {
    String s1 = "ab";			   // 常量池中创建一个新的对象"ab"
    String s2 = new String("a") + new String("b");
    String s3 = s2.intern();	   // 常量池已有"ab"，不会再放入
    System.out.println(s1 == s2);  // jdk6/7/8  false
    System.out.println(s1 == s3);  // jdk6/7/8  true     
}

3、intern() 的效率：空间角度

public class StringInternTest {    
    static final int MAX_COUNT = 1000 * 10000;    
    static final String[] arr = new String[MAX_COUNT];   
    
    public static void main(String[] args) {        
        Integer [] data = new Integer[]{1,2,3,4,5,6,7,8,9,10};      
        
        long start = System.currentTimeMillis();  
        for (int i = 0; i < MAX_COUNT; i++) {            
// 			arr[i] = new String(String.valueOf(data[i%data.length]));    		 // 不用intern   7256ms    
            arr[i] = new String(String.valueOf(data[i%data.length])).intern();   // 使用intern   1395ms
        }       
        long end = System.currentTimeMillis();   
        System.out.println("花费的时间为：" + (end - start));    
        
        try {           
            Thread.sleep(1000000);      
        } catch (Exception e) {      
            e.getStackTrace();    
        }  
        System.gc();
    }
}

直接new：堆和字符串常量池可能会存在相同的字符串的两个对象。
使用intern()：保证内存中相同的字符串对象只会有一个。

结论：对于程序中大量使用存在的字符串时，尤其存在很多已经重复的字符串时，使用 intern()方法能够节省内存空间。

4、运行时内存案例

class Memory {
    public static void main(String[] args) {
        int i = 1;
        Object obj = new Object();
        Memory mem = new Memory();
        mem.foo(obj);
    }

    private void foo(Object param) {
        String str = param.toString().intern();
        System.out.println(str);	// java.lang.Object@42a57993
    }
}

因篇幅问题不能全部显示，请点此查看更多更全内容

查看全文