java知识整理-从String开始

字符串拼接

"+"的实现

两个字符串"+"的底层实现是StringBuilder，通过javap -c命令反编译代码之后可以很清楚的看到

public class StringTest2 {
    public static void main(String[] args) {
        String a = "a";
        String b = "b";
        System.out.println(a + b);
    }
}

javap -c StringTest2.class 结果输出

public class com.junhua.base.StringTest2 {
  public com.junhua.base.StringTest2();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: ldc           #2                  // String a
       2: astore_1
       3: ldc           #3                  // String b
       5: astore_2
       6: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
       9: new           #5                  // class java/lang/StringBuilder
      12: dup
      13: invokespecial #6                  // Method java/lang/StringBuilder."<init>":()V
      16: aload_1
      17: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      20: aload_2
      21: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      24: invokevirtual #8                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      27: invokevirtual #9                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      30: return
}

字面量相加的时候，在编译的时候会做优化，不会新建StringBuilder，而是直接将字符串拼接好，然后去新建String对象

String c = "a" + "b";// 不会产生StringBuilder对象

concat字符串拼接

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);
}

字符串常量池

字符串常量池的功能类事于一个StringTable，是一个Hash表的实现，被所有的类共享。在jDK1.7以后，由于可以支持的字符串常量池的长度增加，放在方法区已经不太适合了，就挪到了堆中。同时，新增了常量池大小的设置

-XX:StringTableSize=66666

String s1 = "String";
String s2 = "String";
s1 == s2;

java首先会在缓冲区查找是否有"String"这个常量对象，有就直接将其地址赋给s1，没有就创建一个"String"，然后将其赋给s1;然后String s2 = "String";
java同样会在缓冲区中查找"String"，这次能查找到了，因为s1创建了一个"String",所以会将其地址赋给s2，如此，s1和s2便有了相同的地址。

只有在新建字面量的时候才存在使用常量迟到概念，如果直接新建一个String对象，则是直接开辟一块内存，保持该字符串。

String a1 = new String("String");

intern 方法

如果常量池中有某个字符串对象了，就将该引用返回；否则将创建一个字符串对象放到常量池中，并返回这个引用。intern()方法的关键是始终是用的常量池中的字符串对象，而不是使用堆中的对象。

String b = new String("a").intern();
String a = new String("a");
System.out.println(a == b); //false
String c = "a";
System.out.println(a == c); //true

String对象的创建

String a = new String("String");这个过程会在内存中创建两个对象，一个在heap中，一个在常量池中（如果常量池中已经有了该字符串，则不需要在常量池中创建）。a这个引用指向的是heap中的这个内存区域(对象)。

String b = "String";这个过程首先会去字符串常量池中查找，如果字符串常量池中有值，则直接指向字符串常量池中的地址，如果不存在，则在字符串常量池中新建一个该字符串，并指向该字符串所对应的内存区域。

String的不可变性

String对象是不可变的，一旦生成了，就无法直接修改，每次都会创建新的字符串对象。String内部的用一个char[]来保存，这个属性是一个私有的属性，并不对外提供修改的方法，进而也就无法实现对这个string对象的修改。

StringBuffer vs StringBuilder

字符串是不可变的，每次对字符串的操作都回生成新的对象，舍弃掉老的对象，会造成很多额外的开销。StringBuffer和StringBuilder就是为了解决这个问题而生的。不同点在于StringBuffer是线程安全的，StringBuilder是线程不安全的。append()方法都是采用字符串复制的方法，不同点在于StringBuffer在每个方法上都会加synchronized

StringBuffer和StringBuilder的核心方法append(String)

public AbstractStringBuilder append(String str) {
        if (str == null)
            return appendNull();
        int len = str.length();
        // 对原始数组长度进行扩容
        ensureCapacityInternal(count + len);
        // 将str中的char复制到value这个char数组中
        str.getChars(0, len, value, count);
        count += len;
        return this;
    }