Java八股文——Java基础「数据类型篇」

参考小林coding和Java Guide

八种基本的数据类型

Java支持的数据类型分为两类：基本数据类型和引用数据类型。

基本数据类型共有8种，可以分为三类：

• 数值型：整数类型（byte、short、int、long）和浮点类型（float、double）
• 字符型：char
• 布尔型：boolean

请注意以下几点：

• Java八种基本数据类型的字节数：1字节(byte、boolean)、2字节(short、char)、4字节(int、float)、8字节(long、double)
• 浮点数的默认类型为double（如果需要声明一个常量为float型，则必须要在末尾加上f或F）
• 整数的默认类型为int（声明Long型在末尾加上l或者L）
• 八种基本数据类型的包装类：除了char的是Character、int类型的是Integer，其他都是首字母大写
• char类型是无符号的，不能为负，所以是0开始的

int和long是多少位，多少字节的？

面试官您好，关于int和long这两种Java中的基本数据类型，它们都是用来表示整数的，主要区别在于它们能够存储的数值范围和占用的内存空间。

具体来说：

• int类型：
  • 它在Java中是一个32位（bit）的有符号整数。
  • 因此，它占用4个字节（byte）的内存空间。
  • 作为有符号整数，int的取值范围是从 -2³¹ 到 2³¹-1，这大约是负21亿到正21亿。
  • 在实际应用中，int是我们最常用的整数类型。比如用作简单的计数器、表示年龄、或者一些常规数量等，如果数值不会超出这个范围，int通常是默认和合适的选择。如果计数值超过了这个范围，确实会发生溢出，导致结果不准确。
• long类型：
  • 它是一个64位（bit）的有符号整数。
  • 相应地，它占用8个字节（byte）的内存空间。
  • long的取值范围就大很多了，是从 -2⁶³ 到 2⁶³-1。这是一个非常大的数值范围。
  • 当我们需要处理的整数可能会超过int所能表示的范围时，就应该使用long类型。您举的例子非常好，比如在文件传输程序中表示文件的大小（特别是大文件），或者在数据库中用作自增ID且预计ID会非常大，还有像表示时间戳（通常是毫秒数）等场景，long类型都能很好地胜任。

所以，在选择使用int还是long时，主要还是根据我们对业务数据可能达到的最大值的预估来决定的，以确保数据能够被正确存储和处理。

超过 long 整型的数据应该如何表示？

面试官您好，当我们需要表示的整数超出了 long 类型的最大范围时，Java 的基本数据类型 long 就不够用了。在这种情况下，Java 提供了一个非常强大的类来处理这种大整数，那就是 java.math.BigInteger。

BigInteger 类有以下几个关键特性，使得它能够表示任意大小的整数：

• 任意精度：理论上，BigInteger 可以表示的整数大小只受限于可用的内存空间。无论这个数字有多大，只要内存足够，BigInteger 都能准确地表示出来。
• 对象而非基本类型：与 int 或 long 这些基本数据类型不同，BigInteger 是一个对象。这意味着我们需要通过创建 BigInteger 的实例来使用它。
• 通过方法进行运算：由于 BigInteger 是对象，我们不能直接使用像 +, -, *, /这样的算术运算符对它们进行操作。相反，BigInteger 类提供了一整套方法来进行各种算术运算，比如 add(), subtract(), multiply(), divide(), mod(), pow() 等等。这些方法会返回一个新的 BigInteger 对象作为运算结果，因为 BigInteger 对象是不可变的（immutable）。
• 构造方式：通常，我们会使用包含数字的字符串作为参数来构造 BigInteger 对象，以确保能够精确表示非常大的数值。例如：

BigInteger veryLargeNumber = new BigInteger("123456789012345678901234567890");
BigInteger anotherLargeNumber = new BigInteger("987654321098765432109876543210");
BigInteger sum = veryLargeNumber.add(anotherLargeNumber);

使用字符串构造可以避免在转换过程中因超出基本类型范围而导致的精度损失。

所以，总结来说，当遇到需要处理可能超过 long 类型表示范围的极大整数时，比如在密码学、某些科学计算或者需要精确表示非常大ID的场景下，BigInteger 就是Java中标准且可靠的选择。它牺牲了一部分基本数据类型操作的性能，但换来了表示任意大小整数的能力和运算的精确性。

