Java中堆(heap)和栈(stack)的区别

　　简单的说： Java把内存划分红两种：一种是栈内存，一种是堆内存。

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

     堆内存用来存放由new建立的对象和数组。

     在堆中分配的内存，由Java虚拟机的自动垃圾回收器来管理。

　　1. 栈(stack)与堆(heap)都是Java用来在Ram中存放数据的地方。与C++不一样，Java自动管理栈和堆，程序员不能直接地设置栈或堆。

　　2. 栈的优点是，存取速度比堆要快，仅次于直接位于CPU中的寄存器。但缺点是，存在栈中的数据大小与生存期必须是肯定的，缺少灵活性。另外，栈数据能够共享，详见第3点。堆的优点是能够动态地分配内存大小，生存期也没必要事先告诉编译器，Java的垃圾收集器会自动收走这些再也不使用的数据。但缺点是，因为要在运行时动态分配内存，存取速度较慢。

　　3. Java中的数据类型有两种。 一种是基本类型(primitive types)， 共有8种，即int， short， long， byte， float， double， boolean， char(注意，并无string的基本类型)。这种类型的定义是经过诸如int a = 3; long b = 255L;的形式来定义的，称为自动变量。值得注意的是，自动变量存的是字面值，不是类的实例，即不是类的引用，这里并无类的存在。如int a = 3; 这里的a是一个指向int类型的引用，指向3这个字面值。这些字面值的数据，因为大小可知，生存期可知(这些字面值固定定义在某个程序块里面，程序块退出后，字段值就消失了)，出于追求速度的缘由，就存在于栈中。

　　另外，栈有一个很重要的特殊性，就是存在栈中的数据能够共享。假设咱们同时定义

 int a = 3; 
 int b = 3；

　　编译器先处理int a = 3；首先它会在栈中建立一个变量为a的引用，而后查找有没有字面值为3的地址，没找到，就开辟一个存放3这个字面值的地址，而后将a指向3的地址。接着处理int b = 3；在建立完b的引用变量后，因为在栈中已经有3这个字面值，便将b直接指向3的地址。这样，就出现了a与b同时均指向3的状况。

　　特别注意的是，这种字面值的引用与类对象的引用不一样。假定两个类对象的引用同时指向一个对象，若是一个对象引用变量修改了这个对象的内部状态，那么另外一个对象引用变量也即刻反映出这个变化。相反，经过字面值的引用来修改其值，不会致使另外一个指向此字面值的引用的值也跟着改变的状况。如上例，咱们定义完a与 b的值后，再令a=4；那么，b不会等于4，仍是等于3。在编译器内部，遇到a=4；时，它就会从新搜索栈中是否有4的字面值，若是没有，从新开辟地址存放4的值；若是已经有了，则直接将a指向这个地址。所以a值的改变不会影响到b的值。

　　另外一种是包装类数据，如Integer， String， Double等将相应的基本数据类型包装起来的类。这些类数据所有存在于堆中，Java用new()语句来显式地告诉编译器，在运行时才根据须要动态建立，所以比较灵活，但缺点是要占用更多的时间。

　　4. String是一个特殊的包装类数据。便可以用String str = new String("abc");的形式来建立，也能够用String str = "abc"；的形式来建立(做为对比，在JDK 5.0以前，你从未见过Integer i = 3;的表达式，由于类与字面值是不能通用的，除了String。而在JDK 5.0中，这种表达式是能够的！由于编译器在后台进行Integer i = new Integer(3)的转换)。前者是规范的类的建立过程，即在Java中，一切都是对象，而对象是类的实例，所有经过new()的形式来建立。Java 中的有些类，如DateFormat类，能够经过该类的getInstance()方法来返回一个新建立的类，彷佛违反了此原则。其实否则。该类运用了单例模式来返回类的实例，只不过这个实例是在该类内部经过new()来建立的，而getInstance()向外部隐藏了此细节。那为何在String str = "abc"；中，并无经过new()来建立实例，是否是违反了上述原则？其实没有。

　　5. 关于String str = "abc"的内部工做。Java内部将此语句转化为如下几个步骤：

