Question

Java 中的几种基本数据类型了解么？

Java 中有 8 种基本数据类型，分别为：

• 6 种数字类型：
  • 4 种整数型： byte 、 short 、 int 、 long
  • 2 种浮点型： float 、 double
• 1 种字符类型： char
• 1 种布尔型： boolean 。

这 8 种基本数据类型的默认值以及所占空间的大小如下：

基本类型	位数	字节	默认值	取值范围
byte	8	1	0	-128 ~ 127
short	16	2	0	-32768（-2^15） ~ 32767（2^15 - 1）
int	32	4	0	-2147483648 ~ 2147483647
long	64	8	0L	-9223372036854775808（-2^63） ~ 9223372036854775807（2^63 -1）
char	16	2	'u0000'	0 ~ 65535（2^16 - 1）
float	32	4	0f	1.4E-45 ~ 3.4028235E38
double	64	8	0d	4.9E-324 ~ 1.7976931348623157E308
boolean	1		false	true、false

可以看到，像 byte 、 short 、 int 、 long 能表示的最大正数都减 1 了。这是为什么呢？这是因为在二进制补码表示法中，最高位是用来表示符号的（0 表示正数，1 表示负数），其余位表示数值部分。所以，如果我们要表示最大的正数，我们需要把除了最高位之外的所有位都设为 1。如果我们再加 1，就会导致溢出，变成一个负数。

对于 boolean ，官方文档未明确定义，它依赖于 JVM 厂商的具体实现。逻辑上理解是占用 1 位，但是实际中会考虑计算机高效存储因素。

另外，Java 的每种基本类型所占存储空间的大小不会像其他大多数语言那样随机器硬件架构的变化而变化。这种所占存储空间大小的不变性是 Java 程序比用其他大多数语言编写的程序更具可移植性的原因之一（《Java 编程思想》2.2 节有提到）。

注意：

1. Java 里使用 long 类型的数据一定要在数值后面加上 L ，否则将作为整型解析。
2. char a = 'h' char :单引号， String a = "hello" :双引号。

这八种基本类型都有对应的包装类分别为： Byte 、 Short 、 Integer 、 Long 、 Float 、 Double 、 Character 、 Boolean 。

基本类型和包装类型的区别？

• 用途 ：除了定义一些常量和局部变量之外，我们在其他地方比如方法参数、对象属性中很少会使用基本类型来定义变量。并且，包装类型可用于泛型，而基本类型不可以。
• 存储方式 ：基本数据类型的局部变量存放在 Java 虚拟机栈中的局部变量表中，基本数据类型的成员变量（未被 static 修饰 ）存放在 Java 虚拟机的堆中。包装类型属于对象类型，我们知道几乎所有对象实例都存在于堆中。
• 占用空间 ：相比于包装类型（对象类型）， 基本数据类型占用的空间往往非常小。
• 默认值 ：成员变量包装类型不赋值就是 null ，而基本类型有默认值且不是 null 。
• 比较方式 ：对于基本数据类型来说， == 比较的是值。对于包装数据类型来说， == 比较的是对象的内存地址。所有整型包装类对象之间值的比较，全部使用 equals() 方法。

为什么说是几乎所有对象实例都存在于堆中呢？ 这是因为 HotSpot 虚拟机引入了 JIT 优化之后，会对对象进行逃逸分析，如果发现某一个对象并没有逃逸到方法外部，那么就可能通过标量替换来实现栈上分配，而避免堆上分配内存

注意： 基本数据类型存放在栈中是一个常见的误区！ 基本数据类型的成员变量如果没有被 static 修饰的话（不建议这么使用，应该要使用基本数据类型对应的包装类型），就存放在堆中。

class BasicTypeVar{
  private int x;
}

包装类型的缓存机制了解么？

Java 基本数据类型的包装类型的大部分都用到了缓存机制来提升性能。

Byte , Short , Integer , Long 这 4 种包装类默认创建了数值 [-128，127] 的相应类型的缓存数据， Character 创建了数值在 [0,127] 范围的缓存数据， Boolean 直接返回 True or False 。

Integer 缓存源码：

public static Integer valueOf(int i) {
  if (i >= IntegerCache.low && i <= IntegerCache.high)
    return IntegerCache.cache[i + (-IntegerCache.low)];
  return new Integer(i);
}
private static class IntegerCache {
  static final int low = -128;
  static final int high;
  static {
    // high value may be configured by property
    int h = 127;
  }
}

Character 缓存源码:

public static Character valueOf(char c) {
  if (c <= 127) { // must cache
    return CharacterCache.cache[(int)c];
  }
  return new Character(c);
}

private static class CharacterCache {
  private CharacterCache(){}
  static final Character cache[] = new Character[127 + 1];
  static {
    for (int i = 0; i < cache.length; i++)
      cache[i] = new Character((char)i);
  }

}

Boolean 缓存源码：

public static Boolean valueOf(boolean b) {
  return (b ? TRUE : FALSE);
}

如果超出对应范围仍然会去创建新的对象，缓存的范围区间的大小只是在性能和资源之间的权衡。

两种浮点数类型的包装类 Float , Double 并没有实现缓存机制。

