java包装类的自动封装、自动拆箱和缓存

/**
* 包装类的自动封装、自动拆箱和缓存
*/
public class TestWrapper2 {
   public static void main(String[] args) {
       Integer i1 = 1;
       //自动封装 通过编译器编译后转变为 Integer i1 = Integer.valueOf(1); 供虚拟机执行
       //Integer i1 引用类型变量
       int i2 = i1;
       //自动拆箱 通过编译器编译后转变为 int i2 = i1.intValue(); 供虚拟机执行
       //int i2 基本数据类型
       Integer i3 = null;
       i2 = i3;
       //运行时报错NullPointerException 在虚拟机运行时代码已经变为 i2 = i3.intValue() 但i3为null空指针 没有指向对象就找不到.intValue()方法

       Integer i4 = 4000;
       Integer i5 = 4000;
       System.out.println(i4==i5);
       //结果false i4 = Integer.valueOf(4000) Integer静态方法.valueOf()执行后会new一个新的对象给i4 value值为4000
       //i5 = Integer.valueOf(4000) 同样会new一个新的对象给i5  i4和i5分别指向两个对象
       System.out.println(i4.equals(i5));
       //结果true Integer重写的equals()方法 在判断i5 instanceof Integer 判断i5是Integer的实例后比较i4和i5的value 两个value都是4000所以true
       Integer i6 = 123;
       Integer i7 = 123;
       System.out.println(i6==i7);
       //结果true 原因：在Integer初始化时缓存了整数范围在[-128,127]之间的包装类对象
       //当i6 = Integer.valueOf(123)时 方法没有new新的包装类对象 而是将缓存中提前创建好的value=123的对象返回给i6
       //i7 = 123同理  i6和i7指向的是同一个对象
       /*
           public static Integer valueOf(int i) {
           //静态方法valueOf() 返回Integer类对象
               if (i >= IntegerCache.low && i <= IntegerCache.high)
               //IntegerCache整数缓存 .low=-128 .high=127 系统运行时已经提前建好了-128到127的整数的包装类放到了缓存数组中
                   return IntegerCache.cache[i + (-IntegerCache.low)];
                   //当判断i在-128到127之间 返回对应的对象
               return new Integer(i);
               //当i不在缓存数组的范围内是new对象返回
        */

   }
}

class ImitateInteger {
   //imitate模仿Integer缓存数组
   private int value;
   //每个对象对应一个value值
   private ImitateInteger(int i){
       //将构造器私有 外部生成对象时需要通过.valueOf()方法
       this.value = i;
   }
   private static final int LOW = -128;
   //模拟[-128,127] 两个值设为final常量 private仅方法内判断时调用 static这个属性不需要给对象
   private static final int HIGH = 127;
   private static final ImitateInteger[] cache = new ImitateInteger[HIGH-LOW+1];
   //创建一个数组准备缓存[-128,127]之间的对象 -128到-1是128个 1到127是127个 再加一个0 [127-(-128)+1]
   //换一种想法 从HIGH到LOW总共有HIGH-LOW个数 包含HIGH没包含LOW 所以再+1
   static {
       //静态初始化块 在类加载时执行
       for (int i=LOW;i<=HIGH;i++){
           cache[i+(-LOW)] = new ImitateInteger(i);
           //数组的index范围[0]-[255] i=LOW i-LOW=0  i=HIGH i-LOW=255
           //将value=-128的对象交给cache[0]   value=127的对象交给cache[255]
           //在类加载时即缓存new了-128到127
       }
   }

   public static ImitateInteger valueOf(int i){
       //public供外部调用的代替私有构造器的方法 代替构造器所以返回ImitateInteger对象
       if (i>=LOW&&i<=HIGH){
           //判断i是否在[-128,127]区间
           return cache[i+(-LOW)];
           //对应静态初始化快中的缓存数组 i对应的对象的index要加128即(-LOW)
       }
       return new ImitateInteger(i);
       //不在区间内则new新对象返回
   }

   public static void main(String[] args) {
       ImitateInteger i1 = ImitateInteger.valueOf(1);
       ImitateInteger i2 = ImitateInteger.valueOf(1);
       System.out.println(i1==i2);
       //结果true i1和i2都没有new对象 返回了cache[1+(-(-128))]即cache[129]  cache[129].value对应1

       ImitateInteger i3 = ImitateInteger.valueOf(200);
       ImitateInteger i4 = ImitateInteger.valueOf(200);
       System.out.println(i3==i4);
       //结果false i3和i4分别指向new新生成的对象
   }

   public boolean equals(Object o){
       //重写继承自Object 的equals()
       if (o instanceof ImitateInteger){
           return this.value==((ImitateInteger)o).value;
           //比较两个对象的value  将o强转为ImitateInteger
       }
       return false;
       //不是同类返回false
       // this.equals(o); 用来比较两个对象所以不是static方法
   }

   public int intValue(){
       return this.value;
       //int a = i4.intValue(); 将包装类转为基本数据类型 要转换的是对象 所以不用static
   }

   @Override
   public String toString() {
       //重写toString
       return ""+this.value;
       //返回值只能是字符串
   }
}