long和int可以互转吗 ？

long和int类型之间是可以相互转换的，不过转换的方向和方式有所不同，并且需要注意潜在的数据精度问题。

具体来说，分为两种情况：

• 从 int 转换为 long：
  • 这是从小范围类型向大范围类型的转换，也叫作“拓宽转换”或“向上转型”。
  • 由于long的表示范围（64位）远大于int的表示范围（32位），所以这种转换是安全的，不会发生数据丢失或溢出。
  • Java编译器会自动进行这种转换，我们不需要做任何特殊的处理，这称为隐式转换。
  • 例如：

int a = 100;
long b = a; // 这是完全合法的，b的值就是100

• 从 long 转换为 int：
  • 这是从大范围类型向小范围类型的转换，也叫作“窄化转换”或“向下转型”。
  • 这种转换是有风险的。因为long类型可以存储比int类型大得多的数值。如果一个long类型变量的实际值超出了int所能表示的范围，那么在转换时就会发生数据截断，导致最终得到的int值与原始的long值不符，丢失了高位的数据。
  • 因此，Java编译器不会自动进行这种转换，如果需要转换，必须使用显式强制类型转换，也就是在long类型的变量前加上 (int)。这其实也是在提醒开发者，这里可能存在数据丢失的风险，需要自己来保证转换的安全性。
  • 例如：

long c = 100L;
int d = (int) c; // c的值在int范围内，d的值是100，转换正确long e = 3000000000L; // 30亿，超出了int的最大值 (约21亿)
int f = (int) e;     // 强制转换，f的值会因为高位截断而变成一个不正确的值
// (具体结果是保留e的低32位，可能是负数或一个小的正数)

总结一下：int转long是安全的，自动进行；long转int则需要强制转换，并且开发者必须非常清楚原始long值是否在int的表示范围内，否则就可能导致数据不准确。在实际编程中，如果确定long的值不会超过int的范围，可以进行强制转换，否则就需要重新考虑数据类型的设计或者进行相应的范围检查

数据类型转换方式你知道哪些？

面试官您好，关于Java中的数据类型转换方式，我了解到的主要有以下几种：

• 自动类型转换（隐式转换）：
  这种情况发生在我们将一个小范围的数据类型赋值给一个大范围的数据类型时。比如，把一个 int 类型的值赋给一个 long 类型的变量，或者把一个 float 赋给 double。因为目标类型的表示范围比源类型更大，所以这种转换是安全的，不会导致数据丢失或精度降低。Java编译器会自动帮我们完成这种转换，我们不需要写任何特殊的代码。例如：

int i = 100;
long l = i; // 自动从int转换为long
float f = 3.14f;
double d = f; // 自动从float转换为double

• 强制类型转换（显式转换）：
  这种转换则相反，是当我们需要将一个大范围的数据类型赋值给一个小范围的数据类型时。比如，想把一个 long 类型的值赋给 int，或者把 double 赋给 int。由于目标类型的范围较小，这种转换可能会导致数据丢失（比如高位被截断）或者溢出，所以是有风险的。因此，Java要求我们必须显式地进行这种转换，通过在源数据前加上 (目标类型) 这样的语法。这样做也是在提醒开发者，这里可能存在数据转换的风险，需要自己来确保转换的合理性。
  例如：

long l = 1234567890123L;
int i = (int) l; // 强制将long转换为int，可能会有数据丢失
double d = 99.99;
int k = (int) d; // 强制将double转换为int，小数部分会被截断，k会是99

这里也包括一些特殊的转换，比如将一个表示ASCII码或Unicode码的int值转换为char类型，也需要强制转换：char c = (char) 65; // c 会是 ‘A’。

