java中String声明与内存分配

Java中String s1 ; String s2=null ; String s3=”” ; String s4=new String(“”) ; 的区别。

====================================================================== 当声明为String s1时
声明一个字符串对象，分配了一个内存空间，没有进行初始化，没有存入任何对象。

成员变量：
JA V A为安全原因不允许一个悬挂引用，没有赋值的引用地址一律自动赋值为NULL，以防止访问到任意内存。

局部变量：
局部变量是不会自动初始化的，必须显示地赋初始值。

如果没有赋初始值，在用System.out.println(s1);时会报错。

---------------------------------------------------------------------------------------------------------------------- 当声明为String s2 = null时
声明一个字符串对象，分配了一个内存空间，进行初始化，存入了一个空对象，值为空。

NULL代表声明了一个空对象，根本就不是一个字符串。

除了=和==，对空对象做任何操作都不行的，运行时会报异常。

---------------------------------------------------------------------------------------------------------------------- 当声明为String s3 = “”时
声明一个字符串对象，分配了一个内存空间，初始化，存了一个字符串对象，值为””。

是在字符串常量池（栈中）存入了一个字符串常量，并用引用指向他。

--------------------------------------------------------------------------------------------------------------------
当声明为String s3 = new String(“” ) 时
声明一个字符串对象，分配了一个内存空间，初始化，存了一个字符串对象
是在堆中创建一个字符串对象，并把引用放在栈中指向他的首地址。

Java 把内存划分成两种：一种是栈内存，另一种是堆内存。

在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的
栈内存中分配，当在一段代码块定义一个变量时，Java 就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java 会自动
释放掉为该变量分配的内存空间，该内存空间可以立即被另作它用。

堆内存用来存放由new 创建的对象和数组，在堆中分配的内存，由Java 虚拟机的自动垃圾回收器来管理。

在堆中产生了一个数
组或者对象之后，还可以在栈中定义一个特殊的变量，让栈中的这个变量的取值等于数组或对象在堆内存中的首地址，栈中的这个
变量就成了数组或对象的引用变量，以后就可以在程序中使用栈中的引用变量来访问堆中的数组或者对象，引用变量就相当于是为
数组或者对象起的一个名称。

引用变量是普通的变量，定义时在栈中分配，引用变量在程序运行到其作用域之外后被释放。

而数组
和对象本身在堆中分配，即使程序运行到使用new 产生数组或者对象的语句所在的代码块之外，数组和对象本身占据的内存不会
被释放，数组和对象在没有引用变量指向它的时候，才变为垃圾，不能在被使用，但仍然占据内存空间不放，在随后的一个不确定
的时间被垃圾回收器收走（释放掉）。

这也是Java 比较占内存的原因。

实际上，栈中的变量指向堆内存中的变量，这就是Java 中的指针！
1. 首先String不属于8种基本数据类型，String是一个对象。

String的默认值是null；但它又是一种特殊的对象，有其它对象没有的一些特性。

2. new String()和new String(”")都是申明一个新的空字符串，是空串不是null；
3. String str=”kvill”；String str=new String (”kvill”);的区别：
常量池(constant pool)指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。

它包括了关于类、方法、接口等中的常量，也包括字符串常量。

首先，我们要知结果为道Java会确保一个字符串常量只有一个拷贝。

当一个字符串由多个字符串常量连接而成时，它自己肯定也是字符串常量。

用new String() 创建的字符串不是常量，不能在编译期就确定，所以new String() 创建的字符串不放入常量池中，它们有自己的地址空间。

4. String.intern()：
存在于.class文件中的常量池，在运行期被JVM装载，并且可以扩充。

String的intern()方法就是扩充常量池的。

一个方法；当一个String实例str调用intern()方法时，Java查找常量池中是否有相同Unicode的字符串常量，如果有，则返回其的引用，如果没有，则在常量池中增加一个Unicode等于str的字符串并返回它的引用；
在这个类中我们没有声名一个”kvill”常量，所以常量池中一开始是没有”kvill”的，当我们调用s1.intern()后就在常量池中
新添加了一个”kvill”常量，原来的不在常量池中的”kvill”仍然存在，也就不是“将自己的地址注册到常量池中”了。

s1==s1.intern()为false说明原来的”kvill”仍然存在；s2现在为常量池中”kvill”的地址，所以有s2== s1.intern()为true。

5. 关于equals()和==:
这个对于String简单来说就是比较两字符串的Unicode序列是否相当，如果相等返回true;而==是比较两字符串的地址是否相同，也
就是是否是同一个字符串的引用。

6. 关于String是不可变的
这一说又要说很多，大家只要知道String的实例一旦生成就不会再改变了。

比如说：String str=”kv”+”ill”+” “+”ans”;就是有4个字符串常量，首先”kv”和”ill”生成了”kvill”存在内存中，然后”kvill”又和” ” 生成“kvill “存在内存中，最后又和生成了”kvill ans”;并把这个字符串的地址赋给了str,就是因为Stri ng的”不可变”产生了很多临时变量，这也就是为什么建议用StringBuffer的原因了，因为StringBuff er是可改变的。

单独的这样一条语句String str=”kv”+”ill”+” “+”ans”;应该不会产生临时变量吧，等号后面的一长串东西应该在编译期就直接变成一个常量字符串，放在常量池里了。

做了个测试：
源代码
public class Test{
public static void main(String[] s){
String b=”xxx”;
String a=”bbb”+”ccc”+”ddd”;
System.out.println(a+b);
}
}
javac 编译后，用javap看他的机器码。

public static void main(ng.String[]);
Code:
0: ldc #2; //String xxx
2: astore_1
3: ldc #3; //String bbbcccddd
5: astore_2
6: getstatic #4; //Field java/lang/System.out:Ljava/io/PrintStream;
9: new #5; //class java/lang/StringBuilder
12: dup
13: invokespecial #6; //Method java/lang/StringBuilder.”":()V
16: aload_2
17: invokevirtual #7; //Method java/lang/StringBuilder.append:(Ljava/lang/
String;)Ljava/lang/StringBuilder;
20: aload_1
21: invokevirtual #7; //Method java/lang/StringBuilder.append:(Ljava/lang/
String;)Ljava/lang/StringBuilder;
24: invokevirtual #8; //Method java/lang/StringBuilder.toString:()Ljava/la
ng/String;
27: invokevirtual #9; //Method java/io/PrintStream.println:(Ljava/lang/Str
ing;)V
30: return
}
可以看到只有一个已经编译成”bbbcccddd”的常量字符串。

可以看到编译器自动调用StringBuilder来处理字符串拼接，编译器还是很AI的。

（StringBuilde r是1.5的新类，1.4应该是StringBuffer，两者区别后面说。

）
到了JDK1.5多了一个StringBuilder类，这个类比StringBuffer应该更快一点，毕竟StringBuf fer是线程安全的。