StringTable
String的基本特性
- String:字符串,使用一对 ”” 引起来表示
String s1 = "qaq"
; // 字面量的定义方式String s2 = new String("aqa")
;
- String声明为final的,不可被继承
- String实现了Serializable接口:表示字符串是支持序列化的。还实现了Comparable接口:表示String可以比较大小
- String在JDK8及以前内部是用
final char[] value
存储字符串数据。JDK9时改为final byte[] value
为什么JDK9改变了结构
String类的当前实现将字符存储在char数组中,每个字符使用两个字节(16位)。从许多不同的应用程序收集的数据表明,字符串是堆使用的主要组成部分,而且,大多数字符串对象只包含拉丁字符。这些字符只需要一个字节的存储空间,因此这些字符串对象的内部char数组中有一半的空间将不会使用。
我们将字符串的内部改为byte[]+一个encoding-flag字段。新的String类将根据字符串的内容,来选择用哪种方式存储,如果是存储编码为ISO-8859-1/Latin-1就用一个byte去存,如果是UTF-16,则还是用两个字符去存。
结论:String再也不用char[] 来存储了,改成了byte[]加上编码标记,节约了一些空间
// 之前
private final char value[];
// 之后
private final byte[] value
同时基于String的数据结构,例如StringBuffer和StringBuilder也同样做了修改
*String的不可变性
String:代表不可变的字符序列。简称:不可变性。
- 当对字符串重新赋值时,需要重写指定内存区域赋值,不能使用原有的value进行赋值。
- 当对现有的字符串进行连接操作时,也需要重新指定内存区域赋值,不能使用原有的value进行赋值。
- 当调用String的
replace()
方法修改指定字符或字符串时,也需要重新指定内存区域赋值,不能使用原有的value进行赋值。
通过字面量的方式(区别于new)给一个字符串赋值,此时的字符串值声明在字符串常量池中。
测试
import org.junit.Test;
/**
* String的不可变性
*/
public class StringTest1 {
@Test
public void test1(){
String s1 = "abc"; //字面量定义的方式,"abc"存储在字符串常量池中,相同的值在字符串常量池中只会存储一遍
String s2 = "abc";
System.out.println(s1 == s2);// true,因为它们指向堆空间同一个地址
s1 = "hello";
System.out.println(s1 == s2);// false
System.out.println(s1);
System.out.println(s2);
}
@Test
public void test2(){
String s1 = "abc";
String s2 = "abc";
s2 += "def";
System.out.println(s1);
System.out.println(s2);
}
@Test
public void test3(){
String s1 = "abc";
String s2 = s1.replace('a','m');
System.out.println(s1);// abc
System.out.println(s2);// mbc
}
}
*面试题
public class StringExer {
String str = new String("good");
char [] ch = {'t','e','s','t'};
public void change(String str, char ch []) {
str = "test ok";// 改的是形参,而不是上面的局部变量
ch[0] = 'b';
}
public static void main(String[] args) {
StringExer ex = new StringExer();
ex.change(ex.str, ex.ch);
System.out.println(ex.str);// good
System.out.println(ex.ch);// best
}
}
注意
字符串常量池是不会存储相同内容的字符串的
String的String Pool(常量池)是一个固定大小的Hashtable,默认值大小长度是1009。如果放进String Pool的String非常多,就会造成Hash冲突严重,从而导致链表会很长,而链表长了后,直接会造成的影响就是当调用String.intern时性能会大幅下降。
使用-XX:StringTablesize
可设置StringTable的长度
在jdk6中StringTable是固定的,就是1009的长度,所以如果常量池中的字符串过多就会导致效率下降很快。StringTableSize设置没有要求
在jdk7中,StringTable的长度默认值是60013,StringTablesize设置没有要求
在jdk8中,StringTable可以设置的最小值为1009
测试
GenerateString.java
import java.io.FileWriter;
import java.io.IOException;
/**
* 生成测试常量池所需的文件
* 产生10万个长度不超过10的字符串,包含a-z,A-Z
*/
public class GenerateString {
public static void main(String[] args) throws IOException {
FileWriter fw = new FileWriter("words.txt");
for (int i = 0; i < 100000; i++) {
// 每一行放1-10个字符
int length = (int) (Math.random() * (10 - 1 + 1) + 1);
fw.write(getString(length) + "\n");
}
fw.close();
}
/**
* 每行产生的字符
* @param length
* @return
*/
public static String getString(int length) {
String str = "";
for (int i = 0; i < length; i++) {
//65-90:A-Z
//97-122:a-z
int num = (int) (Math.random() * (90 - 65 + 1) + 65) + (int) (Math.random()*2)*32;
str += (char) num;
}
return str;
}
}
StringTest2.java
import java.io.BufferedReader;
import java.io.FileReader;
/**
* 测试常量池的长度对程序的影响
* -XX:StringTableSize=1009---花费的时间:176
* -XX:StringTableSize=100009---花费的时间:47
*/
public class StringTest2 {
public static void main(String[] args) {
BufferedReader br = null;
try{
br = new BufferedReader(new FileReader("words.txt"));
long start = System.currentTimeMillis();
String data;
while((data = br.readLine())!=null){
data.intern();//如果字符串常量池中没有对应data的字符串的话,则在常量池中生成
}
long end = System.currentTimeMillis();
System.out.println("花费的时间为:" + (end - start));
} catch (Exception e) {
e.printStackTrace();
} finally {
if (br != null) {
try{
br.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}
String的内存分配
在Java语言中有8种基本数据类型和一种比较特殊的类型String。这些类型为了使它们在运行过程中速度更快、更节省内存,都提供了一种常量池的概念。
常量池就类似一个Java系统级别提供的缓存。8种基本数据类型的常量池都是系统协调的,String类型的常量池比较特殊。
它的主要使用方法有两种:
-
直接使用双引号声明出来的String对象会直接存储在常量池中。
- 比如:
String info="qweqwe"
;
- 比如:
-
如果不是用双引号声明的String对象,可以使用String提供的
intern()
方法。
Java 6及以前,字符串常量池存放在永久代
Java 7中 Oracle的工程师对字符串池的逻辑做了很大的改变,即将字符串常量池的位置调整到Java堆内
-
所有的字符串都保存在堆(Heap)中,和其他普通对象一样,这样可以让你在进行调优应用时仅需要调整堆大小就可以了。
-
字符串常量池概念原本使用得比较多,但是这个改动使得我们有足够的理由让我们重新考虑在Java 7中使用
String.intern()
。
Java8元空间,字符串常量池在堆
为什么StringTable从永久代调整到堆中
在JDK 7中,interned字符串不再在Java堆的永久生成中分配,而是在Java堆的主要部分(称为年轻代和年老代)中分配,与应用程序创建的其他对象一起分配。此更改将导致驻留在主Java堆中的数据更多,驻留在永久生成中的数据更少,因此可能需要调整堆大小。由于这一变化,大多数应用程序在堆使用方面只会看到相对较小的差异,但加载许多类或大量使用字符串的较大应用程序会出现这种差异。intern()方法会看到更显著的差异。
- 永久代的默认空间比较小
- 永久代垃圾回收频率低
测试
import java.util.HashSet;
import java.util.Set;
/**
* 查看字符串常量池的位置
* JDK6:-XX:PermSize=6m -XX:MaxPermSize=6m -Xms6m -Xmx6m
* JDK8:-XX:MetaspaceSize=6m -XX:MaxMetaspaceSize=6m -Xms6m -Xmx6m
*
* 1.8.0_181不报OOM,提示Error occurred during initialization of VM MaxMetaspaceSize is too small.
*/
public class StringTest3 {
public static void main(String[] args) {
// 使用Set保持着常量池引用,避免full gc回收常量池行为
Set<String> set = new HashSet<String>();
// 在short可以取值的范围内足以让6MB的PermSize或heap产生OOM了
short i = 0;
while (true){
set.add(String.valueOf(i++).intern());
}
}
}
String的基本操作
Java语言规范里要求完全相同的字符串字面量,应该包含同样的Unicode字符序列(包含同一份码点序列的常量),并且必须是指向同一个String类实例。
public class StringTest4 {
public static void main(String[] args) {
System.out.println();
System.out.println("1");
System.out.println("2");
System.out.println("3");
System.out.println("4");
System.out.println("5");
System.out.println("6");
System.out.println("7");
System.out.println("8");
System.out.println("9");
System.out.println("10");
// 如下的字符串"1"到"10"不会再次加载
System.out.println("1");
System.out.println("2");
System.out.println("3");
System.out.println("4");
System.out.println("5");
System.out.println("6");
System.out.println("7");
System.out.println("8");
System.out.println("9");
System.out.println("10");
}
}
字符串拼接操作
- 常量与常量的拼接结果在常量池,原理是编译期优化
- 常量池中不会存在相同内容的变量
- 只要其中有一个是变量,结果就在堆中。变量拼接的原理是StringBuilder
- 如果拼接的结果调用intern()方法,则主动将常量池中还没有的字符串对象放入池中,并返回此对象地址
public void test1(){
String s1 = "a" + "b" +"c";// 编译期优化:.class文件中就是"abc",所以"a" + "b" + "c"等同于"abc"
String s2 = "abc";//一定是放在字符串常量池中,将此地址赋给s2
System.out.println(s1 == s2);//true
System.out.println(s1.equals(s2));//true
}
public void test2() {
String s1 = "javaEE";
String s2 = "hadoop";
String s3 = "javaEEhadoop";
String s4 = "javaEE" + "hadoop"; // 编译期优化
String s5 = s1 + "hadoop";
String s6 = "javaEE" + s2;
String s7 = s1 + s2;
System.out.println(s3 == s4); // true
System.out.println(s3 == s5); // false
System.out.println(s3 == s6); // false
System.out.println(s3 == s7); // false
System.out.println(s5 == s6); // false
System.out.println(s5 == s7); // false
System.out.println(s6 == s7); // false
String s8 = s6.intern();
System.out.println(s3 == s8); // true
}
从上述的结果我们可以知道:
如果拼接符号的前后出现了变量,则相当于在堆空间中new String(),具体的内容为拼接的结果
而调用intern方法,则会判断字符串常量池中是否存在JavaEEhadoop值,如果存在则返回常量池中的值,否则就在常量池中创建;如果不存在,则在常量池中加载一份javaEEhadoop,并返回此对象的地址
底层原理
案例一
拼接操作的底层其实使用了StringBuilder,在JDK5之后,使用的是StringBuilder,在JDK5之前使用的是StringBuffer
public void test3(){
String s1 = "a";
String s2 = "b";
String s3 = "ab";// 存储在常量池中
String s4 = s1 + s2; // 存储在new对象的堆中
System.out.println(s3 == s4);// false
}
// s1+s2的底层
StringBuilder s = new StringBuilder();
s.append(s1);
s.append(s2);
s.toString(); // 类似于new String("ab");
案例二
字符串拼接操作也不一定使用的都是StringBuilder
-
如果拼接符号左右两边都是字符串常量或常量引用,则仍然使用编译期优化,将其存到字符串常量池中
-
针对于final修饰的类、方法、基本数据类型、引用数据类型,能使用final就使用上final
public static void test4() {
final String s1 = "a";
final String s2 = "b";
String s3 = "ab";
String s4 = s1 + s2;
System.out.println(s3 == s4); // true
}
拼接操作和append性能对比
@Test
public void test6(){
long start = System.currentTimeMillis();
// method1(100000); // 4819
method2(100000); // 7
long end = System.currentTimeMillis();
System.out.println("花费的时间为:"+ (end - start));
}
public void method1(int highLevel) {
String src = "";
for (int i = 0; i < highLevel; i++) {
src += "a"; //每次循环都会创建一个StringBuilder、String
}
}
public void method2(int highLevel) {
// 只需要创建一个StringBuilder
StringBuilder src = new StringBuilder();
for (int i = 0; i < highLevel; i++) {
src.append("a");
}
}
结论:
- 通过StringBuilder的
append()
方式添加字符串的效率,要远远高于String的字符串拼接方法
好处
- StringBuilder的
append()
的方式,自始至终只创建过一个StringBuilder的对象 - 对于String的字符串拼接的方式,需要创建很多StringBuilder对象和调用toString时候创建的String对象
- 内存中由于创建了较多的StringBuilder和String对象,内存占用过大,如果进行GC将会耗费更多的时间
改进的空间
-
我们使用的是StringBuilder的空参构造器,默认的字符串容量是16,然后将原来的字符串拷贝到新的字符串中, 我们也可以默认初始化更大的长度,减少扩容的次数
-
在实际开发中,如果能够确定前前后后需要添加的字符串,不高于某个限定值highlevel,那么建议使用如下的构造器实例化
-
StringBuilder s = new StringBuilder(highLevel);//new char[highLevel]
intern()的使用
intern是一个native方法,调用的是底层C的方法
字符串池最初是空的,由String类私有地维护。在调用intern方法时,如果池中已经包含了由equals(object)方法确定的与该字符串对象相等的字符串,则返回池中的字符串。否则,该字符串对象将被添加到池中,并返回对该字符串对象的引用。
如果不是用双引号声明的string对象,可以使用string提供的intern方法:intern方法会从字符串常量池中查询当前字符串是否存在,若不存在就会将当前字符串放入常量池中。
比如:
String myInfo = new string("I love atguigu").intern();
也就是说,如果在任意字符串上调用string.intern方法,那么其返回结果所指向的那个类实例,必须和直接以常量形式出现的字符串实例完全相同。因此,下列表达式的值必定是true
("a"+"b"+"c").intern()=="abc"
通俗点讲,Interned string就是确保字符串在内存里只有一份拷贝,这样可以节约内存空间,加快字符串操作任务的执行速度。注意,这个值会被存放在字符串内部池(String Intern Pool)
如何保证变量s指向的是字符串常量池中的数据?
方式一:字面量定义的方式
String s = "qwe";
方式二:调用intern()
方法
String s = new String("qwe").intern();
String s = new StringBuilder("qwe").toString().intern();
*面试题
new String(“ab”)会创建几个对象
public class StringNewTest {
public static void main(String[] args) {
String str = new String("ab");
}
}
编译成字节码文件之后,发现会创建两个对象,会在常量池中生成qwe
new String(“a”) + new String(“b”) 会创建几个对象
public class StringNewTest {
public static void main(String[] args) {
String str = new String("a") + new String("b");
}
}
字节码文件,会创建6个对象,不会在常量池中生成ab
引用类型的变量实际保存的都是地址
*intern的面试题
JDK6中
JDK6的常量池是存在永久代里
public class StringIntern {
public static void main(String[] args) {
// 首先new String创建的对象会存入堆空间,然后("1")创建的对象会存入字符串常量池,
// 最后会将堆空间的对象地址返回给s
String s = new String("1");
// intern()会到字符串常量池中查找是否有"1",而“1”在一开始创建s的时候,就存入
// 字符串常量池了,所以intern()不会起什么作用
s.intern();
// s2用的就是字符串常量池中存的("1")的地址
String s2 = "1";
// 结果在jdk6/7/8中均为false
System.out.println(s == s2);
// s3变量记录的地址为:new String("11");这个操作不会在字符串常量池中创建"11"
String s3 = new String("1") + new String("1");
// 在字符串常量池中创建一个"11"的对象
s3.intern();
// s4使用的"11"的地址
String s4 = "11";
System.out.println(s3 == s4); //jdk6:false
}
}
JDK7中
jdk7中有个变化,那就是把常量池放在堆当中了
public class StringIntern {
/**
* intern面试题,在单元测试中测试这个例子,后办单jdk8提示为false
*/
public static void main(String[] args) {
// s3变量记录的地址为:new String("11");这个操作不会在字符串常量池中创建"11"
String s3 = new String("1") + new String("1");
// 此时字符串常量池中并没有创建"11",为了节省空间,创建了一个指向引用堆空间的new String("11")的地址
s3.intern();
// 给s4赋值字面量的时候,会去字符串常量池中找,结果发现字符串常量池的"11"指向的是的堆空间的new String("11")
// 这就相当于,s4也是指向的堆空间的new String("11")
String s4 = "11";
System.out.println(s3 == s4); //jdk7/8:true
}
}
简单拓展
/**
* jdk8
*/
@Test
public void test2(){
// 在堆空间创建的new String("11")
String s3 = new String("1") + new String("1");
// 在字符串常量池中生成的"11"对象
String s4 = "11";
// 发现字符串常量池中已经有"11"对象,所以intern()不起作用
String s5 = s3.intern();
System.out.println(s3 == s4); // false
System.out.println(s4 == s5); // true
}
总结
总结String的intern()
的使用:
JDK1.6中,将这个字符串对象尝试放入串池(字符串常量池)。
- 如果串池中有,则并不会放入。返回已有的串池中的对象的地址
- 如果没有,会把此对象复制一份,放入串池,并返回串池中的对象地址
JDK1.7起,将这个字符串对象尝试放入串池。
- 如果串池中有,则并不会放入。返回已有的串池中的对象的地址
- 如果没有,则会把对象的引用地址复制一份,放入串池,并返回串池中的引用地址
练习一
/**
* intern练习1:jdk6
*/
@Test
public void test3(){
// 在堆空间中new String("ab")
String s = new String("a") + new String("b");
// 在字符串常量池中创建"ab"的对象
String s2 = s.intern();
System.out.println(s2 == "ab"); // true
System.out.println(s =="ab"); // false
}
/**
* intern练习1:jdk8
*/
@Test
public void test3(){
// 在堆空间中new String("ab")
String s = new String("a") + new String("b");
// 将new String("ab")的引用存入常量池
String s2 = s.intern();
// 此时的常量池没有"ab",记录的是new String("ab")的引用,
// 这就意味着s2在字符串常量池存的地址是new String("ab"),它的值也是"ab"
System.out.println(s2 == "ab"); // true
// "ab" = s2,s2 = s.intern(),inter()指向的是new String("ab")
System.out.println(s =="ab"); // true
}
/**
* intern练习1扩展:jdk6/7/8
*/
@Test
public void test3(){
// 通过字面量的方式将“ab”存入常量池
String x = "ab";
// 在堆空间中new String("ab"),不会在常量池中创建"ab"
String s = new String("a") + new String("b");
// 到常量池中查找,发现已有“ab”,直接取出赋值给s2
String s2 = s.intern();
System.out.println(s2 == "ab"); // true
// "ab" = s2,s2 = s.intern(),inter()指向的是new String("ab")
System.out.println(s =="ab"); // false
}
练习二
/**
* inter练习2
*/
@Test
public void test4(){
// 在堆空间创建new String("ab");不会在字符串常量池中创建"ab"
String s1 = new String("a") + new String("b");
// 在常量池中创建了一个指向堆空间的new String("ab")的地址
s1.intern();
// 给s2赋值的时候,去常量池发现"ab"指向的是new String("ab")的引用
String s2 = "ab";
System.out.println(s1 == s2); //true
}
/**
* inter练习2扩展
*/
@Test
public void test5(){
// 在堆空间创建new String("ab");并在字符串常量池中创建"ab"
String s1 = new String("ab");
// 字符串常量池中已有"ab",所以不会起什么作用
s1.intern();
// 赋值字符串常量池的"ab"
String s2 = "ab";
System.out.println(s1 == s2); // false
}
intern的空间效率测试
我们通过测试一下,使用了intern和不使用的时候,其实相差还挺多的
/**
* 从空间的角度上测试intern的效率
*/
public class StringIntern2 {
static final int MAX_COUNT = 1000 * 10000;
static final String[] arr = new String[MAX_COUNT];
public static void main(String[] args) {
Integer[] data = new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
long start = System.currentTimeMillis();
for (int i = 0; i < MAX_COUNT; i++) {
arr[i] = new String(String.valueOf(data[i % data.length]));
// arr[i] = new String(String.valueOf(data[i % data.length])).intern();
}
long end = System.currentTimeMillis();
System.out.println("花费的时间为:" + (end - start));
try{
Thread.sleep(1000000);
}catch(InterruptedException e){
e.printStackTrace();
}
System.gc();
}
}
如果使用上面的这种方式创建对象的话,一方面是在堆空间把这个对象真正的给new出来, 其次在字符串常量池中也会维护这样一个字符串实例,每次去new的时候,如果已经存了一遍1-10, 那后续则不会再放入1-10,因为常量池不会放入重复的数据,但是这一千万个String的对象还是会造出来,又由于数据是放到了数组中,数组也不会释放空间,所以就真的在内存中维护了一千万个String的对象,这是占用的一种情况。
如果使用下面的这种情况,虽然它也会去new对象,同时常量池该维护还维护,但是当我们去调用intern()
方法的时候,此时对于数组来讲,它里面的元素指向的就不是new的对象了,而是常量池里面放的实例,而之前new的这个对象,因为我们之前不用,所以后面也可以做一些销毁,所以使的下面这种方式没有在内存中创建过多的String,换句话说就是,创建完了以后都做了销毁。
结论
对于程序中大量使用存在的字符串时,尤其存在很多重复的字符串时,使用intern()方法能够节省内存空间。
大的网站平台,需要内存中存储大量的字符串。比如社交网站,很多人都存储:北京市、海淀区等信息。这时候如果字符串都调用intern() 方法,就会很明显降低内存的大小。
StringTable的垃圾回收
/**
* 测试StringTable的垃圾回收
* -Xms15m -Xmx15m -XX:+PrintStringTableStatistics -XX:+PrintGCDetails
*/
public class StringGCTest {
public static void main(String[] args) {
// 修改i<的范围 100 10000 100000
for (int i = 0; i < 100000; i++) {
String.valueOf(i).intern();
}
}
}
测试结果
i < 100
i < 10000
i < 100000
结论
通过以上的结果可以发现,字符串常量池中的个数在100、10000的时候,并没有产生GC,而数据量达到100000的时候,进行了YGC,使得堆空间的字符串信息降了下去。
G1中的String去重操作
注意这里说的去重,指的是在堆中的数据,而不是常量池中的,因为常量池中的数据本身就不会重复
描述
背景:对许多Java应用(有大的也有小的)做的测试得出以下结果:
-
堆空间中存活的数据集合里有25%都是String对象
-
堆空间中存活的数据集合里有13.5%都是重复的String对象
-
String对象的平均长度是45
许多大规模的Java应用的瓶颈在于内存,测试表明,在这些类型的应用里面,Java堆中存活的数据集合差不多25%是string对象。更进一步,这里面差不多一半string对象是重复的,重复的意思是说:
string1.equals(string2)= true
。堆上存在重复的string对象必然是一种内存的浪费。这个项目将在G1垃圾收集器中实现自动持续对重复的string对象进行去重,这样就能避免浪费内存。
实现
- 当垃圾收集器工作的时候,会访问堆上存活的对象。对每一个访问的对象都会检查是否是候选的要去重的string对象。
- 如果是,把这个对象的一个引用插入到队列中等待后续的处理。一个去重的线程在后台运行,处理这个队列。处理队列的一个元素意味着从队列删除这个元素,然后尝试去重它引用的string对象。
- 使用一个hashtable来记录所有的被string对象使用的不重复的char数组。当去重的时候,会查这个hashtable,来看堆上是否已经存在一个一模一样的char数组。
- 如果存在,string对象会被调整引用那个数组,释放对原来的数组的引用,最终会被垃圾收集器回收掉。
- 如果查找失败,char数组会被插入到hashtable,这样以后的时候就可以共享这个数组了。
开启
命令行选项
-XX:+UsestringDeduplication(bool)
:开启string去重,默认是不开启的,需要手动开启。-XX:+Printstringbeduplicationstatistics(bool)
:打印详细的去重统计信息-XX:+stringpeduplicationAgeThreshold(uintx)
:达到这个年龄的String对象被认为是去重的候选对象
String/StringBuffer/StringBuilder
String | StringBuffer | StringBuilder |
---|---|---|
String的值是不可变的,这就导致每次对String的操作都会生成新的String对象,不仅效率低下,而且浪费大量优先的内存空间 | StringBuffer是可变类、线程安全的字符串操作类,任何对它指向的字符串操作都不会产生新的对象。每个StringBuffer对象都有一定的缓冲区容量,当字符串大小没有超过容量时,不会分配新的容量,当字符串大小超过容量时,会自动增加容量 | 可变类,速度更快 |
不可变 | 可变 | 可变 |
线程安全 | 线程不安全 | |
多线程操作字符串 | 单线程操作字符串 |