水滴石穿-int和Integer的比较

本文最后更新于：March 6, 2023 pm

积土成山，风雨兴焉；积水成渊，蛟龙生焉；积善成德，而神明自得，圣心备焉。故不积跬步，无以至千里，不积小流无以成江海。齐骥一跃，不能十步，驽马十驾，功不在舍。面对悬崖峭壁，一百年也看不出一条裂缝来，但用斧凿，能进一寸进一寸，能进一尺进一尺，不断积累，飞跃必来，突破随之。

目录

预知知识：基本类型和包装类、装箱和拆箱。

区别

int 和 Integer 有什么区别?

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

Integer变量和int变量的对比

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

1
2
3
4
5
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变量比较

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

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

非new的Integer变量和new的变量的比较

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

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

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

对于两个非new生成的Integer对象，进行比较时，如果两个变量的值在区间-128到127之间，则比较结果为true，如果两个变量的值不在此区间，则比较结果为false。主要原因在于包装类型的缓存机制。

1
2
3
4
5
6
7
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出一个对象来存储。

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
/**
      * 缓存支持自动装箱的对象标识语义 -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() {}
}


int类型赋给Integer类型

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

1
2
3
public static Integer valueOf(String s, int radix) throws NumberFormatException {
  return Integer.valueOf(parseInt(s,radix));
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
 * （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);
}


个人总结

一定等：Integer和int值相等时，两个一定等。

一定不等（都是Integer）：只要是和new的比较，则就一定不等。

非new的两个Integer，看是否在-128~127之间，在，则相等；否则不等。