JAVA 堆栈 关于String那些事

JAVA 中变量分为 1. 基本类型      2.引用类型       基本类型都是值传递， 其他的都是引用传递

                              基本类型有： byte, long, short, int, double, float, boolean, char 没有String 而且都必须是小写

JAVA 的堆栈

JAVA在程序运行时，在内存中划分5片空间进行数据的存储。分别是：1：寄存器。2：本地方法区。3：方法区。4：栈。5：堆。

 

stack堆: 内存全部存放实体对象，用来存放new的对象和数组（ 但是！ 并不是所有对象都在堆中， 也有在常量池的 例如 String）。由虚拟机自动垃圾回收器管理。 JVM 只有一个heap 区， 被所有线程共享， 不存放基本类型跟引用只存放对象本身。 

堆的优势： 堆可以动态改变大小，生存期也不用告诉编译器，但是存取速度较慢 。 堆中的对象的由垃圾回收器负责回收，因此大小和生命周期不需要确定，具有很大的灵活性。

heap栈： 存放1. 基本类型的变量数据和 2. 对象的引用。 栈中的数据大小和生命周期是可以确定的，当没有引用指向数据时，这个数据就会消失

方法区 主要存放一个类的模板和静态方法。

1. 对于字符串：其对象的引用都是存储在栈中的，如果是编译期已经创建好(直接用双引号定义的)的就存储在常量池中，如果是运行期（new出来的）才能确定的就存储在堆中。对于equals相等的字符串，在常量池中永远只有一份，在堆中有多份。 

String s1 = "china";  
String s2 = "china";  
String s3 = "china";  
String ss1 = new String("china");  
String ss2 = new String("china");  
String ss3 = new String("china");  

 

这里解释一下黄色这3个箭头，对于通过new产生一个字符串（假设为”china”）时，会先去常量池中查找是否已经有了”china”对象，如果没有则在常量池中创建一个此字符串对象，然后堆中再创建一个常量池中此”china”对象的拷贝对象。

面试题：String s = new String(“xyz”);产生几个对象？一个或两个，如果常量池中原来没有”xyz”,就是两个。（先在常量池一个"xyz", 再在堆里面创建一个 new String("xyz")， 其中xyz 是由常量池拷贝过来。 

2. 对于基础类型的变量和常量 ： 变量和引用存储在栈中，常量存储在常量池中。 （ 搞清楚什么是常量什么是变量。 常量就是final 的 不会变的， string 类型 其实也是 不可变类 所以在常量区。 ） 

int i1 = 9;  
int i2 = 9;  
int i3 = 9;   
public static final int INT1 = 9;  
public static final int INT2 = 9;  
public static final int INT3 = 9;  

 

3.对于成员变量和局部变量：（成员变量就是方法外部，类的内部定义的变量；局部变量就是方法内部定义的变量。局部变量必须初始化，成员变量jvm自动初始化， 形式参数也是局部变量）

局部变量的数据存在于栈内存中。栈内存中的局部变量随着方法的消失而消失。
成员变量存储在堆中的对象里面，由垃圾回收器负责回收。

class BirthDate {  
    private int day;   //成员变量
    private int month;  
    private int year;      
    public BirthDate(int d, int m, int y) {  //d, m,y 也是局部变量
        day = d;   
        month = m;   
        year = y;  
    }  
    省略get,set方法………  
}  
  
public class Test{  
    public static void main(String args[]){  
        int date = 9;   //局部变量
        Test test = new Test();        
        test.change(date);   
        BirthDate d1= new BirthDate(7,7,1970);         
    }    
  