• 字符串与其他数据类型之间的转换：
  这在实际开发中非常常见。
  • 将字符串转换为数值类型：我们通常会使用对应包装类提供的 parseXxx()静态方法。比如，Integer.parseInt(“123”) 会将字符串 “123” 转换为 int 类型的 123；Double.parseDouble(“3.14”) 会将字符串 “3.14” 转换为 double 类型的 3.14。如果字符串格式不正确，这些方法会抛出 NumberFormatException。
  • 将其他数据类型转换为字符串：最简单的方式是使用 String.valueOf() 方法，它可以接收各种基本类型或对象作为参数。或者，也可以调用对象的 toString() 方法（对于基本类型，它们的包装类有 toString() 方法，也可以通过字符串拼接自动转换）。例如：

String s1 = String.valueOf(100); // int转String
String s2 = String.valueOf(true); // boolean转String
Integer num = 200;
String s3 = num.toString(); // 包装类对象转String

• 通过包装类进行转换：
  Java的包装类（如 Integer, Long, Double, Character 等）在类型转换中也扮演了重要角色。除了上面提到的 parseXxx() 和 toString() 方法：
  • 它们实现了自动装箱和拆箱，允许我们在基本类型和其对应的包装类对象之间无缝转换。
  • 包装类对象也提供了 xxxValue() 方法，比如 intValue(), doubleValue() 等，可以将包装类对象转换为对应的基本类型值。
  • 对于字符和数字的转换，Character 类也提供了一些有用的方法，比如 Character.getNumericValue(char) 可以将一个数字字符（如 ‘7’）转换为其对应的 int 值（7）。

总的来说，选择哪种转换方式取决于具体的转换需求和数据类型之间的关系，关键是要注意转换的安全性，特别是强制类型转换时可能发生的数据丢失问题。

类型互转会出现什么问题吗？

在Java中进行数据类型转换时，确实可能会遇到一些问题，特别是在不恰当的转换或者没有充分考虑到数据特性的时候。

• 数据丢失（通常指窄化转换中的高位截断）：
  这是最常见也最需要注意的问题。当我们将一个表示范围较大的数据类型强制转换为一个表示范围较小的数据类型时（比如 long 转 int，或者 double 转 int），如果原始值超出了目标类型的表示范围，就会发生数据丢失。
  • 对于整数类型，比如 long 转 int，如果 long 的值大于 Integer.MAX_VALUE 或小于 Integer.MIN_VALUE，转换后高位的字节会被直接截断，只保留低位的32位，导致最终的 int 值与原始 long 值完全不同。例如：long bigNum = 3000000000L; int smallNum = (int) bigNum; 这里 smallNum 就会是一个不正确的值，因为30亿超出了int的正数范围。
  • 对于浮点数转换为整数，小数部分会被直接舍弃（截断，不是四舍五入）。例如：double pi = 3.99; int intPi = (int) pi; 那么 intPi 的值会是 3。
• 精度损失（Precision Loss）：
  这主要发生在浮点数相关的转换中。
  • 当您将一个 double（双精度，64位）强制转换为 float（单精度，32位）时，如果 double 值的有效数字位数超出了 float 所能精确表示的范围，那么转换后的 float 值就会损失一部分精度。例如，一个具有很多位小数的 double 值转换为 float 后，可能只能保留前面几位有效数字。
• 类型不匹配导致的编译或运行时错误：
  • 编译时错误：如果您尝试在不兼容的类型之间进行转换而没有进行强制转换（比如直接把一个 double 赋值给 int 变量，或者把一个 Object 类型的引用赋值给一个具体的子类如 String 而不加强制转换），编译器通常会报错。
  • 运行时错误 (ClassCastException)：这主要发生在对象类型的强制转换（向下转型）。如果您有一个父类类型的引用，它实际指向的是一个子类对象，那么可以安全地将其强制转换为该子类类型。但是，如果这个父类引用实际指向的并不是目标子类的实例（或者是指向了父类自身的实例，而你想转成子类），那么在运行时就会抛出 ClassCastException。例如：

Object obj = "Hello"; // obj 实际引用一个String对象
String str = (String) obj; // 安全Object obj2 = new Integer(10); // obj2 实际引用一个Integer对象
// String str2 = (String) obj2; // 编译通过，但运行时会抛出 ClassCastException

字符串转换，比如 Integer.parseInt(“abc”)，如果字符串内容无法被正确解析为目标数字类型，会抛出 NumberFormatException，这广义上也算是一种类型转换时因格式不匹配导致的运行时错误。