• 先定义一个名为str的对String类的对象引用变量：String str；
• 在栈中查找有没有存放值为"abc"的地址，若是没有，则开辟一个存放字面值为"abc"的地址，接着建立一个新的String类的对象o，并将o 的字符串值指向这个地址，并且在栈中这个地址旁边记下这个引用的对象o。若是已经有了值为"abc"的地址，则查找对象o，并返回o的地址。
• 将str指向对象o的地址。 值得注意的是，通常String类中字符串值都是直接存值的。但像String str = "abc"；这种场合下，其字符串值倒是保存了一个指向存在栈中数据的引用！ 为了更好地说明这个问题，咱们能够经过如下的几个代码进行验证。

String str1 = "abc"; 
String str2 = "abc";
System.out.println(str1==str2); //true

　　注意，咱们这里并不用str1.equals(str2)；的方式，由于这将比较两个字符串的值是否相等。==号，根据JDK的说明，只有在两个引用都指向了同一个对象时才返回真值。而咱们在这里要看的是，str1与str2是否都指向了同一个对象。 结果说明，JVM建立了两个引用str1和str2，但只建立了一个对象，并且两个引用都指向了这个对象。 咱们再来更进一步，将以上代码改为：

String str1 = "abc";
String str2 = "abc";
str1 = "bcd";
System.out.println(str1 + "，" + str2); //bcd， abc
System.out.println(str1==str2); //false

　　这就是说，赋值的变化致使了类对象引用的变化，str1指向了另一个新对象！而str2仍旧指向原来的对象。上例中，当咱们将str1的值改成"bcd"时，JVM发如今栈中没有存 放该值的地址，便开辟了这个地址，并建立了一个新的对象，其字符串的值指向这个地址。 事实上，String类被设计成为不可改变(immutable)的类。若是你要改变其值，能够，但JVM在运行时根据新值悄悄建立了一个新对象，而后将这个对象的地址返回给原来类的引用。这个建立过程虽然说是彻底自动进行的，但它毕竟占用了更多的时间。在对时间要求比较敏感的环境中，会带有必定的不良影响。 再修改原来代码：

String str1 = "abc";
String str2 = "abc";
str1 = "bcd";
String str3 = str1;
System.out.println(str3); //bcd
String str4 = "bcd";
System.out.println(str1 == str4); //true

　　str3 这个对象的引用直接指向str1所指向的对象(注意，str3并无建立新对象)。当str1改完其值后，再建立一个String的引用str4，并指向因str1修改值而建立的新的对象。能够发现，这回str4也没有建立新的对象，从而再次实现栈中数据的共享。 咱们再接着看如下的代码。

String str1 = new String("abc");
String str2 = "abc";
System.out.println(str1==str2); //false

 

　　建立了两个引用。建立了两个对象。两个引用分别指向不一样的两个对象。

String str1 = "abc";
String str2 = new String("abc");
System.out.println(str1==str2); //false

　　建立了两个引用。建立了两个对象。两个引用分别指向不一样的两个对象。

　　以上两段代码说明，只要是用new()来新建对象的，都会在堆中建立，并且其字符串是单独存值的，即便与栈中的数据相同，也不会与栈中的数据共享。

　　6. 数据类型包装类的值不可修改。不只仅是String类的值不可修改，全部的数据类型 包装类都不能更改其内部的值。

　　7. 结论与建议：

　　(1) 咱们在使用诸如String str = "abc"；的格式定义类时，老是想固然地认为，咱们建立了String类的对象str。担忧陷阱！对象可能并无被建立！惟一能够确定的是，指向 String类的引用被建立了。至于这个引用究竟是否指向了一个新的对象，必须根据上下文来考虑，除非你经过new()方法来显要地建立一个新的对象。所以，更为准确的说法是，咱们建立了一个指向String类的对象的引用变量str，这个对象引用变量指向了某个值为"abc"的String类。清醒地认识到这一点对排除程序中难以发现的bug是颇有帮助的。

　　(2) 使用String str = "abc"；的方式，能够在必定程度上提升程序的运行速度，由于JVM会自动根据栈中数据的实际状况来决定是否有必要建立新对象。而对于String str = new String("abc")；的代码，则一律在堆中建立新对象，而无论其字符串值是否相等，是否有必要建立新对象，从而加剧了程序的负担。这个思想应该是享元模式的思想，但JDK的内部在这里实现是否应用了这个模式，不得而知。