    public void change1(int i){  //i 是局部变量
        i = 1234;  
    }  

 

1. date 是局部变量，基础类型， 所以值跟引用都放在栈里 int date = 9;

2. Test test = new Test(); test 为 new Test()对象的引用， 存放在栈里

3. test.change(date); i是局部变量，引用和值存在栈中。当方法change执行完成后，i就会从栈中消失。

4.4. BirthDate d1= new BirthDate(7,7,1970);    d1 为对象的引用 所以存放在栈中， 其所指的对象 存放在堆中， ，其中d，m，y为局部变量存储在栈中，且它们的类型为基础类型，因此它们的数据也存储在栈中。day,month,year为成员变量，它们存储在堆中(new BirthDate()里面)。当BirthDate构造方法执行完之后，d,m,y将从栈中消失。

5.main方法执行完之后，date变量，test，d1引用将从栈中消失，new Test(),new BirthDate()将等待垃圾回收。

 

变量声明位置的不同决定储存位置

在方法中声明（局部变量）：调用方式时在栈中分配空间给变量，结束时释放栈,体现变量的局限性。

在类中声明（成员变量）：由于作用周期需要，变量存放在堆中。不会因方法销毁为失效，类似于C中的全局变量。

对于引用变量来说，对应内存所储存的值是一个引用，是对象的储存地址，被存放在栈中

---

再来一个例子

示例1

main()
　　int x=1;
show ()
　　int x=2

主函数main()中定义变量int x=1，show()函数中定义变量int x=1。最后show()函数执行完毕。

以上程序执行步骤：

第1步——main()函数是程序入口，JVM先执行，在栈内存中开辟一个空间，存放int类型变量x，同时附值1。
第2步——JVM执行show()函数，在栈内存中又开辟一个新的空间，存放int类型变量x，同时附值2。
　　　　　此时main空间与show空间并存，同时运行，互不影响。
第3步——show()执行完毕，变量x立即释放，空间消失。但是main()函数空间仍存在，main中的变量x仍然存在，不受影响。

示意图如下：

 

————————————————————————————————————————————————————————

示例2

main()
　　int[] x=new int[3];
　　x[0]=20

主函数main()中定义数组x，元素类型int，元素个数3。

以上程序执行步骤
第1步——执行int[] x=new int[3];
　　隐藏以下几分支
　　JVM执行main()函数，在栈内存中开辟一个空间，存放x变量（x变量是局部变量）。
　　同时，在堆内存中也开辟一个空间，存放new int[3]数组，堆内存会自动内存首地址值，如0x0045。
　　数组在栈内存中的地址值，会附给x，这样x也有地址值。所以，x就指向（引用）了这个数组。此时，所有元素均未附值，但都有默认初始化值0。

第2步——执行x[0]=20
　　即在堆内存中将20附给[0]这个数组元素。这样，数组的三个元素值分别为20,0,0

示图如下：

——————————————————————————————————————————————————————————————————————

示例3
main()
　　int[] x=new int[3];
　　x[0]=20
　　x=null;

以上步骤执行步骤
第1、2步——与示例2完全一样，略。

第3步——执行x=null;
　　null表示空值，即x的引用数组内存地址0x0045被删除了，则不再指向栈内存中的数组。此时，堆中的数组不再被x使用了，即被视为垃圾，JVM会启动垃圾回收机制，不定时自动删除。

示图如下

——————————————————————————————————————————————————————————————————

示例4
main()
　　int[] x=new int[3];
　　int[] y=x;
　　y[1]=100
　　x=null;

以上步骤执行步骤

第1步——与示例2第1步一致，略。
第2步——执行int[] y=x，
　　在栈内存定义了新的数组变量内存y，同时将x的值0x0045附给了y。所以，y也指向了堆内存中的同一个数组。
第3步——执行y[1]=100
　　即在堆内存中将20附给[0]这个数组元素。这样，数组的三个元素值分别为0,100,0
第4步——执行x=null
　　则变量x不再指向栈内存中的数组了。但是，变量y仍然指向，所以数组不消失。

示图如下

——————————————————————————————————————————————————————————————————

示例5

Car c=new Car;
c.color="blue";
Car c1=new Car;
c1.num=5;

 虽然是个对象都引用new Car，但是是两个不同的对象。每一次new，都产生不同的实体

 

——————————————————————————————————————————————————————————————————

示例6

Car c=new Car;
c.num=5;
Car c1=c;
c1.color="green";
c.run();

Car c1=c，这句话相当于将对象复制一份出来，两个对象的内存地址值一样。所以指向同一个实体，对c1的属性修改，相当于c的属性也改了。

 

堆主要用来存放对象 ， 栈用来存放基本类型跟引用， 用来执行程序。 

Stack栈： 储存基本数据类型的变量，对象的引用。 栈的存取速度更快，大小和生存期必须是确定的， 因此缺乏一定灵活性。

Heap堆 ，常量池： 引用类型的变量， （new 创建的对象都在堆内存） 线程之间会共享堆内存，堆可以在运行时动态分配内存

JAVA引用的用法： 在堆中产生了一个数组或对象后，可以在栈中定义一个特殊的变量，让栈中这个变量的取值等于数组或对象 在队中的首地址， 栈中的这个变量就成了这个数组/对象的引用变量。 就相当于为数组/对象 起的一个名字。

例：

String s = "abc" ; // 把“abc"放到常量区中，在编译时产生
String s = "ab" + "c"; 把”ab" + "c" 转换为字符串常量“abc" 并放到常量区中
String s =  new String("abc") 在运行时 把“abc" 放到 堆里

String s1 = "abc"; 在栈里创建s1 并指向常量区中的”abc"
String s2 = new String("abc")；  在堆中又创建一个新的对象