因此，在进行类型转换，尤其是强制类型转换时，我们必须非常小心，最好能明确源数据的可能范围和目标类型的容量，必要时进行前置的范围检查或者使用 instanceof 操作符来判断对象类型，以避免这些潜在的问题。

为什么用bigDecimal 不用double ？

面试官您好，我们之所以在很多场景下，特别是涉及金额计算、财务报表等对数值精度有严格要求的场景，会选择使用 BigDecimal 而不是 double，最根本的原因就是为了避免 double (以及 float) 可能带来的精度丢失问题。

double 和 float 这两种浮点数类型，它们在计算机内部是基于IEEE 754标准的二进制浮点表示法来存储和运算的。这种表示法的特点是，它能够表示非常大或非常小的数，并且运算速度相对较快。但它的一个固有缺陷就是，对于某些十进制小数，它无法进行完全精确的表示。这有点像我们在十进制中无法精确表示1/3（它会变成0.3333…无限循环）一样，二进制也无法精确地表示某些十进制小数，比如0.1、0.2等。它们在二进制中会变成一个无限循环的数，计算机只能取一个近似值来存储。

• 比如我们用 double 计算 0.05 + 0.01，期望得到的是 0.06，但实际结果可能是 0.060000000000000005。
• 同样，1.0 - 0.42 可能会得到 0.5800000000000001。
• 4.015 * 100 可能会是 401.49999999999994。
• 123.3 / 100 可能会是 1.2329999999999999。

这些微小的差异，在普通科学计算中可能影响不大，但在像商品价格计算、金融交易、会计核算这类场景下，就是完全不可接受的。就像您说的，如果因为这种精度问题导致用户账户的金额计算出错，或者在电商网站上因为总价计算的微小偏差导致无法下单或对账不平，那后果会非常严重。

为了解决这个问题，Java提供了 BigDecimal 类。BigDecimal 内部采用的是一种更接近我们人类直观理解的十进制表示方式来进行存储和运算（或者说它能精确地表示十进制数及其运算）。它提供了 add()、subtract()、multiply()、divide() 等方法来进行精确的算术运算。

使用 BigDecimal 时，有一个非常关键的点需要注意：在创建 BigDecimal 对象时，强烈推荐使用字符串作为构造函数的参数，而不是直接传入 double 类型的值。
例如，应该写 BigDecimal num1 = new BigDecimal(“0.1”); 而不是 BigDecimal num1 = new BigDecimal(0.1);。
原因是，如果使用 new BigDecimal(0.1)，那么传递给构造函数的 0.1 这个 double 值本身可能就已经是一个不精确的近似值了，BigDecimal 只是忠实地把这个不精确的 double 值给表示了出来，并没有解决源头上的精度问题。而使用字符串 “0.1” 作为参数，BigDecimal 就能准确地解析这个十进制表示，从而保证后续计算的精确性。

所以，虽然 BigDecimal 在性能上可能会比 double 稍慢一些，因为它需要处理更复杂的内部表示和运算逻辑，但在那些对计算精度要求极高的场景，使用 BigDecimal 是确保结果正确性的必要选择。

装箱和拆箱是什么？

面试官您好，关于Java中的装箱和拆箱，我的理解是这样的：

装箱（Boxing） 指的是将Java中的基本数据类型（比如 int, double, boolean 等）转换成它们对应的包装类对象（例如 Integer, Double, Boolean）。

拆箱（Unboxing） 则正好相反，它是指将这些包装类对象转换回其对应的基本数据类型。

这个机制的存在，主要是因为Java虽然是一个面向对象的语言，但它为了执行效率等方面的考虑，保留了8种基本数据类型，这些基本类型本身并不是对象。然而，在很多场景下，比如我们使用集合框架（像 ArrayList、HashMap 等，它们在Java 5之前通常只能存储对象类型的数据），或者在泛型中，我们都需要将基本类型当作对象来处理。包装类和装箱/拆箱操作就充当了基本数据类型和对象世界之间的一座桥梁。

在Java 5之前，装箱和拆箱操作都需要我们开发者手动进行。
例如，装箱可能是这样的：

