打开凤凰新闻，查看更多高清图片
String作为Java中最常用的引用类型，相对来说基本上都比较熟悉，无论在平时的编码过程中还是在笔试面试中，String都很受到青睐，然而，在使用String过程中，又有较多需要注意的细节之处。
String的连接
@Test
publicvoid contact () {
//1连接方式
String s1 = "a";
String s2 = "a";
String s3 = "a" + s2;
String s4 = "a" + "a";
String s5 = s1 + s2;
//表达式只有常量时，编译期完成计算
//表达式有变量时，运行期才计算，所以地址不一样
System.out.println(s3 == s4); //f
System.out.println(s3 == s5); //f
System.out.println(s4 == "aa"); //t
}
String类型的intern
publicvoid intern () { //2：string的intern使用 //s1是基本类型，比较值。s2是string实例，比较实例地址 //字符串类型用equals方法比较时只会比较值 String s1 = "a"; String s2 = newString("a"); //调用intern时,如果s2中的字符不在常量池，则加入常量池并返回常量的引用 String s3 = s2.intern(); System.out.println(s1 == s2); System.out.println(s1 == s3);}
String类型的equals
//字符串的equals方法// public boolean equals(Object anObject) {// if (this == anObject) {// return true;// }// if (anObject instanceof String) {// String anotherString = (String)anObject;// int n = value.length;// if (n == anotherString.value.length) {// char v1[] = value;// char v2[] = anotherString.value;// int i = 0;// while (n-- != 0) {// if (v1[i] != v2[i])// return false;// i++;// }// return true;// }// }// return false;// }
StringBuffer和Stringbuilder
底层是继承父类的可变字符数组value
/**
* The value is used for character storage.
*/
char[] value;
初始化容量为16
/**
* Constructs a string builder with no characters in it and an
* initial capacity of 16 characters.
*/
publicStringBuilder() {
super(16);
}
这两个类的append方法都是来自父类AbstractStringBuilder的方法
publicAbstractStringBuilder append(String str) {
if (str == null)
return appendNull();
int len = str.length();
ensureCapacityInternal(count + len);
str.getChars(0, len, value, count);
count += len;
returnthis;
}
@Override
publicStringBuilder append(String str) {
super.append(str);
returnthis;
}
@Override
publicsynchronizedStringBuffer append(String str) {
toStringCache = null;
super.append(str);
returnthis;
}
append
Stringbuffer在大部分涉及字符串修改的操作上加了synchronized关键字来保证线程安全，效率较低。
String类型在使用 + 运算符例如
String a = "a"
a = a + a;时，实际上先把a封装成stringbuilder，调用append方法后再用tostring返回，所以当大量使用字符串加法时，会大量地生成stringbuilder实例，这是十分浪费的，这种时候应该用stringbuilder来代替string。
扩容
#注意在append方法中调用到了一个函数
ensureCapacityInternal(count + len);
该方法是计算append之后的空间是否足够，不足的话需要进行扩容
publicvoid ensureCapacity(int minimumCapacity) {
if (minimumCapacity > 0)
ensureCapacityInternal(minimumCapacity);
}
privatevoid ensureCapacityInternal(int minimumCapacity) {
// overflow-conscious code
if (minimumCapacity - value.length > 0) {
value = Arrays.copyOf(value,
newCapacity(minimumCapacity));
}
}
如果新字符串长度大于value数组长度则进行扩容
扩容后的长度一般为原来的两倍 + 2；
假如扩容后的长度超过了jvm支持的最大数组长度MAX_ARRAY_SIZE。
考虑两种情况
如果新的字符串长度超过int最大值，则抛出异常，否则直接使用数组最大长度作为新数组的长度。
privateint hugeCapacity(int minCapacity) {
if (Integer.MAX_VALUE - minCapacity < 0) { // overflow
thrownewOutOfMemoryError();
}
return (minCapacity > MAX_ARRAY_SIZE)
? minCapacity : MAX_ARRAY_SIZE;
}
删除
这两个类型的删除操作：
都是调用父类的delete方法进行删除
publicAbstractStringBuilderdelete(int start, intend) {
if (start < 0)
thrownewStringIndexOutOfBoundsException(start);
if (end > count)
end = count;
if (start > end)
thrownewStringIndexOutOfBoundsException();
int len = end - start;
if (len > 0) {
System.arraycopy(value, start+len, value, start, count-end);
count -= len;
}
returnthis;
}
事实上是将剩余的字符重新拷贝到字符数组value。
这里用到了system.arraycopy来拷贝数组，速度是比较快的
system.arraycopy方法
转自知乎：
在主流高性能的JVM上（HotSpot VM系、IBM J9 VM系、JRockit系等等），可以认为System.arraycopy()在拷贝数组时是可靠高效的——如果发现不够高效的情况，请报告performance bug，肯定很快就会得到改进。
java.lang.System.arraycopy()方法在Java代码里声明为一个native方法。所以最naïve的实现方式就是通过JNI调用JVM里的native代码来实现。
String的不可变性
关于String的不可变性，这里转一个不错的回答
什么是不可变？
String不可变很简单，如下图，给一个已有字符串"abcd"第二次赋值成"abcedl"，不是在原内存地址上修改数据，而是重新指向一个新对象，新地址。
String为什么不可变？
翻开JDK源码，java.lang.String类起手前三行，是这样写的：
publicfinalclassStringimplements java.io.Serializable, Comparable, CharSequence { /** String本质是个char数组. 而且用final关键字修饰.*/ privatefinalchar value[]; ... ... }
首先String类是用final关键字修饰，这说明String不可继承。再看下面，String类的主力成员字段value是个char[]数组，而且是用final修饰的。
final修饰的字段创建以后就不可改变。 有的人以为故事就这样完了，其实没有。因为虽然value是不可变，也只是value这个引用地址不可变。挡不住Array数组是可变的事实。
Array的数据结构看下图。
也就是说Array变量只是stack上的一个引用，数组的本体结构在heap堆。
String类里的value用final修饰，只是说stack里的这个叫value的引用地址不可变。没有说堆里array本身数据不可变。看下面这个例子，
finalint[] value={1,2,3} ；
int[] another={4,5,6};
value=another; //编译器报错，final不可变 value用final修饰，编译器不允许我把value指向堆区另一个地址。
但如果我直接对数组元素动手，分分钟搞定。
finalint[] value={1,2,3};
value[2]=100; //这时候数组里已经是{1,2,100} 所以String是不可变，关键是因为SUN公司的工程师。
在后面所有String的方法里很小心的没有去动Array里的元素，没有暴露内部成员字段。
privatefinalchar value[]这一句里，private的私有访问权限的作用都比final大。而且设计师还很小心地把整个String设成final禁止继承，避免被其他人继承后破坏。所以String是不可变的关键都在底层的实现，而不是一个final。考验的是工程师构造数据类型，封装数据的功力。
不可变有什么好处？
这个最简单地原因，就是为了安全。看下面这个场景（有评论反应例子不够清楚，现在完整地写出来），一个函数appendStr( )在不可变的String参数后面加上一段“bbb”后返回。appendSb( )负责在可变的StringBuilder后面加“bbb”。
总结以下String的不可变性。
1 首先final修饰的类只保证不能被继承，并且该类的对象在堆内存中的地址不会被改变。
2 但是持有String对象的引用本身是可以改变的，比如他可以指向其他的对象。
3 final修饰的char数组保证了char数组的引用不可变。但是可以通过char[0] = a来修改值。不过String内部并不提供方法来完成这一操作，所以String的不可变也是基于代码封装和访问控制的。
举个例子
finalclassFi {
int a;
finalint b = 0;
Integer s;
}
finalchar[]a = {a};
finalint[]b = {1};
@Test
publicvoidfinal修饰类() {
//引用没有被final修饰，所以是可变的。
//final只修饰了Fi类型，即Fi实例化的对象在堆中内存地址是不可变的。
//虽然内存地址不可变，但是可以对内部的数据做改变。
Fi f = newFi();
f.a = 1;
System.out.println(f);
f.a = 2;
System.out.println(f);
//改变实例中的值并不改变内存地址。
Fi ff = f;
//让引用指向新的Fi对象，原来的f对象由新的引用ff持有。
//引用的指向改变也不会改变原来对象的地址
f = newFi();
System.out.println(f);
System.out.println(ff);
}
这里的对f.a的修改可以理解为char[0] = a这样的操作。只改变数据值，不改变内存值。
要理解String里的intern方法，就要注意基本数据类型的拆箱装箱，以及对常量池的理解。
常量池和自动拆箱装箱
自动拆箱和装箱的原理其实与常量池有关。
3.1存在栈中：
publicvoid(int a)
{
int i = 1;
int j = 1;
}
方法中的i 存在虚拟机栈的局部变量表里，i是一个引用，j也是一个引用，它们都指向局部变量表里的整型值 1.
int a是传值引用，所以a也会存在局部变量表。
3.2存在堆里：
class A{
int i = 1;
A a = new A();
}
i是类的成员变量。类实例化的对象存在堆中，所以成员变量也存在堆中，引用a存的是对象的地址，引用i存的是值，这个值1也会存在堆中。可以理解为引用i指向了这个值1。也可以理解为i就是1.
3.3包装类对象怎么存
其实我们说的常量池也可以叫对象池。
比如String a= newString("a").intern()时会先在常量池找是否有“a"对象如果有的话直接返回“a"对象在常量池的地址，即让引用a指向常量”a"对象的内存地址。
public native String intern();
Integer也是同理。
下图是Integer类型在常量池中查找同值对象的方法。
publicstaticInteger valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
returnIntegerCache.cache[i + (-IntegerCache.low)];
returnnewInteger(i);
}
privatestaticclassIntegerCache {
staticfinalint low = -128;
staticfinalint high;
staticfinalInteger cache[];
static {
// high value may be configured by property
int h = 127;
String integerCacheHighPropValue =
sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
if (integerCacheHighPropValue != null) {
try {
int i = parseInt(integerCacheHighPropValue);
i = Math.max(i, 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
} catch( NumberFormatException nfe) {
// If the property cannot be parsed into an int, ignore it.
}
}
high = h;
cache = newInteger[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
cache[k] = newInteger(j++);
// range [-128, 127] must be interned (JLS7 5.1.7)
assertIntegerCache.high >= 127;
}
privateIntegerCache() {}
}
所以基本数据类型的包装类型可以在常量池查找对应值的对象，找不到就会自动在常量池创建该值的对象。
而String类型可以通过intern来完成这个操作。
JDK1.7后，常量池被放入到堆空间中，这导致intern()函数的功能不同，具体怎么个不同法，且看看下面代码，这个例子是网上流传较广的一个例子，分析图也是直接粘贴过来的，这里我会用自己的理解去解释这个例子：
[java] view plain copy
String s = newString("1");
s.intern();
String s2 = "1";
System.out.println(s == s2);
String s3 = newString("1") + newString("1");
s3.intern();
String s4 = "11";
System.out.println(s3 == s4);
输出结果为：
[java] view plain copy
JDK1.6以及以下：falsefalse
JDK1.7以及以上：falsetrue
JDK1.6查找到常量池存在相同值的对象时会直接返回该对象的地址。
JDK 1.7后，intern方法还是会先去查询常量池中是否有已经存在，如果存在，则返回常量池中的引用，这一点与之前没有区别，区别在于，如果在常量池找不到对应的字符串，则不会再将字符串拷贝到常量池，而只是在常量池中生成一个对原字符串的引用。
那么其他字符串在常量池找值时就会返回另一个堆中对象的地址。