int 和 Integer 有什么区别?

• Integer是int的包装类；int是基本数据类型；
• Integer变量必须实例化后才能使用；int变量不需要；
• Integer实际是对象的引用，指向此new的Integer对象；int是直接存储数据值 ；
• Integer的默认值是null；int的默认值是0。

• 两个new生成的Integer变量的对比

  由于Integer变量实际上是对一个Integer对象的引用，所以两个通过new生成的Integer变量永远是不相等的（因为new生成的是两个对象，其内存地址不同）。

  Integer i = new Integer(10000);
  Integer j = new Integer(10000);
  System.out.print(i == j); //false
  

  Integer变量和int变量的对比

  Integer变量和int变量比较时，只要两个变量的值是向等的，则结果为true（因为包装类Integer和基本数据类型int比较时，java会自动拆包装为int，然后进行比较，实际上就变为两个int变量的比较）

      int a = 10000;
      Integer b = new Integer(10000);
      Integer c=10000;
      System.out.println(a == b); // true
      System.out.println(a == c); // true
  

  非new生成的Integer变量和new Integer()生成变量的对比

  非new生成的Integer变量和new Integer()生成的变量比较时，结果为false。（因为非new生成的Integer变量指向的是java常量池中的对象，而new Integer()生成的变量指向堆中新建的对象，两者在内存中的地址不同）

      Integer b = new Integer(10000);
      Integer c=10000;
      System.out.println(b == c); // false
  

  两个非new生成的Integer对象的对比

  对于两个非new生成的Integer对象，进行比较时，如果两个变量的值在区间-128到127之间，则比较结果为true，如果两个变量的值不在此区间，则比较结果为false

  Integer i = 100;
  Integer j = 100;
  System.out.print(i == j); //true
  
  Integer i = 128;
  Integer j = 128;
  System.out.print(i == j); //false
  

  当值在 -128 ~ 127之间时，java会进行自动装箱，然后会对值进行缓存，如果下次再有相同的值，会直接在缓存中取出使用。缓存是通过Integer的内部类IntegerCache来完成的。当值超出此范围，会在堆中new出一个对象来存储。

  给一个Integer对象赋一个int值的时候，会调用Integer类的静态方法valueOf，源码如下：

  public static Integer valueOf(String s, int radix) throws NumberFormatException {
          return Integer.valueOf(parseInt(s,radix));
      }
  

  /**
   * （1）在-128~127之内：静态常量池中cache数组是static final类型，cache数组对象会被存储于静态常量池中。
   * cache数组里面的元素却不是static final类型，而是cache[k] = new Integer(j++)，
   * 那么这些元素是存储于堆中，只是cache数组对象存储的是指向了堆中的Integer对象（引用地址）
   * 
   * （2）在-128~127 之外：新建一个 Integer对象，并返回。
   */
  public static Integer valueOf(int i) {
          assert IntegerCache.high >= 127;
          if (i >= IntegerCache.low && i <= IntegerCache.high) {
              return IntegerCache.cache[i + (-IntegerCache.low)];
          }
          return new Integer(i);
      }
  
  

  IntegerCache是Integer的内部类，源码如下：

       /**
        * 缓存支持自动装箱的对象标识语义 -128和127（含）。
        * 缓存在第一次使用时初始化。 缓存的大小可以由-XX：AutoBoxCacheMax = <size>选项控制。
        * 在VM初始化期间，java.lang.Integer.IntegerCache.high属性可以设置并保存在私有系统属性中
       */
      private static class IntegerCache {
          static final int low = -128;
          static final int high;
          static final Integer cache[];
  
          static {
              // high value may be configured by property
              int h = 127;
              String integerCacheHighPropValue =
                  sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
              if (integerCacheHighPropValue != null) {
                  int i = parseInt(integerCacheHighPropValue);
                  i = Math.max(i, 127);
                  // Maximum array size is Integer.MAX_VALUE
                  h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
              }
              high = h;
  
              cache = new Integer[(high - low) + 1];
              int j = low;
              for(int k = 0; k < cache.length; k++) {
                  cache[k] = new Integer(j++); // 创建一个对象
              }
          }
  
          private IntegerCache() {}
      }