Java把内存划分成两种：一种是栈内存，一种是堆内存。
栈(stack):是一个先进后出的数据结构,通常用于保存方法(函数)中的参数,局部变量.
在java中,所有基本类型和引用类型都在栈中存储.栈中数据的生存空间一般在当前scopes内(就是由{...}括起来的区域).
堆(heap):是一个可动态申请的内存空间(其记录空闲内存空间的链表由操作系统维护),C中的malloc语句所产生的内存空间就在堆中.
在java中,所有使用new xxx()构造出来的对象都在堆中存储,当垃圾回收器检测到某对象未被引用,则自动销毁该对象.所以,理论上说java中对象的生存空间是没有限制的,只要有引用类型指向它,则它就可以在任意地方被使用.
堆与堆栈的关系：
堆：堆是heap，是所谓的动态内存，其中的内存在不需要时可以回收，以分配给新的内存请求，其内存中的数据是无序的，即先分配的和随后分配的内存并没有什么必然的位置关系，释放时也可以没有先后顺序。一般由使用者自由分配，malloc分配的就是堆，需要手动释放。
堆栈:就是stack。实际上是只有一个出入口的队列，即后进先出（First In Last Out），先分配的内存必定后释放。一般由，由系统自动分配，存放存放函数的参数值，局部变量等，自动清除。
栈(stack)的优缺点：
优点是：栈的存取速度比堆要快，仅次于CPU中的寄存器。栈数据可以共享
缺点是：存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。
堆(heap)的优缺点：
优点是：可以动态地分配内存大小，生存期也不必事先告诉编译器，Java的垃圾收集器会自动收走这些不再使用的数据。
缺点是：由于要在运行时动态分配内存，所以存取速度较慢。
2、Java中的数据类型有两种。
基本类型：即int, short, long, byte, float, double, boolean, char(注意，string是引用类型)。如 int a = 3 存的是字面值。
栈的由来：这些字面值的数据，由于大小可知，生存期可知(这些字面值固定定义在某个程序块里面，程序块退出后，字段值就消失了)，出于追求速度的原因，就存在于栈中。
引用类型包括类、接口、数组、Integer, String, Double等。 引用类型声明的变量是指该变量在内存中实际存储的是一个引用地址，实体在堆中。
包装类就属于引用类型，也就是将相应的基本数据类型包装起来的类（int → Integer），自动装箱和拆箱就是基本类型和引用类型之间的转换。
为什么要转换？
因为基本类型转换为引用类型后，就可以new对象，从而调用包装类中封装好的方法进行基本类型 之间的转换或者toString（当然用类名直接调用也可以，便于一眼看出该方法是静态的），还有就是如果集合中想存放基本类型，泛型的限定类型只能是对应的包装类型。
3、关于String str =new String("abc")和 String str = "abc"的比较
Java中的String，StringBuilder，StringBuffer三者的区别
String str =new String("abc")
String str1 = "abc"
System.out.println(str == str1)
System.out.println(str.equal(str1))
结果：
false
true
原因解析：
- Java运行环境有一个字符串池，由String类维护。
1. 执行语句String str="abc";时。首先查看字符串池中是否存在字符串"abc",如果存在则直接将“abc”赋给str,如果不存在则先在 字 符串池中新建一个字符串"abc"，然后再将其赋给str.
2. 执行语句String str = new String("abc");时。不管字符串池中是否存在字符串“abc”,直接新建一个字符串“abc”,(注意，新建的字符串“abc”不是在字符串池中)， 然后将其赋给str。由此可见 1.的效率要高于2的效率。
3. String str1="java";//指向字符串池
String str2="blog";//指向字符串池
String s = str1+str2;
+运算符会在堆中建立起两个String对象，这两个对象的值分别是“java”,"blog",也就是说从字符串常量池中复制这两个值，然后再堆中创建两个对象。然后再建立对象s,然后将“javablog”的堆地址赋给s. 这句话共创建了3个String对象。
System.out.println(s=="javablog");//结果是false;
JVM确实对形如String str="javablog";的对象放在常量池中，但是它是在编译时name做的。而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;
总之，创建字符串有两种方式：两种内存区域(pool,heap)
1.""创建的字符串在字符串池中。
2.new 创建字符串时，首先查看池中是否有相同的字符串，如果有则拷贝一份放到堆中，然后返回堆中的地址；如果池中没有则在堆中创建一分，然后返回堆中的地址，
3.在对字符串赋值时，如果右操作数含有一个或一个以上的字符串引用时，则在堆中再建立一个字符串对象，返回引用如：String s= str1+"blog";
之间的区别
第1种：
String a="abc";
String b="abc";
System.out.print(a==b);
结果：true
原因：编译时，这两个"abc"被认为是同一个对象保存到了常量池中；运行时JVM则认为这两个变量赋的是同一个对象，所以返回true。
---------------------
第2种：
String a=new String("abc");
String b=new String("abc");
System.out.print(a==b);
结果：false
原因：用构造器创建的对象，是不会被放入常理池中的，也很明显这完全是两个对象，只是内容相同罢了，结果当然为false了。用equals()或者System.out.print(a.intern()==b.intern());就返回true了。
------------------------------
第3种
String a="abc";
String b=new String("abc");
System.out.print(a==b);
结果：false
原因：同上。此外，a的类加载时就完成了初始化，而b要在执行引擎执行到那一行代码时才完成初始化。
---------------------------
第4种
String a="abcdef";
System.out.print(a=="abcdef");
结果：true
原因：运行出现的字符串常量，若是在常量池中出现过，则JVM会认为同一个对象，以节省内存开销，所以这两个字符串会被认为是同一个对象。
-------------------------------------------
第5种
String a="abcdef";
String b="";
String c=a+b;
System.out.print(c=="abcdef");
结果：false
原因：编译时，先将"abcedf"放在常量池中，而c的值则是在运行时在堆里创建的。所以为false。
6. 结论与建议：
(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类，以提高程序效率。