java 字符串类型知道少

package com.easyway.commons.ispace.dev.oop.questions;
/**
 * 
 * String的学习应用：
 * String的intern()方法 
 *“当调用 intern 方法时，如果池已经包含一个等于此 String 对象的字符串（该对象由 equals(Object) 方法确定），
 *则返回池中的字符串；否则，将此 String 对象添加到池中，并且返回此 String 对象的引用。它遵循对于任何两个字符
 *串 s 和 t，当且仅当 s.equals(t) 为 true 时，s.intern() == t.intern() 才为 true”，这是jdk文档原文
 *注解。现在我们回到最开头的那个例子，为什么String str=new String("aaa");会产生2个对象？一个是"aaa"又作
 *为字符串构造函数的参数，但"aaa"自己就是一个字符串，在传进构造函数前就已创建了一个字符对象，实质上与就好比是
 *第二个实例：String str="aaa"; ，它创建的字符串对象会放入到池中，并且引用的也是池中的那个字符串对象；
 *另一个就是通过new String()构造函数创建的。所以new String("aaa")会产生两个对象，也就是说通过此种方式创
 *建字符串对象时，会先将字符串参数对象放入对象池，然后另外创建一个字符串对象。理解完new String("aaa")为什么
 *会产生两个对象，我们再来看看new String(char value[])这样的方式创建时，又会不会把字符串对象放入到池中呢？
 *答案是不会的。因为传递给构造函数的是一个字符数组，而不是像前面传递的是一个字面常量字符串参数那样，将字符串参
 *数本身放入池中。那么我们现在如果证明new String(char value[])未将字符串对象放入池中，我们可以写一个简单
 *的测试，运行时打开XP的任务管理器，查看操作系统的内存使用情况就可以初步确认：
 *方法测试如下：monitorCPU（）
 *所以创建字符串对象放入并放入池中有二种方式：第一种就是直接使用字面常量定义字符串时，如 String str="aaa"; ，
 *str会引用放入池中的对象；第二种就是使用带字符串参数的字符串构造函数，并且此时传入的参数值要是字符串常量形式，
 *而不能是变量的形式，也就是说只能是 String str=new String("aaa");形式，而不能是先定义 String s = "aaa"，
 *然后再使用 String str=new String(s);来创建对象，new String(s);此时只创建一个对象，但如果池中不存在时我
 *们可以使用intern方法将它放入池中。当然上面放入池中的前提是池中还不存在这些字符串对象。其实，当我们仔细研究时，
 *发现放入池中只实质上只存在一种时机，那就是：直接使用字面常量字符串时。上面所说的两种时机实质上就是直接使用了字面常的字符串而将其放入池中的。
*上面多处提到了JVM中的堆栈，下面小结一下各自原作用：
*栈用来保存基本类型与对象的引用的，基本型在创建前会查看Stack中是否已经有, 有则指向, 没有则创建。
*String内部是以字符串数组来存储字符串的，因此可以认为与char[]等同, String a= "abc",首先在Heap中创一个对
*象,再到Stack中找char[]是否存在,有则指向该地址, 无则在Stack中创建数组 new出来的都是在Heap中，堆是用于存储对象的。
 *
 *
 * @author longgangbai
 * @date 2010-5-14
 * @version 1.0
 * @since JDK6.0
 */