int i = 10;
Integer integerObject = new Integer(i);

拆箱则是：

int j = integerObject.intValue();

从 Java 5开始，引入了自动装箱（Autoboxing）和自动拆箱（Auto-unboxing） 的特性。这意味着编译器可以在许多情况下自动为我们完成基本类型和其包装类之间的转换，这大大简化了代码编写。
现在我们可以这样写：

Integer integerObject = 10;   // 装箱 (编译器会自动执行类似 Integer.valueOf(10) 的操作)
int j = integerObject;   	  // 拆箱 (编译器会自动执行类似 integerObject.intValue() 的操作)

这使得代码看起来更加简洁自然。

不过，在使用自动装箱和拆箱时，也有一些值得注意的地方：

• 性能考虑：虽然自动装箱拆箱很方便，但在一些性能敏感的场景，比如循环中进行大量的这类操作，可能会因为频繁创建和销毁对象而带来额外的性能开销。
• NullPointerException风险：如果一个包装类对象的值为 null，在尝试对其进行自动拆箱时，会调用 null 对象的 xxxValue() 方法，这将导致 NullPointerException。例如：Integer num = null; int i = num; 这行代码在运行时就会抛出空指针异常。
• 对象比较的细微差别：当使用 == 运算符比较两个包装类对象时，如果它们的值在某个缓存范围内（例如 Integer 默认缓存-128到127之间的值），它们可能会指向JVM中预先创建的同一个对象，此时 == 判断为 true。但如果超出这个范围，== 比较的通常是对象的内存地址，即使它们的值相同，结果也可能是 false。因此，对于包装类对象的值是否相等，更推荐使用 equals() 方法进行比较。

总的来说，装箱和拆箱是Java中非常基础且重要的概念，它使得基本数据类型能够更好地融入到面向对象的编程范式中，而自动装箱和拆箱则提升了编码的便捷性。了解其原理和注意事项有助于写出更健壮和高效的代码。

包装类的缓存范围是什么

面试官您好，关于Java包装类的缓存范围，这主要是针对一些常用的基本类型对应的包装类，为了提高性能和节省内存而设计的一种机制。当通过自动装箱或者显式调用 valueOf() 方法创建这些包装类对象时，如果值在特定范围内，就会直接返回缓存中预先创建好的对象，而不是每次都创建一个新的对象。

具体来说，这些包装类和它们的默认缓存范围是：

• Boolean：
  • 缓存了 true 和 false 对应的两个静态常量对象：Boolean.TRUE 和 Boolean.FALSE。所以，任何时候获取 Boolean.valueOf(true) 或 Boolean.valueOf(false) (或者自动装箱 Boolean b = true;)，都会得到这两个固定的对象。
• Byte：
  • 缓存了所有 byte 值，即 -128 到 127 范围内的所有 Byte 对象。因为 byte 类型本身范围就这么大。
• Short：
  • 缓存了 -128 到 127 范围内的 Short 对象。
• Integer：
  • 默认情况下，缓存了 -128 到 127 范围内的 Integer 对象。
  • 值得注意的是，对于 Integer，这个缓存的上界是可以配置的。通过JVM参数 -XX:AutoBoxCacheMax= 可以调整这个上界，但下界 -128 是固定的。如果设置的 小于127，那么至少会缓存到127。
• Long：
  • 默认缓存了 -128 到 127 范围内的 Long 对象。
• Character：
  • 缓存了 0 到 127 (即 \u0000 到 \u007F) 范围内的 Character 对象。这个范围覆盖了常见的ASCII字符。

至于 Float 和 Double 这两种浮点数类型的包装类，它们是没有缓存机制的**。这是因为浮点数的取值范围非常大，且连续性强，缓存特定范围内的值意义不大，也难以实现有效的缓存。

这个缓存机制主要是通过各个包装类内部的静态内部类（比如 Integer 类中的 IntegerCache）来实现的。在类加载时，这些缓存对象就被创建好了。当我们使用 valueOf() 方法（自动装箱通常会调用这个方法）时，它会先检查值是否在缓存范围内，如果在，就直接返回缓存中的对象实例。