Integer i1 = 33;
Integer i2 = 33;
System.out.println(i1 == i2);// 输出 true

Float i11 = 333f;
Float i22 = 333f;
System.out.println(i11 == i22);// 输出 false

Double i3 = 1.2;
Double i4 = 1.2;
System.out.println(i3 == i4);// 输出 false

下面我们来看一个问题：下面的代码的输出结果是 true 还是 false 呢？

Integer i1 = 40;
Integer i2 = new Integer(40);
System.out.println(i1==i2);

Integer i1=40 这一行代码会发生装箱，也就是说这行代码等价于 Integer i1=Integer.valueOf(40) 。因此， i1 直接使用的是缓存中的对象。而 Integer i2 = new Integer(40) 会直接创建新的对象。

因此，答案是 false 。你答对了吗？

记住： 所有整型包装类对象之间值的比较，全部使用 equals 方法比较 。

自动装箱与拆箱了解吗？原理是什么？

什么是自动拆装箱？

• 装箱 ：将基本类型用它们对应的引用类型包装起来；
• 拆箱 ：将包装类型转换为基本数据类型；

举例：

Integer i = 10;  //装箱
int n = i;   //拆箱

上面这两行代码对应的字节码为：

L1
  LINENUMBER 8 L1
  ALOAD 0
  BIPUSH 10
  INVOKESTATIC java/lang/Integer.valueOf (I)Ljava/lang/Integer;
  PUTFIELD AutoBoxTest.i : Ljava/lang/Integer;
L2
  LINENUMBER 9 L2
  ALOAD 0
  ALOAD 0
  GETFIELD AutoBoxTest.i : Ljava/lang/Integer;
  INVOKEVIRTUAL java/lang/Integer.intValue ()I
  PUTFIELD AutoBoxTest.n : I
  RETURN

从字节码中，我们发现装箱其实就是调用了 包装类的 valueOf() 方法，拆箱其实就是调用了 xxxValue() 方法。

因此，

• Integer i = 10 等价于 Integer i = Integer.valueOf(10)
• int n = i 等价于 int n = i.intValue() ;

注意： 如果频繁拆装箱的话，也会严重影响系统的性能。我们应该尽量避免不必要的拆装箱操作。

private static long sum() {
  // 应该使用 long 而不是 Long
  Long sum = 0L;
  for (long i = 0; i <= Integer.MAX_VALUE; i++)
    sum += i;
  return sum;
}

为什么浮点数运算的时候会有精度丢失的风险？

浮点数运算精度丢失代码演示：

float a = 2.0f - 1.9f;
float b = 1.8f - 1.7f;
System.out.println(a);// 0.100000024
System.out.println(b);// 0.099999905
System.out.println(a == b);// false

为什么会出现这个问题呢？

这个和计算机保存浮点数的机制有很大关系。我们知道计算机是二进制的，而且计算机在表示一个数字时，宽度是有限的，无限循环的小数存储在计算机时，只能被截断，所以就会导致小数精度发生损失的情况。这也就是解释了为什么浮点数没有办法用二进制精确表示。

就比如说十进制下的 0.2 就没办法精确转换成二进制小数：

// 0.2 转换为二进制数的过程为，不断乘以 2，直到不存在小数为止，
// 在这个计算过程中，得到的整数部分从上到下排列就是二进制的结果。
0.2 * 2 = 0.4 -> 0
0.4 * 2 = 0.8 -> 0
0.8 * 2 = 1.6 -> 1
0.6 * 2 = 1.2 -> 1
0.2 * 2 = 0.4 -> 0（发生循环）
...

关于浮点数的更多内容，建议看一下 计算机系统基础（四）浮点数 这篇文章。

如何解决浮点数运算的精度丢失问题？

BigDecimal 可以实现对浮点数的运算，不会造成精度丢失。通常情况下，大部分需要浮点数精确运算结果的业务场景（比如涉及到钱的场景）都是通过 BigDecimal 来做的。

BigDecimal a = new BigDecimal("1.0");
BigDecimal b = new BigDecimal("0.9");
BigDecimal c = new BigDecimal("0.8");

BigDecimal x = a.subtract(b);
BigDecimal y = b.subtract(c);

System.out.println(x); /* 0.1 */
System.out.println(y); /* 0.1 */
System.out.println(Objects.equals(x, y)); /* true */

关于 BigDecimal 的详细介绍，可以看看我写的这篇文章： BigDecimal 详解 。

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

基本数值类型都有一个表达范围，如果超过这个范围就会有数值溢出的风险。

在 Java 中，64 位 long 整型是最大的整数类型。

long l = Long.MAX_VALUE;
System.out.println(l + 1); // -9223372036854775808
System.out.println(l + 1 == Long.MIN_VALUE); // true

BigInteger 内部使用 int[] 数组来存储任意大小的整形数据。

相对于常规整数类型的运算来说， BigInteger 运算的效率会相对较低。

Java 是一门面向对象的编程语言，不仅吸收了 C++语言的各种优点，还摒弃了 C++里难以理解的多继承、指针等概念，因此 Java 语言具有功能强大和简单易用两个特征。