public class JavaString {
	
	
	/**
	 * 下面声明相等于两个字符串：一个有java虚拟机创建的字符串常量“aaa”和创建在堆时的原实例对象。
	 * str是一个字符串的声明，是一个字符串的引用，放在堆里，用来指向对中创建出来的对象。
	 * 相当于一个字符创创
	 * 
	 * 常量池(constant pool)指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。
	 * 它包括了关于类、方法、接口等中的常量，也包括字符串常量。
	 */
     String  str=new String("aaa");
     /**
      * 只创建1个对象。这里涉及到字符串常量池，在JVM中有一个字符串池，它用来保存很多可以被共享的
      * String对象，这样如果我们在使用同样字面字符串时，它就使用字符串池中同字面的字符串。当然我
      * 们可以使用String对象的intern()方法来访问String对象在字符串池中所对应的常量对象。 
      * 上面这行代码被执行的时候，JVM先到字符串池中查找，看是否已经存在值为"aaa"的对象，如果存在，
      * 则不再创建新的对象，直接返回已存在对象的引用；如果不存在，则先创建这个对象，然后把它加入到
      * 字符串池中，再将它的引用返回。
      */
     String constStr1="aaa";
     /**
      * 也只创建1个对象。能过上面的解释这个就更清楚了，在执行第二行代码时，aaa字符串对象在池中已存在，
      * 所以直接返回池中已存在的那个字符串对象。
      */
     String constStr2="aaa";
     
     
     /**
      * 还是只创建1个对象。由于常量字符串是在编译的时候就也被确定的，又因"aaa"和"bbb"都是常量，因此变
      * 量str的值在编译时就可以确定。这行代码编译后的与String str="aaabbb";是一样的，这与我们平时
      * 好像不太一样啊？一般使用“+”连接两个字符串都会产生另一个新的字符对象。
      */
     String constStr3="aaa"+"bbb";
     
     //但如果先定义final字符串，但未在定义处初始化，而初始化在块中，如下：
     //此时str1与str2相当于变量，而不是常，因为块是在运行时才能确定，在编译时不能确定
	 final static String str9;  
	 final static String str10;  
	 static {  
	         str9 ="aaa";  
	         str10 ="bbb";  
	 }
     
     
     /**
      * 使用“+”连接的两个字符串本身就是字面常量字符串时，如果池中存在这样连接
      * 后的字符串，则是不会重新创建对象，而是直接引用池中的字符串对象；如果“+”连接的两字符串中只要有一个
      * 不是字面常量串（即定义过的），是会产生新的字符串对象。凡事也有例外，这个也不例外：如果“+”连接的字
      * 符串中两个或一个不是“字面常量”，但如果定义成常量字符串时，情况又有变化：
      * @param args
      */
     public static void main(String[] args) {
    	 String str1 = "aaa";
    	 String str2 = "bbb";
    	 String str3 = "aaabbb";

    	 String str4 = "aaa" + "bbb";//不会产生新的字符串对象
    	 System.out.println(str3 == str4);//true

    	 str4 = str1 + "bbb";//会产生新的字符串对象
    	 System.out.println(str3 == str4);//false

    	 str4 = str1 + str2;//会产生新的字符串对象
    	 System.out.println(str3 == str4);//false
    	 
    	 
    	 
    	 final String str5 = "aaa";
    	 final String str6 = "bbb";
    	 String str7 = "aaabbb";

    	 /*
    	  * 因为str1与str2都定义成了常量，所以编译时就能确定，编译时就会将常量替换，等同于
    	  * str4 = "aaa"+"bbb"，因此不产生新对象
    	  */
    	 String str8 = str5 + str6;
    	 System.out.println(str7 == str8);//true
    	 
    	 
    	 
    	 String str11 = str9 + str10;
         String str12 ="aaabbb";  
         System.out.println(str11==str12);   //输出为false
    	 
    	 
    	 
    	 
	}
     
     public void monitorCPU() throws InterruptedException{
    	 int size = 10000000;
    	 char c[] = new char[size];
    	 for (int i = 0; i < size; i++) {
    	     c[i] = 'a';
    	 }
    	 //使用带字符数组参数构造函数创建字符串时，字符串对象不会放入字符串池
    	 String str1 = new String(c);
    	 System.out.println("String字符串对象创建完毕...");
    	 Thread.sleep(5000);
    	 str1.intern();//到里会看见内存增加
    	 System.out.println("第一次调用intern()完毕...");
    	 Thread.sleep(5000);
    	 str1.intern();//再过5秒将看不到内存增长，因为池中有了，不会再放入，所以内存无变化
    	 System.out.println("第二次调用intern()完毕...");
    	 Thread.sleep(5000);
     }
     
}