因此，当比较这些在缓存范围内的包装类对象时，使用 == 运算符可能会因为它们指向同一个缓存对象而返回 true。但对于超出缓存范围的值，或者对于 Float、Double 对象，== 通常比较的是对象的内存地址，所以即使值相同也可能返回 false。这就是为什么我们总是推荐使用 equals() 方法来比较包装类对象的值是否相等的原因。

Java为什么要有Integer？

面试官您好，Java之所以设计了像 Integer 这样的包装类，主要是为了解决基本数据类型（如 int）在面向对象的编程范式中的一些局限性。我的理解主要有以下几个原因：

• 让基本类型能够参与到对象化的操作中：
  • Java的核心思想是“一切皆对象”，但为了性能和存储效率，它保留了8种基本数据类型（byte, short, int, long, float, double, char, boolean）。这些基本类型不是对象，它们没有方法，也不能被赋值为 null。
  • 在很多场景下，我们需要将这些基本类型当作对象来处理。最典型的就是集合框架（如 ArrayList, HashMap 等）。在Java 5引入泛型之前，集合只能存储 Object 类型的引用。所以，如果你想往一个 ArrayList 中添加一个 int 值，就必须先把它包装成一个 Integer 对象。即使有了泛型（如 ArrayList），泛型类型参数也必须是引用类型，不能是基本类型 int。因此，Integer 使得 int 值能够被存储在这些面向对象的集合中。
• 支持泛型：
  • 正如上面提到的，Java的泛型机制要求类型参数必须是类（引用类型）。你不能写 ArrayList，而必须写 ArrayList。包装类在这里是必不可少的，它们使得基本类型也能够享受到泛型带来的类型安全和代码复用性。
• 提供表示“无值”或“未知”的能力（null）：
  • 基本数据类型 int 总是有值的，它的默认值是 0。但在某些业务场景中，我们需要区分一个数值是 0 还是“未赋值”或“不存在”。例如，数据库中的某个整数字段可能是 NULL。
  • Integer 对象可以被赋值为 null，这正好可以用来表示这种“无值”的状态，从而能更准确地映射现实世界或数据库中的情况。
• 提供相关的实用方法和常量：
  • Integer 类（以及其他包装类）提供了很多有用的静态方法和常量，这些是基本类型 int 自身无法提供的。例如：
    • Integer.parseInt(String s): 将字符串解析成 int。
    • Integer.toString(int i): 将 int 转换成字符串。
    • Integer.valueOf(String s) 或 Integer.valueOf(int i): 创建 Integer 对象（后者会利用缓存）。
    • Integer.MAX_VALUE 和 Integer.MIN_VALUE: 表示 int 类型的最大值和最小值。
    • 还有像比较 (compareTo)、获取哈希码 (hashCode)，以及一些位操作相关的静态方法。
• 用于方法参数和返回值，当需要对象语义时：
  • 在某些API设计中，方法可能期望接收一个对象，或者需要返回一个可以为 null 的数值对象。

当然，为了方便开发者在基本类型和包装类之间转换，Java 5引入了 **自动装箱（Autoboxing）和自动拆箱（Auto-unboxing）**机制。这使得我们可以像下面这样写代码，编译器会自动进行转换：

Integer i = 100; // 自动装箱，等价于 Integer i = Integer.valueOf(100);
int j = i; // 自动拆箱，等价于 int j = i.intValue();

尽管有了自动装箱/拆箱，Integer 存在的根本原因还是上述那些。

总而言之，Integer 的存在是为了弥补基本数据类型 int 在面向对象编程中的不足，使其能够更好地融入到Java的对象体系中，并提供额外的功能和灵活性。

Integer相比int有什么优点？

面试官您好，Integer 相比于 int，其优点主要体现在它作为 int** 的包装类，赋予了 int 值对象的能力**，从而带来了更多的灵活性和功能。

具体来说，Integer 的主要优势和与 int 的区别体现在以下几个方面：

