java基础知识回顾之---java String final类 容易混淆的java String常量池内存分析

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
    }

 
}