目录
从这里开始，我们就取初步认识一下Java中的堆、栈等知识，把我所知道的，汇总他人的经验，在这里浅谈一下。当然了，我这里仅是一个初探，没有进行更深入的了解，如果大家想了解深入的东西，请移步大牛帖子。在此，作为一个小白，如有说错的地方，欢迎大家指正。
1、引言----从一行代码开始
首先我们来看一种创建对象的方式，如图所示：
从这个图中，我们大概知道他们各自存放在哪里，然后我们继续往下面看， 从下面这张图可以看出，Person类信息存放在方法区，person对象的引用存放在栈，而对象本身即new出来的东西，存放在堆中。为了不迷糊，这里简单说一下栈、堆、方法区是怎么联系起来的：在栈中会有一个堆中对象头中运行时元数据里的哈希值，这就是一个地址，用于在栈中可以引用堆中对象。
堆中对象中有一个类型指针是对方法区中类元信息的引用。好，到此为止，更深层次的东西我们留待以后再说。
2、堆、栈、方法区、常量池介绍
2.1、系统方面的堆、栈
1、栈区（stack）——由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。
2、堆区（heap）——是一个可动态申请的内存空间（其记录空闲内存空间的链表由操作系统维护），在java中，所有使用new 出来的对象都在堆中存储，一般由程序员分配释放，若程序员不释放，程序结束时可能会由OS回收，注意它与数据结构中的堆是两回事，分配方式倒是类似于链表。
2.2、Java中的堆、栈、方法区、常量池
2.2.1、堆和栈
栈和堆都是Java用来在RAM中存放数据的地方。
2.2.2、堆和栈优缺点
栈的优势是，存取速度快，仅次于直接位于CPU中的寄存器，栈数据可以共享。缺点是，存在栈中的数据大小与生存期必须是确定的，就是说编译器编译的时候必须能确定你的大小，缺乏灵活性；
堆的优势是，可以动态分配内存大小，所有使用new构造出来的对象都在堆中存储，生存期也不必事先告诉编译器，当这些数据不再使用的时候，Java的垃圾回收器会自动收走这些不再使用的数据。缺点是，由于运行时要动态分配内存，存取速度较慢。
2.2.3、方法区
落地实现jdk7永久代，jdk8元空间，元空间并不存在于虚拟机中，而是使用本地内存，它和堆在逻辑上是连续的，但在物理上是不连续的，所以也叫非堆。
1）此区域时线程共享的，存储已加载的类型信息、常量、静态变量、即是编译器编译后的代码的缓存等数据；
2）运行时常量池：编译器生成的各种字面量和符号引用；
3）关于字符串常量池和运行时常量池的位置说明：
jdk1.6 存在永久代，字符串常量池、运行时常量池、静态变量都是在永久代中；
jdk1.7 存在永久代，字符串常量池和静态变量被移动到了堆当中，运行时常量池还是在永久代中；
jdk1.8 不存在永久代，实现形式是元空间，字符串常量池和静态变量仍然在堆当中，运行时常量池、类型信息、常量、字段、方法被移动都了元空间中。
4）元空间的好处：
① 元空间与永久代类似，本质区别是元空间并不占用虚拟机内存了，而是使用本地内存，由于本地内存一般是比较大的，所以方法区就没有那么容易报OOM（OutOfMemoryError）。
② 类及相关的元数据的生命周期与类加载器的一致；
③ 每个加载器有专门的存储空间；
④ 省掉了GC扫描及压缩的时间。
2.2.4、常量池
关于常量池，我们这里只做初步了解，先大概认识一下，后面再做更深入的探讨。
在Java的内存分配中，有2种常量池，字符串常量池（String Constant Pool）、运行时常量池(Runtime Constant Pool)。
1、字符串常量池
（1）在JDK6.0及之前版本，字符串常量池是放在Perm Gen区(也就是方法区)中；
（2）在JDK7.0版本，字符串常量池被移到了堆中了；
（3）字符串常量池存放的是字符串常量和堆中的字符串对象的引用，这是在jdk7.0之后的变化。
注意：字符串常量池中的字符串只存在一份
2、运行时常量池
运行时常量池（Runtime Constant Pool），它是方法区的一部分。Class文件中除了有类的版本、字段、方法、接口等描述等信息外，还有一项信息是常量池（Constant Pool Table），用于存放编译期生成的各种字面量和符号引用，这部分内容将在类加载后存放到常量池中。
运行时常量是相对于常量来说的，它具备一个重要特征是：动态性。当然，值相同的动态常量与我们通常说的常量只是来源不同，但是都是储存在池内同一块内存区域。Java语言并不要求常量一定只能在编译期产生，运行期间也可能产生新的常量，这些常量被放在运行时常量池中。
3、常量池的好处
常量池的好处是为了避免频繁的创建和销毁对象而影响系统性能，其实现了对象的共享。
例如字符串常量池，在编译阶段就把所有的字符串文字放到一个常量池中。
（1）节省内存空间：常量池中所有相同的字符串常量被合并，只占用一个空间。
（2）节省运行时间：比较字符串时，==比equals()快。对于两个引用变量，只用==判断引用是否相等，也就可以判断实际值是否相等。
2.2.5、小结
前面说了这么多，那么我们来画一个图加深理解
3、浅谈操作系统的堆、栈与数据结构的堆、栈
3.1、数据结构的堆、栈
系统中的堆、栈和数据结构堆、栈不是一个概念。可以说系统中的堆、栈是真实的内存物理区，数据结构中的堆、栈是抽象的数据存储结构。
1、栈
实际上就是满足后进先出的性质，是一种数据项按序排列的数据结构，只能在一端(称为栈顶(top))对数据项进行插入和删除。
2. 堆
堆是一种完全二叉树或者近似完全二叉树，完全二叉树是效率很高的数据结构，像十分常用的排序算法、Dijkstra算法、Prim算法等都要用堆才能优化。
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。
4、案例说明
4.1、基本类型
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的值。
4.2、引用类型
1、String类型的对象创建
String str = new String("abc");可以用这个方式来创建
String str = "abc"; 也可以用这个方式来创建前者是规范的类的创建过程，即在Java中，一切都是对象，而对象是类的实例，全部通过new()的形式来创建。
作为对比，在JDK 5.0之前，你从未见过Integer i = 3;的表达式，因为类与字面值是不能通用的，除了String。而在JDK 5.0中，这种表达式是可以的！因为编译器在后台进行Integer i = new Integer(3)的转换。
Java 中的有些类，如DateFormat类，可以通过该类的getInstance()方法来返回一个新创建的类，似乎违反了此原则。其实不然。该类运用了单例模式来返回类的实例，只不过这个实例是在该类内部通过new()来创建的，而getInstance()向外部隐藏了此细节。
2、String str = "abc"的对象创建
Java内部将此语句转化为以下几个步骤：
(1) 先定义一个名为str的对String类的对象引用变量放入栈中。
(2) 在常量池中查找是否存在内容为"abc"字符串对象。
(3) 如果不存在则在常量池中创建"abc"，并让str引用该对象。
(4) 如果存在则直接让str引用该对象。
为了更好地说明这个问题，我们可以通过以下的几个代码进行验证。
String str1 = "abc";
String str2 = "abc";
System.out.println(str1==str2); //true注意：
equals是对象方法，是比较值 ；
== ，基本类型的话比较的也是值，对象的话，比较的是不是同一个对象，而不是这个变量在栈区的地址，这有点像键值对，str1的key是栈区的地址，它的value是abc的地址值，这个地址值指向了常量池中的地址，这个常量池中，又是一个键值对，key是地址值，value是abc。Java里面的对象方法不知道有没有提供读取变量在栈区的地址，即这个key值，这个太底层了，不一定有吧。我再用图来加以理解，我是这么理解的，如不正确，请帮忙指出。
所以，我们这里并不用str1.equals(str2)；的方式，因为它比较两个字符串的值是否相等。而==号，根据JDK的说明，只有在两个引用都指向了同一个对象时才返回真值。而我们在这里就是要看str1与str2是否都指向了同一个对象。 
结果说明，JVM创建了两个引用str1和str2，但只创建了一个对象，而且两个引用都指向了这个对象。
继续，我们将上面代码改为
1 String str1 = "abc";
2 String str2 = "abc";
3 str1 = "bcd";
4 System.out.println(str1 + "," + str2); //bcd, abc
5 System.out.println(str1==str2); //false 这就是说，赋值的变化导致了类对象引用的变化，str1指向了另外一个新对象！而str2仍旧指向原来的对象。上例中，当我们将str1的值改为"bcd"时，JVM发现在栈中没有存放该值的地址，便开辟了这个地址，并创建了一个新的对象，其字符串的值指向这个地址。 我们画图来帮助理解
然后，我们再修改代码，
1 String str1 = "abc";
2 String str2 = "abc";
3
4 str1 = "bcd";
5
6 String str3 = str1;
7 System.out.println(str3); //bcd
8
9 String str4 = "bcd";
10 System.out.println(str1 == str4); //truestr3这个对象的引用直接指向str1所指向的对象(注意，str3并没有创建新对象)。当str1改完其值后，再创建一个String的引用 str4，并指向因str1修改值而创建的新的对象。可以发现，这回str4也没有创建新的对象，从而再次实现栈中数据的共享，指向的是同一个对象。画图理解：
3、String str = new String("abc")创建对象
创建对象的步骤如下：
(1) 先定义一个名为str的对String类的对象引用变量放入栈中。
(2) 然后在堆中（不是字符串常量池）创建一个指定的对象，并让str引用指向该对象。
(3) 在字符串常量池中查找是否存在内容为"abc"字符串对象。
(4) 如果不存在，则在字符串常量池中创建内容为"abc"的字符串对象，并将堆中的对象与之联系起来。
(5) 如果存在，则将new出来的字符串对象与字符串常量池中的对象联系起来（即让那个特殊的成员变量value的指针指向它）
我们再接着看以下的代码，
1 String str1 = new String("abc");
2 String str2 = "abc";
3 System.out.println(str1==str2); //false 创建了两个引用。创建了两个对象。两个引用分别指向不同的两个对象。
对于字符串：其对象的引用都是存储在栈中的，如果是编译器已经创建好的（直接用双引号定义的）就存储在常量池，如果是运行期（new出来的）才能确定的就存储在堆中。下面这道面试题String s = new String(“abc”);产生几个对象？答：一个或两个，如果常量池中原来没有”abc”,就是两个。
4、基本数据类型包装类的值不可修改
基本数据类型包装类的值不可修改。不仅仅是String类的值不可修改，所有的基本数据数据类型包装类都不能更改其内部的值。
5、结论与建议
(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类，以提高程序效率。
5、数据存储
5.1、堆栈缓存方式
栈使用的是一级缓存， 他们通常都是被调用时处于存储空间中，调用完毕立即释放。
堆则是存放在二级缓存中，生命周期由虚拟机的垃圾回收算法来决定（并不是一旦成为孤儿对象就能被回收）。所以调用这些对象的速度要相对来得低一些。
5.2、在JAVA中，有六个不同的地方可以存储数据
1. 寄存器（register）：这是最快的存储区，因为它的位置不同于其他存储区，它处于处理器内部。但是寄存器的数量极其有限，所以寄存器由编译器根据需求进行分配。你不能直接控制，也不能在程序中感觉到寄存器存在的任何迹象。
2. 栈（stack）：存放基本类型的变量数据和对象的引用。位于通用RAM中，但通过它的“堆栈指针”可以从处理器那里获得支持。堆栈指针若向下移动，则分配新的内存；若向上移动，则释放那些内存。这是一种快速有效的分配存储方法，仅次于寄存器。创建程序的时候，JAVA编译器必须知道存储在堆栈内所有数据的确切大小和生命周期，因为它必须生成相应的代码，以便上下移动堆栈指针。这一约束限制了程序的灵活性。
3. 堆（heap）：一种通用性的内存池（也存在于RAM中），用于存放所有的JAVA对象。堆不同于堆栈的好处是：编译器不需要知道要从堆里分配多少存储区域，也不必知道存储的数据在堆里存活多长时间。因此，在堆里分配存储有很大的灵活性。当你需要创建一个对象的时候，只需要new，写一行简单的代码，当执行这行代码时，会自动在堆里进行存储分配。当然，为这种灵活性必须要付出相应的代价，用堆进行存储分配比用堆栈进行存储需要更多的时间。
4. 静态存储（static storage）：这里的“静态”是指“在固定的位置”。静态存储里存放程序运行时一直存在的数据。你可用关键字static来标识一个对象的特定元素是静态的，但JAVA对象本身从来不会存放在静态存储空间里。
5. 常量存储（constant storage）：存放字符串常量和基本类型常量（public static final）。 常量值通常直接存放在程序代码内部，这样做是安全的，因为它们永远不会被改变。
6. 非RAM存储：硬盘等永久存储空间。如果数据完全存活于程序之外，那么它可以不受程序的任何控制，在程序没有运行时也可以存在。
6、队列
什么是队列？
1、队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。
2、队列中没有元素时，称为空队列。
3、建立顺序队列结构必须为其静态分配或动态申请一片连续的存储空间，并设置两个指针进行管理。一个是队头指针front，它指向队头元素；另一个是队尾指针rear，它指向下一个入队元素的存储位置。
4、队列采用的FIFO(first in first out)，新元素（等待进入队列的元素）总是被插入到链表的尾部，而读取的时候总是从链表的头部开始读取。每次读取一个元素，释放一个元素，即所谓的动态创建，动态释放。因而也不存在溢出等问题。由于链表由结构体间接而成，遍历也方便。（先进先出）
765
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
