java对象的创建与初始化
1．Java中的数据类型
Java中有3个数据类型：基本数据类型（在Java中，boolean、byte、short、int、long、char、float、double这八种是基本数据类型）、引用类型和null类型。其中，引用类型包括类类型（含数组）、接口类型。
下列语句声明了一些变量：
int k ;
A a; //a是A数据类型的对象变量名。
B b1,b2,…,b10000;// 假定B是抽象类或接口。
String s;
注意：从数据类型与变量的角度看，基本数据类型变量k、类类型变量a和s、抽象类或接口类型变量b（1万个），它们都是变量（标识符）。
Java中有3个数据类型：基本数据类型（在Java中，boolean、byte、short、int、long、char、float、double这八种是基本数据类型）、引用类型和null类型。其中，引用类型包括类类型（含数组）、接口类型。
下列语句声明了一些变量：
int k ;
A a; //a是A数据类型的对象变量名。
B b1,b2,…,b10000;// 假定B是抽象类或接口。
String s;
注意：从数据类型与变量的角度看，基本数据类型变量k、类类型变量a和s、抽象类或接口类型变量b（1万个），它们都是变量（标识符）。
2．关于句柄（handle）
为了区别引用类型的变量标识符和基本数据类型变量标识符，我们特别的使用Handle来称呼引用类型的变量标识符。上面例子中b1至b10000、a、s都是Handle。Handle直观的看就是手柄、把手，我们采用计算机界常用的中文翻译“句柄”。
为了区别引用类型的变量标识符和基本数据类型变量标识符，我们特别的使用Handle来称呼引用类型的变量标识符。上面例子中b1至b10000、a、s都是Handle。Handle直观的看就是手柄、把手，我们采用计算机界常用的中文翻译“句柄”。
2.1【Windows编程中的】句柄的含义
句柄是WONDOWS用来标识被应用程序所建立或使用的对象的唯一整数，WINDOWS使用各种各样的句柄标识诸如应用程序实例，窗口，控制，位图，GDI对象等等。WINDOWS句柄有点象C语言中的文件句柄。
从上面的定义中的我们可以看到，句柄是一个标识符，是拿来标识对象或者项目的，它就象我们的姓名一样，每个人都会有一个，不同的人的姓名不一样，但是，也可能有一个名字和你一样的人。从数据类型上来看它只是一个16位的无符号整数。应用程序几乎总是通过调用一个WINDOWS函数来获得一个句柄，之后其他的WINDOWS函数就可以使用该句柄，以引用相应的对象。
如果想更透彻一点地认识句柄，我可以告诉大家，句柄是一种指向指针的指针。我们知道，所谓指针是一种内存地址。应用程序启动后，组成这个程序的各对象是驻留在内存的。如果简单地理解，似乎我们只要获知这个内存的首地址，那么就可以随时用这个地址访问对象。但是，如果您真的这样认为，那么您就大错特错了。我们知道，Windows是一个以虚拟内存为基础的操作系统。在这种系统环境下，Windows内存管理器经常在内存中来回移动对象，依此来满足各种应用程序的内存需要。对象被移动意味着它的地址变化了。如果地址总是如此变化，我们该到哪里去找该对象呢?
为了解决这个问题，Windows操作系统为各应用程序腾出一些内存储地址，用来专门登记各应用对象在内存中的地址变化，而这个地址(存储单元的位置)本身是不变的。Windows内存管理器在移动对象在内存中的位置后，把对象新的地址告知这个句柄地址来保存。这样我们只需记住这个句柄地址就可以间接地知道对象具体在内存中的哪个位置。这个地址是在对象装载(Load)时由系统分配给的，当系统卸载时(Unload)又释放给系统。
句柄地址(稳定)→记载着对象在内存中的地址────→对象在内存中的地址(不稳定)→实际对象
句柄是WONDOWS用来标识被应用程序所建立或使用的对象的唯一整数，WINDOWS使用各种各样的句柄标识诸如应用程序实例，窗口，控制，位图，GDI对象等等。WINDOWS句柄有点象C语言中的文件句柄。
从上面的定义中的我们可以看到，句柄是一个标识符，是拿来标识对象或者项目的，它就象我们的姓名一样，每个人都会有一个，不同的人的姓名不一样，但是，也可能有一个名字和你一样的人。从数据类型上来看它只是一个16位的无符号整数。应用程序几乎总是通过调用一个WINDOWS函数来获得一个句柄，之后其他的WINDOWS函数就可以使用该句柄，以引用相应的对象。
如果想更透彻一点地认识句柄，我可以告诉大家，句柄是一种指向指针的指针。我们知道，所谓指针是一种内存地址。应用程序启动后，组成这个程序的各对象是驻留在内存的。如果简单地理解，似乎我们只要获知这个内存的首地址，那么就可以随时用这个地址访问对象。但是，如果您真的这样认为，那么您就大错特错了。我们知道，Windows是一个以虚拟内存为基础的操作系统。在这种系统环境下，Windows内存管理器经常在内存中来回移动对象，依此来满足各种应用程序的内存需要。对象被移动意味着它的地址变化了。如果地址总是如此变化，我们该到哪里去找该对象呢?
为了解决这个问题，Windows操作系统为各应用程序腾出一些内存储地址，用来专门登记各应用对象在内存中的地址变化，而这个地址(存储单元的位置)本身是不变的。Windows内存管理器在移动对象在内存中的位置后，把对象新的地址告知这个句柄地址来保存。这样我们只需记住这个句柄地址就可以间接地知道对象具体在内存中的哪个位置。这个地址是在对象装载(Load)时由系统分配给的，当系统卸载时(Unload)又释放给系统。
句柄地址(稳定)→记载着对象在内存中的地址────→对象在内存中的地址(不稳定)→实际对象
2.2Java中句柄的意义
对句柄以前的【Windows编程中的】含义有了深刻的认识，我们可以说Handle是一个我们学习Java时非常需要的术语。它的意义在于区别“对象本身”和对象变量（或者严格点：对象所属的数据类型的变量标识符）。
对句柄以前的【Windows编程中的】含义有了深刻的认识，我们可以说Handle是一个我们学习Java时非常需要的术语。它的意义在于区别“对象本身”和对象变量（或者严格点：对象所属的数据类型的变量标识符）。
2.3回到1中的变量声明：
现在，你应该对下面的注释一目了然。
int k, j ;//k里面存放的是一个整型数。
A a; //a里面存放地址。
B b1,b2,…,b10000;// b1，…，b10000里面存放地址。
String s; //s里面存放地址。
现在，你应该对下面的注释一目了然。
int k, j ;//k里面存放的是一个整型数。
A a; //a里面存放地址。
B b1,b2,…,b10000;// b1，…，b10000里面存放地址。
String s; //s里面存放地址。
3．关于引用（reference）
什么是“引用”？ “the identifier you manipulate is actually a ‘reference’ to an object”。（Thinking in Java 2e ）
翻译是：你操纵的标识符实际上是一个对象的“引用”。或者精确些，翻译成：你操作的标识符实际上是指向一个对象的“引用”。显然，原文中reference是一个有方向感的东西。
回到Java中来，引用可以想象成对象的身份证号码、对象的ID或者对象的手机号码。当然，更多的说法是，引用是对象在内存中住的房间号码。直观的说，对象的引用是创建对象时的返回值！引用是new表达式的返回值。
new A(); 这里真正创建了一个对象，但我们没有用句柄去持有（hold、拿着、保存）该引用。从微观上看，new表达式完成了对象初始化的任务（三步曲，下文详细分析），整体上看则返回一个引用。
再次回到1中的变量声明，再看看下面的注释。
A a; //声明句柄a，但未初始化，所以里面的值为null。
B b1,b2,…,b10000;// 声明句柄b1，…，b10000，但未初始化，所以里面的值为null。
String s; //声明句柄s，但未初始化，所以里面的值为null。
什么是“引用”？ “the identifier you manipulate is actually a ‘reference’ to an object”。（Thinking in Java 2e ）
翻译是：你操纵的标识符实际上是一个对象的“引用”。或者精确些，翻译成：你操作的标识符实际上是指向一个对象的“引用”。显然，原文中reference是一个有方向感的东西。
回到Java中来，引用可以想象成对象的身份证号码、对象的ID或者对象的手机号码。当然，更多的说法是，引用是对象在内存中住的房间号码。直观的说，对象的引用是创建对象时的返回值！引用是new表达式的返回值。
new A(); 这里真正创建了一个对象，但我们没有用句柄去持有（hold、拿着、保存）该引用。从微观上看，new表达式完成了对象初始化的任务（三步曲，下文详细分析），整体上看则返回一个引用。
再次回到1中的变量声明，再看看下面的注释。
A a; //声明句柄a，但未初始化，所以里面的值为null。
B b1,b2,…,b10000;// 声明句柄b1，…，b10000，但未初始化，所以里面的值为null。
String s; //声明句柄s，但未初始化，所以里面的值为null。
4．句柄与引用的关系
A a;//声明句柄a，值为null
a=new A();//句柄的初始化（句柄 = 引用；即把引用赋值给句柄）
A a;//声明句柄a，值为null
a=new A();//句柄的初始化（句柄 = 引用；即把引用赋值给句柄）
引用：new A()的值。引用可以简单的看作对象占据内存空间的地址；通过对象的引用，就可以方便的与其他对象区别开来，引用就是对象独特的身份标识。
完成句柄的初始化后，就可以用句柄遥控对象了。
当然，这只是从一方面解释对象的创建和初始化，理解了句柄和引用的关系后，下面分析对象初始化的整个过程。先做以下准备工作，说说栈与堆。
完成句柄的初始化后，就可以用句柄遥控对象了。
当然，这只是从一方面解释对象的创建和初始化，理解了句柄和引用的关系后，下面分析对象初始化的整个过程。先做以下准备工作，说说栈与堆。
5．java中栈（stack）与堆(heap)
在java中内存分为“栈”和“堆”这两种（Stack and Heap).基本数据类型存储在“栈”中，对象引用类型实际存储在“堆”中，在栈中只是保留了引用内存的地址值。
顺便说说“==”与“equals（）方法”，以帮助理解两者（Stack and Heap)的概念。
在Java中利用"=="比较变量时候，系统使用变量在stack(栈)中所存的值来作为对比的依据，基本数据类型在stack中所存的值就是其內容值，而引用类型在stack中所存放的值是本身所指向Heap中对象的地址值。 Java.lang包中的Object类有public boolean equals (Object obj)方法。它比较两个对象是否相等。仅当被比较的两个引用指向同一对象时（句柄相等），对象的equals()方法返回true。（至于String类的equals（）方法，它重写（override）equals()方法，不在本文讨论之列。）
在java中内存分为“栈”和“堆”这两种（Stack and Heap).基本数据类型存储在“栈”中，对象引用类型实际存储在“堆”中，在栈中只是保留了引用内存的地址值。
顺便说说“==”与“equals（）方法”，以帮助理解两者（Stack and Heap)的概念。
在Java中利用"=="比较变量时候，系统使用变量在stack(栈)中所存的值来作为对比的依据，基本数据类型在stack中所存的值就是其內容值，而引用类型在stack中所存放的值是本身所指向Heap中对象的地址值。 Java.lang包中的Object类有public boolean equals (Object obj)方法。它比较两个对象是否相等。仅当被比较的两个引用指向同一对象时（句柄相等），对象的equals()方法返回true。（至于String类的equals（）方法，它重写（override）equals()方法，不在本文讨论之列。）
6．对象的创建和初始化过程
在java中对象就是类的实例。在一般情况下，当把一个类实例化时，此类的所有成员，包括变量和方法，都被复制到属于此数据类型的一个新的实例中去。分析以下两段代码。
在java中对象就是类的实例。在一般情况下，当把一个类实例化时，此类的所有成员，包括变量和方法，都被复制到属于此数据类型的一个新的实例中去。分析以下两段代码。
6.1 Vehicle veh1 = new Vehicle();
上面的语句做了如下的事情：
①右边的“new Vehicle”，是以Vehicle类为模板，在堆空间里创建一个Vehicle类对象（也简称为Vehicle对象）。
②末尾的()意味着，在对象创建后，立即调用Vehicle类的构造函数，对刚生成的对象进行初始化。构造函数是肯定有的。如果没创建，Java会补上一个默认的构造函数。
③左边的“Vehicle veh1”创建了一个Vehicle类引用变量。
④“=”操作符使对象引用指向刚创建的那个Vehicle对象。（回想一下句柄与引用）
上面的语句做了如下的事情：
①右边的“new Vehicle”，是以Vehicle类为模板，在堆空间里创建一个Vehicle类对象（也简称为Vehicle对象）。
②末尾的()意味着，在对象创建后，立即调用Vehicle类的构造函数，对刚生成的对象进行初始化。构造函数是肯定有的。如果没创建，Java会补上一个默认的构造函数。
③左边的“Vehicle veh1”创建了一个Vehicle类引用变量。
④“=”操作符使对象引用指向刚创建的那个Vehicle对象。（回想一下句柄与引用）
将上面的语句分为两个步骤：
Vehicle veh1;
veh1 = new Vehicle();
这样写，就比较清楚了，有两个实体：一是对象引用变量，一是对象本身。在堆空间里创建的实体，与在栈空间里创建的实体不同。尽管它们也是确确实实存在的实体，但是似乎很难准确的“抓”住它。我们仔细研究一下第二句，找找刚创建的对象叫什么名字？有人说，它叫“Vehicle”。不对，“Vehicle”是类（对象的创建模板）的名字。一个Vehicle类可以据此创建出无数个对象，这些对象不可能全叫“Vehicle”。对象连名都没有，没法直接访问它。我们只能通过对象引用来间接访问对象。
Vehicle veh1;
veh1 = new Vehicle();
这样写，就比较清楚了，有两个实体：一是对象引用变量，一是对象本身。在堆空间里创建的实体，与在栈空间里创建的实体不同。尽管它们也是确确实实存在的实体，但是似乎很难准确的“抓”住它。我们仔细研究一下第二句，找找刚创建的对象叫什么名字？有人说，它叫“Vehicle”。不对，“Vehicle”是类（对象的创建模板）的名字。一个Vehicle类可以据此创建出无数个对象，这些对象不可能全叫“Vehicle”。对象连名都没有，没法直接访问它。我们只能通过对象引用来间接访问对象。
6.2 Vehicle veh2;
veh2 = veh1;
由于veh1和veh2只是对对象的引用，第二行所做的不过是把veh1的引用（地址）赋值给veh2，使得veh1和veh2同时指向唯一的一个Vehicle对象。
veh2 = veh1;
由于veh1和veh2只是对对象的引用，第二行所做的不过是把veh1的引用（地址）赋值给veh2，使得veh1和veh2同时指向唯一的一个Vehicle对象。
6.3 veh2 = new Vehicle();
则引用变量veh2改指向第二个对象。
从以上叙述再推演下去，我们可以获得以下结论：①一个对象引用可以指向0个或1个对象；②一个对象可以有N个引用指向它。
则引用变量veh2改指向第二个对象。
从以上叙述再推演下去，我们可以获得以下结论：①一个对象引用可以指向0个或1个对象；②一个对象可以有N个引用指向它。
Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1903130
1．Java中的基本数据类型
Java中有2种基本数据类型：基本数据类型（在Java中，boolean、byte、short、int、long、char、float、double这八种是基本数据类型）、引用类型。其中，引用类型包括类类型（含数组）、接口类型。
Java中有2种基本数据类型：基本数据类型（在Java中，boolean、byte、short、int、long、char、float、double这八种是基本数据类型）、引用类型。其中，引用类型包括类类型（含数组）、接口类型。
2．java中栈（stack）与堆(heap)
在java中内存分为“栈”和“堆”这两种（Stack and Heap).基本数据类型存储 在“栈”中，对象引用类型实际存储在“堆”中，在栈中只是保留了引用内存的地址值。
在java中内存分为“栈”和“堆”这两种（Stack and Heap).基本数据类型
3．基本数据类型在栈中的存储
基本类型的定义是通过诸如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的值。
基本类型的定义是通过诸如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的值。
4．关于String str = "abc"的内部工作
Java内部将此语句转化为以下几个步骤：
①先定义一个名为str的对String类的对象引用变量：String str;
②在栈中查找有没有存放值为"abc"的地址，如果没有，则开辟一个存放字面值为"abc"的地址，接着创建一个新的String类的对象o，并将o 的字符串值指向这个地址，而且在栈中这个地址旁边记下这个引用的对象o。如果已经有了值为"abc"的地址，则查找对象o，并返回o的地址。
③将str指向对象o的地址。
值得注意的是，一般String类中字符串值都是直接存值的。但像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是否都指向了同一个对象。
再看以下代码：
String str2 = "abc";
System.out.println(str1==str2); //true
注意，我们这里并不用str1.equals(str2)；的方式，因为这将比较两个字符串的值是否相等。==号，根据JDK的说明，只有在两个引用都指向了同一个对象时才返回真值。而我们在这里要看的是，str1与str2是否都指向了同一个对象。
再看以下代码：
String str1 = "abc";
String str2 = "a"+"bc";
System.out.println(str1==str2); //true
String str2 = "a"+"bc";
System.out.println(str1==str2); //true
由上面两段代码结果说明，JVM创建了两个引用str1和str2，但只创建了一个对象，而且两个引用都指向了这个对象。
我们再来更进一步，将以上代码改成：
String str1 = "abc";
String str2 = "abc";
str1 = "bcd";
System.out.println(str1 + "," + str2); //bcd, abc
System.out.println(str1==str2); //false
我们再来更进一步，将以上代码改成：
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;
事实上，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
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 = 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
String str2 = new String("abc");
System.out.println(str1==str2); //false
创建了两个引用。创建了两个对象。两个引用分别指向不同的两个对象。
以上两段代码说明，只要是用new()来新建对象的，都会在堆中创建，而且其字符串是单独存值的，即使与栈中的数据相同，也不会与栈中的数据共享。
这里作如下总结（对后文引入intern（）方法有帮助）：
以上两段代码说明，只要是用new()来新建对象的，都会在堆中创建，而且其字符串是单独存值的，即使与栈中的数据相同，也不会与栈中的数据共享。
这里作如下总结（对后文引入intern（）方法有帮助）：
String str1 = "abc"; //共享内容值
String str2 = new String("abc");//不共享内容值
String str2 = new String("abc");//不共享内容值
我们从另一个角度来分析上面两句语句，从而引入常量池的概念。常量池（constant pool）指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。它包括了关于类、方法、接口等中的常量，也包括字符串常量。
String str1 = "abc";//是字符串常量，它在编译期被确定。
String str2 =new String("abc");
String str2 =new String("abc");
//不是字符串常量，不在编译期确定。
//new String()创建的字符串不放入常量池中。
5．总结Java中处理字符串的机制
由上面这些例子可发现JVM处理字符串的机制。Java虚拟机会维护一个内部的滞留字符串对象的列表（唯一字符串的池）来避免在堆内存中产生重复的String对象。当JVM从class文件里加载字符串字面量并执行的时候，它会先检查一下当前的字符串是否已经存在于滞留字符串列表，如果已经存在，那就不会再创建一个新的String对象而是将引用指向已经存在的String对象，JVM会在内部为字符串字面量作这种检查，但并不会为通过new关键字创建的String对象作这种检查。当然你可以明确地使用String.intern()方法强制JVM为通过 new关键字创建的String对象作这样的检查。这样可以强制JVM检查内部列表而使用已有的String对象。
所以结论是，JVM会内在地为字符串字面量维护一些唯一的String对象，程序员不需要为字符串字面量而发愁，但是可能会被一些通过 new关键字创建的String对象而困扰，不过他们可以使用intern()方法来避免在堆内存上创建重复的String对象来改善Java的运行性能。
由上面这些例子可发现JVM处理字符串的机制。Java虚拟机会维护一个内部的滞留字符串对象的列表（唯一字符串的池）来避免在堆内存中产生重复的String对象。当JVM从class文件里加载字符串字面量并执行的时候，它会先检查一下当前的字符串是否已经存在于滞留字符串列表，如果已经存在，那就不会再创建一个新的String对象而是将引用指向已经存在的String对象，JVM会在内部为字符串字面量作这种检查，但并不会为通过new关键字创建的String对象作这种检查。当然你可以明确地使用String.intern()方法强制JVM为通过 new关键字创建的String对象作这样的检查。这样可以强制JVM检查内部列表而使用已有的String对象。
所以结论是，JVM会内在地为字符串字面量维护一些唯一的String对象，程序员不需要为字符串字面量而发愁，但是可能会被一些通过 new关键字创建的String对象而困扰，不过他们可以使用intern()方法来避免在堆内存上创建重复的String对象来改善Java的运行性能。
6．Java中处理字符串的相关方法
6.1 Java.lang.Object对象的equals()源代码
Public boolean equals(Object obj){
Return (this= =obj);
}
Return (this= =obj);
}
6.2 String.equals()的代码
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = count;
if (n == anotherString.count) {
char v1[] = value;
char v2[] = anotherString.value;
int i = offset;
int j = anotherString.offset;
while (n-- != 0) {
if (v1[i++] != v2[j++])
return false;
}
return true;
}
}
return false;
}
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = count;
if (n == anotherString.count) {
char v1[] = value;
char v2[] = anotherString.value;
int i = offset;
int j = anotherString.offset;
while (n-- != 0) {
if (v1[i++] != v2[j++])
return false;
}
return true;
}
}
return false;
}
6.3 String的intern()方法
存在于.class文件中的常量池，在运行期被JVM装载，并且可以扩充。String的intern()方法就是扩充常量池的一个方法；当一个String实例str调用intern()方法时，Java查找常量池中是否有相同Unicode的字符串常量，如果有，则返回其的引用，如果没有，则在常量池中增加一个Unicode等于str的字符串并返回它的引用；看下面代码：
存在于.class文件中的常量池，在运行期被JVM装载，并且可以扩充。String的intern()方法就是扩充常量池的一个方法；当一个String实例str调用intern()方法时，Java查找常量池中是否有相同Unicode的字符串常量，如果有，则返回其的引用，如果没有，则在常量池中增加一个Unicode等于str的字符串并返回它的引用；看下面代码：
String s0= “abc”;
String s1=new String(”abc”);
String s2=new String(“abc”);
String s1=new String(”abc”);
String s2=new String(“abc”);
System.out.println( s0==s1 );
s1.intern();
s2=s2.intern(); //把常量池中“abc”的引用赋给s2
s2=s2.intern(); //把常量池中“abc”的引用赋给s2
System.out.println( s0==s1);
System.out.println( s0==s1.intern() );
System.out.println( s0==s2 );
System.out.println( s0==s1.intern() );
System.out.println( s0==s2 );
结果为：
false
false //虽然执行了s1.intern(),但它的返回值没有赋给s1
true //说明s1.intern()返回的是常量池中”abc”的引用
true ////说明s2.intern()返回的是常量池中”abc”的引用
false
false //虽然执行了s1.intern(),但它的返回值没有赋给s1
true //说明s1.intern()返回的是常量池中”abc”的引用
true ////说明s2.intern()返回的是常量池中”abc”的引用
回到前文引出常量池定义的部分：
String str1 = "abc";//是字符串常量，它在编译期被确定。
String str2 =new String("abc");
String str1 = "abc";//是字符串常量，它在编译期被确定。
String str2 =new String("abc");
//不是字符串常量，不在编译期确定。
//new String()创建的字符串不放入常量池中。
看下面代码：
看下面代码：
String s1=new String("abc");
String s2=s1.intern();
String s2=s1.intern();
System.out.println( s1==s1.intern() );
System.out.println( s1+" "+s2 );
System.out.println( s2==s1.intern() );
System.out.println( s1+" "+s2 );
System.out.println( s2==s1.intern() );
结果：
false //说明原来的“abc”仍然存在
abc abc
true // s2现在为常量池中“abc”的地址，所以有s2==s1.intern()为true
false //说明原来的“abc”仍然存在
abc abc
true // s2现在为常量池中“abc”的地址，所以有s2==s1.intern()为true
当调用 intern 方法时，如果池已经包含一个等于此 String 对象的字符串（该对象由 equals(Object) 方法确定），则返回池中的字符串。否则，将此 String 对象添加到池中，并且返回此 String 对象的引用。这是Java api文档中关于intern 方法的定义。
回到上面的代码示例。在这个类中一开始，我们没有声名一个”abc”常量，所以常量池中一开始是没有”abc”。当我们调用s1.intern()后就在常量池中新添加了一个”abc”常量，原来的不在常量池中的”abc”，即s1（表现为存储地址）仍然存在，所以s1==s1.intern()返回flase。
回到上面的代码示例。在这个类中一开始，我们没有声名一个”abc”常量，所以常量池中一开始是没有”abc”。当我们调用s1.intern()后就在常量池中新添加了一个”abc”常量，原来的不在常量池中的”abc”，即s1（表现为存储地址）仍然存在，所以s1==s1.intern()返回flase。