　　(3) 当比较包装类里面的数值是否相等时，用equals()方法；当测试两个包装类的引用是否指向同一个对象时，用==。

　　(4) 因为String类的immutable性质，当String变量须要常常变换其值时，应该考虑使用StringBuffer类，以提升程序效率。

java中内存分配策略及堆和栈的比较

内存分配策略

　　按照编译原理的观点，程序运行时的内存分配有三种策略，分别是静态的，栈式的，和堆式的。

　　静态存储分配是指在编译时就能肯定每一个数据目标在运行时刻的存储空间需求，于是在 编译时就能够给他们分配固定的内存空间。这种分配策略要求程序代码中不容许有可变数据结构(好比可变数组)的存在，也不容许有嵌套或者递归的结构出现，由于它们都会致使编译程序没法计算准确的存储空间需求。

　　栈式存储分配也可称为动态存储分配，是由一个相似于堆栈的运行栈来实现的。和静态存储分配相反，在栈式存储方案中，程序对数据区的需求在编译时是彻底未知的，只有到运行的时候才可以知道，可是规定在运行中进入一个程序模块时，必须知道该程序模块所需的数据区大小才可以为其分配内存.和咱们在数据结构所熟知的栈同样，栈式存储分配按照先进后出的原则进行分配。

　　静态存储分配要求在编译时能知道全部变量的存储要求，栈式存储分配要求在过程的入口处必须知道全部的存储要求，而堆式存储分配则专门负责在编译时或运行时模块入口处都没法肯定存储要求的数据结构的内存分配，好比可变长度串和对象实例.堆由大片的可利用块或空闲块组成，堆中的内存能够按照任意顺序分配和释放。

堆和栈的比较

　　上面的定义从编译原理的教材中总结而来，除静态存储分配以外，都显得很呆板和难以理解，下面撇开静态存储分配，集中比较堆和栈：

　　从堆和栈的功能和做用来通俗的比较，堆主要用来存放对象的，栈主要是用来执行程序的。而这种不一样又主要是因为堆和栈的特色决定的：

　　在编程中，例如C/C++中，全部的方法调用都是经过栈来进行的，全部的局部变量，形式参数都是从栈中分配内存空间的。实际上也不是什么分配，只是从栈顶向上用就行，就好像工厂中的传送带(conveyor belt)同样，Stack Pointer会自动指引你到放东西的位置，你所要作的只是把东西放下来就行.退出函数的时候，修改栈指针就能够把栈中的内容销毁.这样的模式速度最快，固然要用来运行程序了.须要注意的是，在分配的时候，好比为一个即将要调用的程序模块分配数据区时，应事先知道这个数据区的大小，也就说是虽然分配是在程序运行时进行的，可是分配的大小多少是肯定的，不变的，而这个"大小多少"是在编译时肯定的，不是在运行时.

　　堆是应用程序在运行的时候请求操做系统分配给本身内存，因为从操做系统管理的内存分配，因此在分配和销毁时都要占用时间，所以用堆的效率很是低。可是堆的优势在于，编译器没必要知道要从堆里分配多少存储空间，也没必要知道存储的数据要在堆里停留多长的时间，所以，用堆保存数据时会获得更大的灵活性。事实上，面向对象的多态性，堆内存分配是必不可少的，由于多态变量所需的存储空间只有在运行时建立了对象以后才能肯定.在C++中，要求建立一个对象时，只需用 new命令编制相关的代码便可。执行这些代码时，会在堆里自动进行数据的保存。固然，为达到这种灵活性，必然会付出必定的代价：在堆里分配存储空间时会花掉更长的时间！这也正是致使咱们刚才所说的效率低的缘由。

JVM中的堆和栈

　　JVM是基于堆栈的虚拟机。JVM为每一个新建立的线程都分配一个堆栈。也就是说，对于一个Java程序来讲，它的运行就是经过对堆栈的操做来完成的。堆栈以帧为单位保存线程的状态。JVM对堆栈只进行两种操做：以帧为单位的压栈和出栈操做。

