java字符串池（string pool）和字符串堆（heap）内存分配

java运行环境有一个字符串池（string pool）,由String类维护。

 

执行语句 String str = "abc" 时，首先查看字符串池中是否存在字符串"abc"，如果存在则直接将"abc"地址赋给str ，如果不存在则先在字符串池中新建一个字符串"abc"，然后再将其赋给str。

 

执行语句 String str = new String("abc") 时，不管字符串池中是否存在"abc"，直接新建一个字符串"abc"（注意：新建的字符串"abc" 不是在字符串池中）,然后将其赋给str。

 

前一语句的效率高，后一语句的效率低，因为新建字符串占用内存空间。String str = newString();创建了一个空字符串，与String str = new String("");相同。

 

public String intern()

返回字符串对象的规范化表示形式。一个初始为空的字符串池，它由类String私有地维护。当调用intern()方法时，如果字符串池中已经包含一个等于此String对象的字符串 (用equals(Object)方法确定），则返回字符串池中的字符串。否则，将此String对象添加到字符串池中，并返回此String 对象的引用。它遵循以下规则：对于任意两个字符串s 和 t，当且仅当s.equals(t)为true时，s.intern() == t.intern() 才为true。

 

String.intern();

再补充一点：存在于.class 文件中的常量池，在运行期间被jvm（java virtualmachine）装载，并且可以扩充。String 的 intern()方法就是扩充常量池的一个方法；当一个String实例（instance）str调用intern()方法时，java 查找常量池中是否有相同 unicode的字符串常量，如果有，则返回其引用，如果没有，则在常量池中增加一个unicode 等于str 的字符串并返回其引用。

 

简单例子：

String s = "kvill";

String s1 = new String("kvill");

String s2 = new String("kvill");

System.out.println(s == s1);

s1.intern();

s2 = s2.intern();

System.out.println(s == s1);

System.out.println(s == s1.intern());

System.out.println(s == s2);

输出结果为：

False

False  //虽然执行了s1.intern()，但是它的返回值并没有赋给s1

True

True

 

最后再破除一个错误的理解：

有人说，"使用String.intern()方法可以将一个String类保存到一个全局的String表中，如果具有相同值的unicode字符串已经在这个表中，那么该方法返回表中已有字符串的地址，如果在表中没有相同unicode的字符串，则将自己的地址注册到表中"，如果我们把这个全局的String表理解成常量池的话，最后一句话"如果在表中没有相同值的字符串，则将自己的地址注册到表中"是错的。

简单例子：

String s1 = new String("kvill");

String s2 = s1.intern();

System.out.println(s1 == s1.intern());

System.out.println(s1 + " " + s2);

System.out.println(s2 == s1.intern());

输出结果是：

False

kvill kvill

True

我们没有声明一个"kvill"常量，所以常量池中一开始没有"kvill"的，当我们调用s1.intern()后，就在常量池中新添加了一个"kvill"常量，原来的不在常量池中的"kvill"仍然存在，也就不是"把自己的地址注册到常量池中"了。

 

 

例子1）：

String str1 = "java"; // str1指向字符串池

String str2 = "blog"; // str2指向字符串池

 

String s = str1 + str2; // s是指向堆中值为"javablog"的对象，+运算符会在堆中建立起来两个String对象，这两个对象分别是"java","blog"，也就是说从字符串池中复制这两个值，然后在堆中创建两个对象，然后再建立对象s，然后将"javablog"的堆地址赋给s。// 这条语句总共创建了多少个对象？

 

System.out.println(s == "javablog"); // 结果为False

jvm（java virtual machine）确实对形如String str1 = "java";的String对象放在常量池中，但是它是在编译时那么做的，而String s = str1 + str2;是在运行时才知道的，也就是说str1 + str2 是在堆里创建的，所以结果为false了。

 

如果改成以下两种方式：

String s = "java" + "blog";  //直接将"javablog"放入字符串池中

System.out.println(s == "javablog");  //结果为true

String s = str1 + "blog"; // 不放入字符串池，而是在堆中分配

System.out.println(s == "javablog"); // 结果为false

 

 

 

引用变量与对象的区别：

字符串"abc" 是一个String 对象，字符串池（pool of literalstrings）和堆（heap）中存放着字符串对象

 

一、引用变量与对象

A a;

这个语句声明了一个类A的引用变量a，而对象一般通过new关键字创建，所以a仅仅是一个引用变量，而不是对象

 

二、java中所有的字符串文字（字符串常量）都是一个String类的对象。有人（特别是c程序员）在一些场合喜欢把字符串"当做/看成"字符数组，这也没有办法，因为字符串与字符数组存在一些内在的联系。事实上，它与字符数组是两种完全不同的对象。

 

三、字符串对象的创建

由于字符串对象的大量使用（它是一个对象，一般而言对象总是在堆（heap）中分配内存）,java中为了节省内存空间和运行时间（如比较字符串时，==比 equals()方法快），在编译阶段就把所有的字符串文字放到一个字符串池（pool of literalstrings）中，而运行时字符串池成为常量池的一部分。字符串池的好处，就是该池中所有相同的字符串常量被合并，只占用一个空间。

 

我们知道，对两个引用变量，使用 == 判断它们的值（引用）是否相等，即是否指向同一个对象：

String s1 = "abc";

String s2 = "abc";

if(s1 == s2) System.out.println("s1,s2 refer to the sameobject");

else System.out.println("trouble");

这里的输出显示，两个字符串文字保存为一个对象，就是说，上面的代码只在字符串池（string pool）中创建了一个对象。

 

现在看看String s = newString("abc");语句，这里"abc"本身就是pool中的一个对象，而在运行时执行newString()时，将pool中的对象复制一份放到heap中，并且把heap中的这个对象的引用交给s持有。ok，这条语句就创建了2个String对象。

 

String s1 = new String("abc");

String s2 = new String("abc");

if(s1 == s2) { } // 不会执行的语句

这里用 ==判断就可知，虽然两个对象的"内容"相同（equals()判断）,但两个引用变量所持有的引用不同，上面的代码创建了几个StringObject？ (三个，pool中一个，heap中两个）

 

 

 

综上所述：

创建字符串有两种方式：两种内存区域（pool vs heap）

1. "" 引号创建的字符串在字符串池中

2. new， new关键字创建字符串时首先查看字符串池（stringpool）中是否有相同值的字符串，如果有，则拷贝一份到堆（heap）中，然后返回堆中的地址；如果字符串池中没有，则在堆中创建一份，然后返回堆（heap）中的地址（注意，此时不需要从堆中复制到池中，否则，将使得堆中的字符串永远是池中的子集，导致浪费字符串池的内存空间）

3. 对字符串进行赋值时，如果右操作数含有一个或一个以上的字符串引用时，则在堆中再建立一个字符串对象，返回引用；如Strings = str1 + "blog"；

比较两个已经存在于字符串池中字符串对象可以用 == 进行，拥有比equals操作更快的速度。