一、概述
String是代表字符串的类，本身是一个最终类，使用final修饰，不能被继承。
二、String字符串的特征
1. 字符串在内存中是以字符数组的形式来存储的。
示例如下，可以从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 /** use serialVersionUID from JDK 1.0.2 for interoperability */ private static final long serialVersionUID = -6849794470754667710L; /** * Class String is special cased within the Serialization Stream Protocol. * * A String instance is written into an ObjectOutputStream according to * <a href="{@docRoot}/../platform/serialization/spec/output.html"> * Object Serialization Specification, Section 6.2, "Stream Elements"</a> */ private static final ObjectStreamField[] serialPersistentFields = new ObjectStreamField[0]; /** * Initializes a newly created {@code String} object so that it represents * an empty character sequence. Note that use of this constructor is * unnecessary since Strings are immutable. */ public String() { this.value = "".value; } ... }
2.因为字符串是常量，所以本身是存储在方法区的常量池中。只要字符串的实际值一样，那么用的就是同一个字符串-->字符串是一个常量，字符串是被共享的。直接使用字符串赋值时，在常量池中创建一个字符串对象，然后将栈中的引用指向常量池中的对象。
例如：
String str = "abc"; //重新创建一个地址，使str指向该地址，栈内存直接指向方法区 str = "def"; //在方法区中查找，如果存在，再次指向原地址 str = "abc"; //在方法区中查找，如果存在，新对象也指向原地址 String str2 = "abc"; //栈内存指向堆内存，堆内存指向方法区 String str3 = new String("abc"); System.out.println(str == str2); //true System.out.println(str == str3);
其中，str和str2的地址就是相同的。
当使用new关键字创建String对象时，先在常量池中创建一个字符串常量对象，然后再在堆中new一个字符串对象，将该对象的地址指向常量区；然后在栈中创建一个引用，指向堆中的对象。
String str3 = new String("abc");
相当于在内存中创建了两个对象。其内存结构图如下所示
3. 如果需要拼接多个字符串，建议使用StringBuilder。因为使用StringBuilder拼接一次只产生一个新的对象，而使用+要产生3个对象。 具体示例如下;
String[] arr = new String[100]; String result = ""; //1个对象：共301个 for(int i = 0; i < 100000; i++) { //result = new StringBuilder(result).append(str).toString(); result += arr[i]; //没拼接一次，产生3个对象 } //共：102个对象 //产生一个对象 StringBuilder sb = new StringBuilder(); for(int i = 0; i < 100000000; i++) { //每拼接一次，创建一个对象；一共产生了100个对象 sb.append("a"); } result = sb.toString(); //1个对象
4. String类中，提供了一系列的字符串操作方法，但是都不改变原来字符串，都是产生一个新的字符串。
例如查看获取子串函数的源码
public String substring(int beginIndex, int endIndex) { if (beginIndex < 0) { throw new StringIndexOutOfBoundsException(beginIndex); } if (endIndex > value.length) { throw new StringIndexOutOfBoundsException(endIndex); } int subLen = endIndex - beginIndex; if (subLen < 0) { throw new StringIndexOutOfBoundsException(subLen); } return ((beginIndex == 0) && (endIndex == value.length)) ? this : new String(value, beginIndex, subLen); }
5. String字符串“+”在编译时和运行时的区别
预编译是指编译器会在编译时检测是否存在字符串字面量，如果有字面量相加的情况，会提前将字面量字符串进行合并并存储到常量池中。
/** * 继续-编译期无法确定 */ public void test5(){ String str1="abc"; String str2="def"; String str3 = "abc" +"def" String str4 = str1 + str2; System.out.println("===========test============"); System.out.println(str4 == str3 ); //false }
返回结果分析：因为str4指向堆中的"abcdef"对象，而"abcdef"是字符串池中的对象，所以结果为false。JVM对String str="abc"对象放在常量池中是在编译时做的，而String str4= str1+str2是在运行时刻才能知道的。new对象也是在运行时才做的。而这段代码总共创建了6个对象，字符串池中两个、堆中三个。+运算符会在堆中建立起来两个String对象，这两个对象的值分别是通过StringBuilder创建"abc"和通过append方法创建"abcdef"，最后通过toString方法再建立对象str4,然后将"abcdef"的堆地址赋给str4，而堆中的“abcdef”地址指向常量池中的地址。
步骤：
1) 栈中开辟一块空间存放引用str1，str1指向池中String常量"abc"。
2) 栈中开辟一块空间存放引用str2，str2指向池中String常量"def"。
3) 栈中开辟一块空间存放引用str3，str3指向常量池中String常量“abcdef”。
4) str1 + str2通过StringBuilder的最后一步toString()方法还原一个新的String对象"abcdef"，因此堆中开辟一块空间存放此对象。
5) 引用str4指向堆中(str1 + str2)所还原的新String对象。
6) str4指向的对象在堆中，而常量str3对应的"abcdef"在池中，输出为false。