• 对象特性带来的扩展性：
  • 参与面向对象的编程：最重要的一点是，Integer 是一个对象（引用类型），而 int 是一个基本数据类型。这意味着 Integer 可以用在所有需要对象的地方。例如，Java的集合框架（如 ArrayList, HashMap<String, Integer>）和泛型机制都要求使用对象类型，所以我们不能直接将 int 作为泛型参数或存入这类集合，必须使用 Integer。
  • 可以为 null：Integer 对象可以被赋值为 null，这在很多业务场景中非常有用。比如，当我们需要表示一个数值“不存在”、“未设置”或“未知”时，null 就能清晰地表达这个语义。而基本类型 int 的默认值是 0，它无法区分一个有效的 0 值和一个“未设置”的状态。
  • 提供丰富的方法：Integer 类提供了很多实用的静态方法和实例方法，比如将字符串转换为 int 的 Integer.parseInt()，将 int 转换为字符串的 Integer.toString()，比较两个 Integer 对象的 compareTo() 方法，以及像 Integer.MAX_VALUE、Integer.MIN_VALUE 这样的常量等。这些都是基本类型 int 自身不具备的。
• 自动装箱与自动拆箱的便利性：
  • 从Java 5开始，Java引入了自动装箱和自动拆箱机制。这意味着我们可以很方便地在 int 和 Integer 之间进行转换，编译器会自动帮我们处理。例如，我们可以写 Integer numObject = 100; (自动装箱) 和 int numPrimitive = numObject; (自动拆箱)。这使得代码编写起来更加简洁自然。

不过，也需要注意 Integer 和 int 的一些差异带来的影响：

• 内存和性能：int 作为基本类型，其值直接存储在栈或者对象内部，不涉及额外的对象头开销，运算效率通常也更高。而 Integer 是一个对象，需要在堆上分配内存，有对象本身的开销（如对象头），并且访问它通常涉及到引用的解引用，所以在纯数值计算且对性能要求极高的场景下，直接使用 int 可能更优。
• NullPointerException 风险：由于 Integer 对象可以为 null，如果在未检查其是否为 null 的情况下对其进行自动拆箱操作（比如直接赋给一个 int 变量，或者在算术表达式中使用），就会抛出 NullPointerException。这是使用 Integer 时需要特别注意的一个地方。

总结来说，Integer 的主要优点在于它允许我们将整数值作为对象来操作，从而能够利用对象的特性（如 null 值、方法、参与泛型和集合等），这在很多复杂的业务逻辑和API设计中是非常必要的。而 int 则更侧重于原始的、高效的数值存储和计算。选择使用哪一个，主要取决于具体的应用场景和需求。

那为什么还要保留int类型？

面试官您好，您这个问题非常好。确实，既然 Integer 提供了这么多面向对象的优点，为什么Java还要保留 int 这样的基本数据类型呢？这主要是出于对性能和内存效率的考量。

就像您提到的：

• 内存占用效率：
  • int 是基本数据类型，它的值是直接存储的。一个 int 变量在内存中固定占用4个字节。
  • 而 Integer 是一个对象，它是一个引用类型。这意味着对象的引用和对象本身是分开存储的（引用通常在栈或对象内部，对象实例在堆中）。除了实际存储的那个 int 值之外，Integer 对象本身还需要额外的内存空间来存储对象头信息（比如对象的哈希码、锁状态、GC标记、类型指针等）。正如您所指出的，在开启了指针压缩的64位JVM上，一个 Integer 对象通常至少会占用16个字节（对象头大约12字节 + 实际的 int 值4字节）。所以，如果大量使用 Integer 代替 int，特别是在数组或集合中，内存消耗会显著增加，这不仅浪费内存，也会加重垃圾回收的压力。
• 读写效率（执行效率）：
  • 对 int 进行操作，比如算术运算，CPU可以直接访问和处理存储在栈（对于局部变量）或对象内部（对于成员变量）的原始二进制数据，这个过程非常直接和高效。
  • 操作 Integer 对象时，首先需要通过引用访问堆内存中的对象，如果涉及到数值运算，还需要进行拆箱操作（即使是自动拆箱，底层也是方法调用）。这些额外的步骤，比如指针解引用、方法调用开销等，都会使得 Integer 的操作在速度上通常慢于直接操作 int。
