JDK9
字符串常量池
String字符串特点
- 字符串内容不可变
- 因为字符串内容不可变,所有字符串可以共享
- 在JDK8中,String类型的字符串用char[]数组存储;在JDK9中,用byte[]数组存储
JDK8中,String类的部分源码:
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
// 可以看到这里是一个final类型的char数组
private final char value[];
//...
}
JDK9中,String类的部分源码:
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
// 可以看到这里是一个final类型的byte数组
@Stable
private final byte[] value;
//...
}
创建String字符串的方式
构造方法:
- public String()
String s1 = new String()); //空字符串
- public String(char[] array)
char[] arr = {'a', 'b', 'c'}; String s2 = new String(arr);
- public String(byte[] array)
byte[] arr = {97, 98, 99}; String s3 = new String(arr);
直接创建:
String s = "abc";
字符串常量池
先通过下面的例子引出字符串常量池:
public static void main(String[] args) {
String str1 = "abc";
String str2 = "abc";
char[] arr = {'a', 'b', 'c'};
String str3 = new String(arr);
System.out.println(str1 == str2); //true
System.out.println(str1 == str3); //false
System.out.println(str2 == str3); //false
}
对于基本数据类型,== 比较的是数值
对于引用类型,== 比较的是地址值
图解:
也就是说JVM创建字符串的时候,是在堆中创建了一个字节数组,然后把字节数组的首地址保存在了字符串常量池中的字符串对象中,然后把字符串对象的首地址保存在栈中的str1变量中。
但是通过new String()的方式创建字符串,是直接在堆上开辟内存。
String类型的变量不可变,即String a = “hello”;a = a + " world";实际上是新创建栈空间存储"hello world",a的地址值由指向"hello"变为指向"hello world","hello"字符串被丢弃。试想一下,如果进行大量的String类型变量的修改操作,就产生了很多未使用的对象,很浪费内存空间。
String a = "abc";
String a = new String("abc");
String d = new String("abc");
char[] arr = {'a', 'b', 'c'};
String str3 = new String(arr);
String str4 = new String(arr);
StringBuffer和StringBuilder
和String一样,在JDK8中,底层用char数组存储字符串,在JDK9中,底层使用byte数组存储字符串
StringBuffer和StringBuilder类的对象能够被多次的修改,并且不产生新的未使用对象。
StringBuilder类在Java5中被提出,它和StringBuffer之间的最大不同在于StringBuilder的方法不是线程安全的(不能同步访问)。
由于StringBuilder相较于StringBuffer有速度优势,所以多数情况下建议使用StringBuilder类。然而在应用程序要求线程安全的情况下,则必须使用StringBuffer类。
三者的继承结构:
StringBuffer和StringBuilder的线程安全问题
StringBuffer sbuf = new StringBuffer();
sbuf.append(1);
StringBuilder sbui = new StringBuilder();
sbui.append(1);
sbuf的append方法会调用:
@Override
@HotSpotIntrinsicCandidate
public synchronized StringBuffer append(int i) {
toStringCache = null;
super.append(i);
return this;
}
sbui的append方法会调用:
@Override
@HotSpotIntrinsicCandidate
public StringBuilder append(int i) {
super.append(i);
return this;
}
可以看到,StringBuffer类的append方法前加上了synchronized关键字保证了线程安全。但是这两个append方法最终调用的都是父类AbstractStringBuilder中的append方法:
public AbstractStringBuilder append(String str) {
if (str == null) {
return appendNull();
}
int len = str.length();
ensureCapacityInternal(count + len);
putStringAt(count, str);
count += len;
return this;
}
下面通过Java多线程编程测试下StringBuffer和StringBuilder的线程安全问题:
public class RunnableTest implements Runnable {
public StringBuilder str = new StringBuilder("");
// public StringBuffer str = new StringBuffer("");
@Override
public void run() {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
str.append(Thread.currentThread().getName());
System.out.println(str+"--"+str.length());
}
}
public class StringTest {
public static void main(String[] args) {
RunnableTest rt = new RunnableTest();
new Thread(rt, "aa").start();
new Thread(rt, "bb").start();
new Thread(rt, "cc").start();
new Thread(rt, "dd").start();
new Thread(rt, "ee").start();
new Thread(rt, "ff").start();
}
}
使用线程不安全的StringBuilder类时的结果,可以看到字符串的长度计算是有问题的,这就是因为字符串拼接和长度计算的代码块没有保障线程安全:
使用线程安全的StringBuffer类时的结果:
一个小案例
StringBuffer sbuf = new StringBuffer();
String s = null;
sbuf.append(s);
System.out.println(sbuf.length());
结果:
4
看源码:
public AbstractStringBuilder append(String str) {
if (str == null) {
return appendNull();
}
int len = str.length();
ensureCapacityInternal(count + len);
putStringAt(count, str);
count += len;
return this;
}
private AbstractStringBuilder appendNull() {
ensureCapacityInternal(count + 4);
int count = this.count;
byte[] val = this.value;
if (isLatin1()) {
val[count++] = 'n';
val[count++] = 'u';
val[count++] = 'l';
val[count++] = 'l';
} else {
count = StringUTF16.putCharsAt(val, count, 'n', 'u', 'l', 'l');
}
this.count = count;
return this;
}
小结
三者的区别:
- StringBuffer和StringBuilder类型的字符串可以改变,且不会产生新的未使用字符串对象
- String类型的字符串不能在原字符串上做修改
- StringBuffer效率低,线程安全
- StringBuilder(JDK5提出)效率高,非线程安全
如何选择:
- 如果程序运行过程中不需要对字符串进行改变则使用String
- 多线程操作字符串缓冲区下操作大量数据则使用StringBuffer
- 单线程操作字符串缓冲区下操作大量数据则使用StringBuilder