深入理解String类

形如 "abc" 的字面值都是 String 类的实例；我们可以对字符串进行比较、查找、截取、大小写转换等操作；

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

    /** Cache the hash code for the string */
    private int hash; // Default to 0
    ...
}

从上面的部分源码我们可以看出

1. String类被final关键字修饰，意味着String类不能被继承，并且它的成员方法都默认为final方法；字符串一旦创建就不能再修改
2. String类实现了Serializable、CharSequence、 Comparable接口
3. String实例的值是通过字符数组实现字符串存储的S

"+"连接符

原理：

字符串对象可以使用“+”连接其他对象。其中字符串连接是通过 StringBuilder（或 StringBuffer）类及其append 方法实现的，对象转换为字符串是通过 toString 方法实现的

测试用例

/**
 * 测试代码
 */
public class Test {
    public static void main(String[] args) {
        int i = 10;
        String s = "abc";
        System.out.println(s + i);
    }
}

/**
 * 反编译后
 */
public class Test {
    public static void main(String args[]) {    //删除了默认构造函数和字节码
        byte byte0 = 10;      
        String s = "abc";      
        System.out.println((new StringBuilder()).append(s).append(byte0).toString());
    }
}

由上可以看出，Java中使用"+"连接字符串对象时，会创建一个StringBuilder()对象，并调用append()方法将数据拼接，最后调用toString()方法返回拼接好的字符串

 

“+”连接符的效率

使用“+”连接符时，JVM会隐式创建StringBuilder对象，这种方式在大部分情况下并不会造成效率的损失，不过在进行大量循环拼接字符串时则需要注意

String s = "abc";
for (int i=0; i<10000; i++) {
    s += "abc";
}

/**
 * 反编译后
 */
String s = "abc";
for(int i = 0; i < 1000; i++) {
     s = (new StringBuilder()).append(s).append("abc").toString();    
}

我们可以清楚的看到，每一次for循环都会在堆上创建StringBuilder对象，这样就会造成空间的浪费，效率的损失；

所以在这种需要多次拼接字符串的情况下建议在循环外创建StringBuilder对象，通过调用append()方法手动拼接

/**
 * 循环中使用StringBuilder代替“+”连接符
 */
StringBuilder sb = new StringBuilder("abc");
for (int i = 0; i < 1000; i++) {
    sb.append("abc");
}
sb.toString();

当"+"两端均为编译期确定的字符串常量时，编译器会进行相应的优化，直接将两个字符串常量拼接好，例如：

System.out.println("Hello" + "World");

/**
 * 反编译后
 */
System.out.println("HelloWorld");

/**
 * 编译期确定
 * 对于final修饰的变量，它在编译时被解析为常量值的一个本地拷贝存储到自己的常量池中或嵌入到它的字节码流中。
 * 所以此时的"a" + str2和"a" + "b"效果是一样的。故结果为true。
 */
String str1 = "ab"; 
final String str2 = "b"; 
String str3 = "a" + str2;  
System.out.println((str1 == str3)); //true

/**
 * 编译期无法确定
 * 这里面虽然将str2用final修饰了，但是由于其赋值是通过方法调用返回的，那么它的值只能在运行期间确定
 * 因此str1和str3指向的不是同一个对象，故上面程序的结果为false。
 */
String str1 = "ab"; 
final String str2 = get(); 
String str3 = "a" + str1; 
System.out.println((str1 == str3)); //false 
 
public String get() {  
    return "b";   
}

"+"连接符拼接字符串常量时效率很高，因为会在编译期间进行拼接；例如 "l" + "miss" + "you" + "kobe"，在编译期间会优化为

"lmissyoukobe"

字符串常量池

JVM内存区域中，有三种常量池：Class常量池，运行时常量池，字符串常量池；

因为字符串常量池空间有限，所以当在实例化字符串的时候会进行优化：每当创建字符串常量时，JVM会先在字符串常量池中查找该字符串是否已经存在常量池中，如果存在，会直接返回常量池中的实例引用，如果不存在，就会实例化该字符串并且将其放在常量池中，再返回该实例的引用；由于String字符串的不可变性，常量池中一定不存在两个相同的字符串