• Java设计哲学与历史背景：
  • Java在设计之初就力求在“纯粹的面向对象”和“执行效率”之间找到一个平衡点。保留基本数据类型，就是为了在处理对性能和内存敏感的场景（如大量数值计算、底层数据结构实现等）时，为开发者提供一个更高效、更底层的选择。
• 避免不必要的对象创建和GC开销：
  • 如果Java中所有的数字都必须是对象，那么即使是简单的循环计数器或者临时变量，也都会涉及到对象的创建和后续的垃圾回收。这在很多情况下会带来不必要的性能开销，尽管有JIT编译器的优化和包装类的缓存机制（比如Integer缓存-128到127的值），但在很多情况下，基本类型的直接使用仍然是最高效的。

因此，Java通过保留 int 这样的基本类型，为开发者提供了在追求极致性能和低内存消耗时的选择。而 Integer 这样的包装类，则弥补了基本类型在面向对象特性上的不足，比如允许为 null、参与泛型、拥有方法等。两者是互补的关系，共同服务于Java开发者在不同场景下的需求。

说一下 integer的缓存

面试官您好。Java中的Integer类确实有一个内部的静态缓存池，这个机制主要是为了优化性能和节省内存。

具体来说：

• 缓存范围：
  • 默认情况下，这个缓存池预先创建并存储了从 -128 到 127（包含边界值）这个范围内的所有整数对应的Integer对象。
• 触发机制：
  • 当我们使用 Integer.valueOf(int i) 这个静态工厂方法来获取一个Integer对象时，如果传入的 int 值在这个-128到127的缓存范围内，valueOf()方法就会直接返回缓存池中预先创建好的那个Integer对象的引用。
  • 同样，Java 5引入的自动装箱特性，比如我们写 Integer num = 100;，编译器在底层实际上会将其转换为 Integer num = Integer.valueOf(100);，所以自动装箱也会利用到这个缓存机制。
• 目的和优势：
  • 性能提升：对于这个常用范围内的小整数，避免了频繁地创建新的Integer对象，减少了对象创建和垃圾回收的开销。
  • 内存节省：多个地方引用这些范围内的同一个整数值时，它们实际上会指向缓存池中的同一个对象实例，从而节省了内存空间。
• 重要注意事项：
  • new Integer(int i) vs Integer.valueOf(int i)：需要强调的是，如果使用 new Integer(int i) 构造器来创建Integer对象，那么无论传入的 int 值是否在缓存范围内，它总是会创建一个全新的Integer对象，不会使用缓存。所以，推荐使用 Integer.valueOf() 或者依赖自动装箱来获取Integer对象，以便利用缓存。
  • 对象比较：这个缓存机制也解释了为什么有时候用 == 比较两个Integer对象会出现一些“意外”情况。
    • 如果两个Integer变量都是通过自动装箱或valueOf()获取，并且它们的值都在-128到127之间，那么它们用 == 比较会是 true，因为它们指向的是缓存中的同一个对象。

Integer a = 100;
Integer b = 100;
System.out.println(a == b); // true

如果值超出了这个缓存范围，或者至少有一个是通过 new Integer() 创建的，那么即使它们的值相同，用 == 比较通常会是 false（因为==比较的是对象的内存地址）。

Integer c = 200;
Integer d = 200;
System.out.println(c == d); // false (通常情况下，除非JVM有更激进的优化或特定实现)Integer e = new Integer(100);
Integer f = 100;
System.out.println(e == f); // false

因此，对于Integer（以及其他包装类）对象的值是否相等，始终推荐使用 .equals() 方法进行比较，而不是 ==。

• 缓存上界的可配置性：
  • 值得一提的是，虽然下界-128是固定的，但Integer缓存池的上界127在某些JDK版本中是可以通过JVM参数 -XX:AutoBoxCacheMax= 来调整的，但这通常不建议随意修改，除非有非常明确的性能分析依据。

除了Integer，Byte, Short, Long, Character 和 Boolean 这些包装类也有类似的缓存机制（比如Boolean缓存TRUE和FALSE，Byte缓存所有值，Character缓存0-127等）。而Float和Double则没有这种缓存机制。

总而言之，Integer的缓存是一个重要的优化手段，理解它有助于我们更好地使用包装类，并避免在对象比较时产生困惑。