　　咱们知道，某个线程正在执行的方法称为此线程的当前方法。咱们可能不知道，当前方法使用的帧称为当前帧。当线程激活一个Java方法，JVM就会在线程的 Java堆栈里新压入一个帧。这个帧天然成为了当前帧。在此方法执行期间，这个帧将用来保存参数，局部变量，中间计算过程和其余数据。这个帧在这里和编译原理中的活动纪录的概念是差很少的。从Java的这种分配机制来看，堆栈又能够这样理解：堆栈(Stack)是操做系统在创建某个进程时或者线程(在支持多线程的操做系统中是线程)为这个线程创建的存储区域，该区域具备先进后出的特性。 每个Java应用都惟一对应一个JVM实例，每个实例惟一对应一个堆。应用程序在运行中所建立的全部类实例或数组都放在这个堆中，并由应用全部的线程 共享.跟C/C++不一样，Java中分配堆内存是自动初始化的。Java中全部对象的存储空间都是在堆中分配的，可是这个对象的引用倒是在堆栈中分配，也就是说在创建一个对象时从两个地方都分配内存，在堆中分配的内存实际创建这个对象，而在堆栈中分配的内存只是一个指向这个堆对象的指针(引用)而已。

GC的思考

　　Java为何慢？JVM的存在固然是一个缘由，但有人说，在Java中，除了简单类型(int，char等)的数据结构，其它都是在堆中分配内存(因此说Java的一切都是对象)，这也 是程序慢的缘由之一。

　　个人想法是(应该说表明TIJ的观点)，若是没有Garbage Collector(GC)，上面的说法就是成立的。堆不像栈是连续的空间，没有办法期望堆自己的内存分配可以象堆栈同样拥有传送带般的速度，由于，谁会 为你整理庞大的堆空间，让你几乎没有延迟的从堆中获取新的空间呢？

　　这个时候，GC站出来解决问题。咱们都知道GC用来清除内存垃圾，为堆腾出空间供程序使用，但GC同时也担负了另一个重要的任务，就是要让Java中堆的内存分配和其余语言中堆栈的内存分配同样快，由于速度的问题几乎是众口一词的对Java的诟病。要达到这样的目的，就必须使堆的分配也可以作到象传送带同样，不用本身操心去找空闲空间.这样，GC除了负责清除Garbage外，还要负责整理堆中的对象，把它们转移到一个远离Garbage的纯净空间中无间隔的排列起来，就象堆栈中同样紧凑，这样Heap Pointer就能够方便的指向传送带的起始位置，或者说一个未使用的空间，为下一个须要分配内存的对象"指引方向".所以能够这样说，垃圾收集影响了对象的建立速度，听起来很怪，对不对?

　　那GC怎样在堆中找到全部存活的对象呢？前面说了，在创建一个对象时，在堆中分配实际创建这个对象的内存，而在堆栈中分配一个指向这个堆对象的指针(引 用)，那么只要在堆栈(也有可能在静态存储区)找到这个引用，就能够跟踪到全部存活的对象.找到以后，GC将它们从一个堆的块中移到另一个堆的块中，并 将它们一个挨一个的排列起来，就象咱们上面说的那样，模拟出了一个栈的结构，但又不是先进后出的分配，而是能够任意分配的，在速度能够保证的状况下。

　　可是，列宁同志说了，人的优势每每也是人的缺点，人的缺点每每也是人的优势(再晕~~).GC()的运行要占用一个线程，这自己就是一个下降程序运行性能 的缺陷，更况且这个线程还要在堆中把内存翻来覆去的折腾.不只如此，如上面所说，堆中存活的对象被搬移了位置，那么全部对这些对象的引用都要从新赋值.这 些开销都会致使性能的下降。

　　基础数据类型直接在栈空间分配，方法的形式参数，直接在栈空间分配，当方法调用完成后从栈空间回收。引用数据类型，须要用new来建立，既在栈空间 分配一个地址空间，又在堆空间分配对象的类变量 。方法的引用参数，在栈空间分配一个地址空间，并指向堆空间的对象区，当方法调用完成后从栈空间回收。局部变量new出来时，在栈空间和堆空间中分配空 间，当局部变量生命周期结束后，栈空间马上被回收，堆空间区域等待GC回收。方法调用时传入的literal参数，先在栈空间分配，在方法调用完成后从栈 空间分配。字 符串常量在DATA区域分配 ， this在堆空间分配。数组既在栈空间分配数组名称 ， 又在堆空间分配数组实际的大小！

 

原文参考【Java知音网】