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    } }