Java整数缓存 - 为什么Integer.valueOf（127）== Integer.valueOf（127）为True

在一次采访中，我的一个朋友被问到，如果我们有两个整数对象，Integer a = 127; Integer b = 127;为什么要a == b的值为true ?在本文中，我将尝试回答这个问题，并解释这个问题的答案。这个问题的简短回答是，将int文字直接分配给Integer引用是自动装箱概念的一个示例，其中文字值到对象转换代码由编译器处理，因此在编译期间编译器转换Integer a = 127;为Integer a = Integer.valueOf(127);。

所述Integer类维护内部IntegerCache为整数，其通过从默认范围-128 to 127和Integer.valueOf()方法返回的上述范围的对象从该高速缓存中。所以a == b返回因为真正的a和b两者都指向同一个对象。

为了理解简短的回答让我们首先了解Java类型，Java中的所有类型都分为两类

1. 基元类型： Java中有8种基本类型（byte，short，int，long，float，double，char和boolean），它们以二进制位的形式直接保存它们的值。
   例如，int a = 5; int b = 5;在这里a和b直接持有的5二进制值，如果我们试图比较a和b使用a == b我们实际上是在比较5 == 5其返回true。
2. 引用类型：除基本类型之外的所有类型都位于引用类型的类别下，例如类，接口，枚举，数组等。引用类型保存对象的地址而不是对象本身。
   例如Integer a = new Integer(5); Integer b = new Integer(5)，这里a和b不成立的二进制值5，而不是a和b拥有两个不同的对象其中两个对象包含的值的内存地址5。因此，如果我们尝试比较a和b使用，a == b,我们实际上是比较这两个单独的内存地址，因此我们得到false，执行实际的相等a，b我们需要执行a.euqals(b)。

• 参考类型进一步分为4类Strong, Soft, Weak and Phantom。

我们知道Java为所有原始类型提供包装类，并支持自动装箱和自动拆箱。

// Example of auto-boxing, here c is a reference type
Integer c = 128; // Compiler converts this line to Integer c = Integer.valueOf(128);   
// Example of auto-unboxing, here e is a primitive type 
int e = c; // Compiler converts this line to int e = c.intValue();

现在，如果我们创建两个整数对象a并b,尝试使用相等运算符进行比较==，我们将得到，false因为两个引用都持有不同的对象

Integer a = 128; // Compiler converts this line to Integer a = Integer.valueOf(128);
Integer b = 128; // Compiler converts this line to Integer b = Integer.valueOf(128);
System.out.println(a == b); // Output -- false

但是如果我们将值赋给127两者a并b尝试使用相等运算符进行比较==，我们会得到true原因吗？

Integer a = 127; // Compiler converts this line to Integer a = Integer.valueOf(127);
Integer b = 127; // Compiler converts this line to Integer b = Integer.valueOf(127);
System.out.println(a == b); // Output -- true

正如我们在，我们分配给不同的对象代码中看到的a和b，但a == b可以返回true只有两个a和b都指向同一个对象。

那么比较如何才真实呢？这里到底发生了什么？是a和b指向同一个对象？

到目前为止，我们知道代码Integer a = 127;是自动装箱的一个例子，编译器会自动将此行转换为Integer a = Integer.valueOf(127);。

所以Integer.valueOf()这是返回这些整数对象的方法，这意味着这种方法必须在引擎盖下做一些事情。

如果我们看一下Integer.valueOf()方法的源代码，我们可以清楚地看到，如果传递的int literal i大于IntegerCache.low且小于IntegerCache.high该方法，则返回Integer对象IntegerCache。默认值IntegerCache.low和IntegerCache.high是-128和127分别。

换句话说，如果传递的int literal大于和小于，则Integer.valueOf()方法不是创建和返回新的整数对象，而是从内部返回Integer对象。IntegerCache``-128``127

/** 
* Returns an {@code Integer} instance representing the specified 
* {@code int} value. If a new {@code Integer} instance is not 
* required, this method should generally be used in preference to 
* the constructor {@link #Integer(int)}, as this method is likely 
* to yield significantly better space and time performance by 
* caching frequently requested values. 
* 
* This method will always cache values in the range -128 to 127, 
* inclusive, and may cache other values outside of this range. 
* 
* @param i an {@code int} value. 
* @return an {@code Integer} instance representing {@code i}. 
* @since 1.5 
*/ 
public static Integer valueOf(int i) { 
    if (i >= IntegerCache.low && i <= IntegerCache.high) 
        return IntegerCache.cache[i + (-IntegerCache.low)]; 
    return new Integer(i); 
}

Java缓存整数对象，这些对象属于-128到127范围，因为这个整数范围在日常编程中被大量使用，间接节省了一些内存。

正如您在下面的图像Integer类中看到的那样，维护一个内部静态IntegerCache类，它充当缓存并保存-128到127的整数对象，这就是为什么当我们尝试获取整数对象时，127我们总是得到相同的对象。

当类被加载到内存中时，缓存会在第一次使用时初始化static block。可以通过-XX:AutoBoxCacheMaxJVM选项控制缓存的最大范围。

此缓存行为是不适用Integer的对象而已，类似于Integer.IntegerCache我们也有ByteCache，ShortCache，LongCache，CharacterCache为Byte，Short，Long，Character分别。

字节，短和长在-127到127（含）之间有一个固定的缓存范围，但对于Character，范围是0到127（含）。范围只能通过参数修改为Integer而不能修改为其他范围。

您可以在此Github存储库中找到本文的完整源代码，请随时提供宝贵的反馈。

翻译自：https://medium.com/@njnareshjoshi/java-integer-cache-why-integer-valueof-127-integer-valueof-127-is-true-e5076824a3d5

`