【java基础】java中String的注意点

【java的内存模型】

一、Java内存模型

 

按照官方的说法：Java 虚拟机具有一个堆，堆是运行时数据区域，所有类实例和数组的内存均从此处分配。

    JVM主要管理两种类型内存：堆和非堆，堆内存（Heap Memory）是在 Java 虚拟机启动时创建，非堆内存(Non-heap Memory)是在JVM堆之外的内存。

简单来说，非堆包含方法区、JVM内部处理或优化所需的内存（如 JITCompiler，Just-in-time Compiler，即时编译后的代码缓存）、每个类结构（如运行时常数池、字段和方法数据）以及方法和构造方法的代码。

    Java的堆是一个运行时数据区,类的(对象从中分配空间。这些对象通过new、newarray、 anewarray和multianewarray等指令建立，它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。 

　　栈的优势是，存取速度比堆要快，仅次于寄存器，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。栈中主要存放一些基本类型的变量数据（int, short, long, byte, float, double, boolean, char）和对象句柄(引用)。 

    虚拟机必须为每个被装载的类型维护一个常量池。常量池就是该类型所用到常量的一个有序集合，包括直接常量（string,integer和 floating point常量）和对其他类型，字段和方法的符号引用。 

　 　对于String常量，它的值是在常量池中的。而JVM中的常量池在内存当中是以表的形式存在的， 对于String类型，有一张固定长度的CONSTANT_String_info表用来存储文字字符串值，注意：该表只存储文字字符串值，不存储符号引 用。说到这里，对常量池中的字符串值的存储位置应该有一个比较明了的理解了。在程序执行的时候,常量池会储存在Method Area,而不是堆中。常量池中保存着很多String对象; 并且可以被共享使用，因此它提高了效率

 

 

二、String对象的存储

 

    请看这样两个语句：

String x = "abc"; String y = new String("abcd");

可以看出，x与y存在栈中，它们保存了相应对象的引用。第一条语句没有在堆中分配内存，而是将“abc”保存在常量池中。对于第二条语句，同样会在常量池 中有一个“abcd”的字符串，当new时，会拷贝一份该字符串存放到堆中，于是y指向了堆中的那个“abcd”字符串。

 

请看这样的语句

String s1="a";String s2="b";String s3=s1+s2;

S3的创建是将常量池的"a"和"b"拷贝一分组合成一个新的字符串，在堆中创建一份对象。栈中的s3变量指向堆中的"ab"

 

三：测试案例

package com.sxf.test.collections;

public class StringTest {
     public static void main(String[] args) {
         //test01();
         //test02();
        // test03();
         //test04();
        // test05();
         test06();
     }
     
     /**
      * s1在常量池中查找是否存在"a",结果没有，创建一个a的常量
      * s2在常量池中查找是否有，结果有，则指向常量池中的"a"
      * "=="比较的是地址
      * "equals"比较的是值
      */
     public static void test01(){
        String s1="a";
        String s2="a";
        System.out.println("StringTest.test01()==>"+(s1==s2));//true
        System.out.println("StringTest.test01()==>"+(s1.equals(s2)));//true
     }
     
     /**
      * s3的创建：在堆内存中创建一个对象，value为"ab".栈中的s1变量指向堆中的地址。
      * s4的创建：在常量池中创建"ab"常量，然后再在堆内存中创建一个对象，value为"ab"。栈中的s4变量指向堆中的地址。
      * 所以s3和s4的地址是不一样的。s3和s4的value是一样的。
      * 
      * s5中去常量池中查找是否存在ab,因为s4已经在常量池中创建"ab"，结果存在，所以s5指向常量池
      */
     public static void test02(){
         String s1="a";
         String s2="b";
         String s3=s1+s2;
         String s4=new String("ab");
         String s5="ab";
         System.out.println("StringTest.test02()==>"+(s3==s4));//false
         System.out.println("StringTest.test02()==>"+(s3.equals(s4)));//true
         System.out.println("StringTest.test02()==>"+(s3==s5));//false
         System.out.println("StringTest.test02()==>"+(s3.equals(s5)));//true
         
     }
     
     /**
      * 两个常量的字面相加，还是保存在常量池中。
      * s2的机制：常量的值在编译的时候就被确定(优化)了。 
      * 在这里，"a"和"1"都是常量，因此变量s2的值在编译时就可以确定。 
      * 这行代码编译后的效果等同于： String s2 = "abcd"; 
      */
     public static void test03(){
            String s1 = "a1";  
            String s2 = "a" +"1";  
            System.out.println("StringTest.test03()===>"+(s1==s2));//true
     }
     
     /**
      * s4:栈中的变量和一个常量相加，需要在堆内存中创建一份对象
      * s5:两个栈中的变量相加，需要在堆中创建一份对象。
      * s4:这个s4的数值在运行时才能确定，因此产生一份对象。
      * 
      */
     public static void test04(){
         String s1="a1";
         String s2="a";
         String s3="1";
         String s4=s2+"1";
         String s5=s2+s3;
         System.out.println("StringTest.test04()===>"+(s1==s4));//false
         System.out.println("StringTest.test04()===>"+(s1==s5));//false
         System.out.println("StringTest.test04()===>"+(s4==s5));//false
     }

     /**
      *final修饰的是常量，所有s3在创建的时候，还是现在常量池中查找是否存在"ab",结果存在，所以共享。结果为true
      */
     public static void test05(){
         String s1 = "ab";  
         final String s2 = "b";  
         String s3 = "a" + s2;  
         System.out.println("StringTest.test05()===>"+(s1==s3));//true     
     }
     
     /**
      * final String s2 = getBB();其实与final String s2 = new String(“b”);是一样的。
      * 也就是说return “b”会在堆中创建一个String对象保存”b”，
      * 虽然s2被定义成了final。可见并非定义为final的就保存在常量池中，
      * 很明显此处s2常量引用的String对象保存在堆中，因为getBB()得到的String已经保存在堆中了，
      * final的String引用并不会改变String已经保存在堆中这个事实。
      */
     public static void test06(){
             String s1 = "ab";  
            final String s2 = getBB();  
            String s3 = "a" + s2;  
            System.out.println("StringTest.test06()===>"+(s1==s3));//false
     }
     private static String getBB() {  
            return "b";  
     }  
    
         /**
          * 可能很多人对intern()这个函数不了解。JDK API文档中对intern()方法的描述是：
          * 返回字符串对象的规范化表示形式。
          * 一个初始为空的字符串池，它由类 String 私有地维护。
          * 当调用 intern 方法时，如果池已经包含一个等于此 String 对象的字符串（用 equals(Object) 方法确定），则返回池中的字符串。否则，将此 String 对象添加到池中，并返回此 String 对象的引用。
          * 它遵循以下规则：对于任意两个字符串 s 和 t，当且仅当 s.equals(t) 为 true 时，s.intern() == t.intern() 才为 true。
          * 所有字面值字符串和字符串赋值常量表达式都使用 intern 方法进行操作。
          * 上面字符串池即为字符串常量池。明白该题结果的原因了吧。
          */
        private static String a = "ab";  
        public static void test07() {  
            String s1 = "a";  
            String s2 = "b";  
            String s = s1 + s2;  
            System.out.println("StringTest.test07()==>"+(s==a));//flase
            System.out.println("StringTest.test07()==>"+(s.intern()==a));//true
        }  
}

View Code