1.直接赋值

/**
 * 字符串常量池中的字符串只存在一份！
 * 运行结果为true
 */
String str1 = "hello world!";
String str2 = "hello world!";
System.out.println(str1 == str2);//true

2.采用构造方法

String str = new String("hello") ;

这样的做法有两个缺点:

1. 如果使用String构造方法就会开辟两块堆内存空间，并且其中一块堆内存将成为垃圾空间(字符串常量 "hello" 也是一个匿名对象, 用了一次之后就不再使用了, 就成为垃圾空间, 会被 JVM 自动回收掉).
2. 字符串共享问题. 同一个字符串可能会被存储多次, 比较浪费空间

这里有一个思考的问题：String str = new String("hello") 创建了几个对象？

我们可以把上面这行代码分成String str、=、"abc"和new String()四部分来看待。String str只是定义了一个名为str的String类型的变量，因此它并没有创建对象；=是对变量str进行初始化，将某个对象的引用（或者叫句柄）赋值给它，显然也没有创建对象；现在只剩下new String("abc")了。

我们查看String类的源码就会发现，它有一个value属性，保存着String对象的值，类型是char[]，这也正说明了字符串就是字符的序列；

当执行String a="abc";时，JAVA虚拟机会在栈中创建三个char型的值'a'、'b'和'c'，然后在堆中创建一个String对象，它的值（value）是刚才在栈中创建的三个char型值组成的数组{'a','b','c'}，最后这个新创建的String对象会被添加到字符串池中。如果我们接着执行String b=new String("abc");代码，由于"abc"已经被创建并保存于字符串池中，因此JAVA虚拟机只会在堆中新创建一个String对象，但是它的值（value）是共享前一行代码执行时在栈中创建的三个char型值值'a'、'b'和'c'

所以String str = new String("hello")创建了两个对象

 

String类中两种对象实例化的区别

• 直接赋值：只会开辟一块堆内存空间，并且该字符串对象可以自动保存在对象池中以供下次使用

• 构造方法：会开辟两块堆内存空间，其中一块成为垃圾空间，不会自动保存在对象池中，可以使用
  intern()方法手工入池
   

intern方法

直接使用双引号声明出来的String对象会直接存储在字符串常量池中，如果不是用双引号声明的String对象，可以使用String提供的intern方法。intern 方法是一个native方法，intern方法会从字符串常量池中查询当前字符串是否存在，如果存在，就直接返回当前字符串；如果不存在就会将当前字符串放入常量池中，之后再返回
 

// 该字符串常量并没有保存在对象池之中
String str1 = new String("hello") ;
String str2 = "hello" ;
System.out.println(str1 == str2);
// 执行结果
false
String str1 = new String("hello").intern() ;
String str2 = "hello" ;
System.out.println(str1 == str2);
// 执行结果
true

String、StringBuilder和StringBuffer

1. String是不可变序列
2. StringBuilder和StringBuffer是可变序列
3. StringBuilder是线程不安全的，StringBuffer是线程安全的
4. 执行速度StringBuilder > StringBuffer > String

总结

public static void main(String[] args) {
    String s1 = "AB";
    String s2 = new String("AB");
    String s3 = "A";
    String s4 = "B";
    String s5 = "A" + "B";
    String s6 = s3 + s4;
    System.out.println(s1 == s2);
    System.out.println(s1 == s5);
    System.out.println(s1 == s6);
    System.out.println(s1 == s6.intern());
    System.out.println(s2 == s2.intern());
}

需要明确三点

1. 直接使用双引号声明出来的String对象会直接存储在常量池中；
2. String对象的intern方法会得到字符串对象在常量池中对应的引用，如果常量池中没有对应的字符串，则该字符串将被添加到常量池中，然后返回常量池中字符串的引用；
3. 字符串的+操作其本质是创建了StringBuilder对象进行append操作，然后将拼接后的StringBuilder对象用toString方法处理成String对象