/**
* 栈(Stack) ：存放基本类型的变量数据和对象的引用，但对象本身不存放在栈中，而是存放在堆（new 出来的对象）或者常量池中（字符串常量对象存放 在常量池中）。
堆(heap)：存放所有new出来的对象。
* 静态存储：存放静态成员（static定义的）。
常量池(constant pool)：在堆中分配出来的一块存储区域，存放储显式的String常量和基本类型常量(float、int等)。另外，可以存储不经常改变的东西
* public static final)。常量池中的数据可以共享。
* Java是一种动态连接的语言，常量池的作用非常重要，常量池中除了包含代码中所定义的各种基本类型（如int、long等等）和对象型（如String及数组）的 常量值还，还包含一些以文本形式出现的符号引用。
* java中的常量池技术，是为了方便快捷地创建某些对象而出现的，当需要一个对象时，就可以从池中取一个出来（如果池中没有则创建一个），则在需要重复重 复创建相等变量时节省了很多时间。常量池其实也就是一个内存空间，不同于使用new关键字创建的对象所在的堆空间。
*/
下面是常量池内存和堆内存的简图：
public class StringDemo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
/*
* String类的特点：
* 字符串对象一旦被初始化就不会被改变。
*
*/
StringDemo4();
}
/**
* 8种基本类型的包装类和对象池
java中基本类型的包装类的大部分都实现了常量池技术，这些类是Byte,Short,Integer,Long,Character,Boolean,
另外两种浮点数类型的包装类则没有实现。
另外Byte,Short,Integer,Long,Character这5种整型的包装类也只是在对应值小于等于127时才可使用对象池，
也即对象不负责创建和管理大于127的这些类的对象。
原因：那么为什么对于<=127才使用对象池？
看Integer的封装源码：
public static Integer valueOf(int i) {
final int offset = 128;
if (i >= -128 && i <= 127) { // must cache
return IntegerCache.cache[i + offset];
}
return new Integer(i);
}
从代码看出，当直接给Integer对象一个int值的时候，其实它调用了valueOf方法，如果赋值的范围在i >= -128 && i <= 127，则走常量池，
如果你赋值不在这个范围之内，那么就不使用常量池，而是new了对象，假设为128，例如下面的i3=128,相当于Integer i3 = new Integer(128);
同理i4 = 128,也为Integer i4 = new Integer(128);则很明显 i3==i4为false；
那么我们知道下面的为什么为True了：
Integer i1=127;
Integer i2=127;
System.out.println(i1==i2);//输出true
我们看一下IntegerCache这个类的源码：
private static class IntegerCache {
private IntegerCache() {
}
static final Integer cache[] = new Integer[-(-128) + 127 + 1];
static {
for (int i = 0; i < cache.length; i++)
cache[i] = new Integer(i - 128);
}
}
由于cache[]在IntegerCache类中是静态数组，也就是只需要初始化一次，即static｛......｝部分，
所以，如果Integer对象初始化时是-128~127的范围，就不需要再重新定义申请空间，
都是同一个对象---在IntegerCache.cache中，这样可以在一定程度上提高效率。
*/
public static void StringDemo4(){
//5种整形的包装类Byte,Short,Integer,Long,Character的对象，
//在值小于127时可以使用常量池
Integer i1=127;
Integer i2=127;
System.out.println(i1==i2);//输出true
//值大于127时，不会从常量池中取对象
Integer i3=128;
Integer i4=128;
System.out.println(i3==i4);//输出false
//Boolean类也实现了常量池技术
Boolean bool1=true;
Boolean bool2=true;
System.out.println(bool1==bool2);//输出true
//浮点类型的包装类没有实现常量池技术
Double d1=1.0;
Double d2=1.0;
System.out.println(d1==d2);//输出false
}
public static void StringDemo3(){
Integer i1=new Integer(1);
Integer i2=new Integer(1);
//i1,i2分别位于堆中不同的内存空间
System.out.println(i1==i2);//输出false
Integer i3=1;
Integer i4=1;
//i3,i4指向常量池中同一个内存空间
System.out.println(i3==i4);//输出true
//很显然，i1,i3位于不同的内存空间
System.out.println(i1==i3);//输出false
}
public static void stringDemo2() {
// TODO Auto-generated method stub
String s1 = "abc";//(1)创建一个字符串对象在常量池中。
String s2 = "abc";//(2)执行时，由于常量池中存在"abc",所以就不在创建新的String对象了
System.out.println(s1==s2);//true,比较地址，因为字符串是存放在常量池中
System.out.println(s1.equals(s2));//true
}
/**
* 分析：①Class被加载时，"xyz"被作为常量读入，在常量池(constant pool)里创建了一个共享的值为"xyz"的String对象；
* 然后当调用到new String("xyz")的时候，会在堆(heap)里创建这个new String("xyz")对象;
* ②由于常量池(constant pool)中存在"xyz"所以不再创建"xyz"，然后创建新的new String("xyz")。
*/
private static void stringDemo1() {
String s3 = new String("abc");//创建两个对象一个new在堆内存中，一个对象在字符串常量池中,创建了一个引用s3在栈中
String s4 = new String("abc");//创建一个对象，new在堆内存中，一个引用s4
System.out.println(s3 == s4);//false
System.out.println(s3.equals(s4));//true
}
}