Java基础——基本数据类型及包装类

1 基本数据类型

Java中有8中基本数据类型

其中整数类型4种，分别为byte、short、int、long，浮点型两种，分别为float和double，字符型一种char，布尔型一种boolean。

2 计算机中数据的存储

计算机中数据都是以二进制存储的，存储的是数据的补码。计算机中数据的存储涉及到原码、反码和补码三个概念。

• 原码：第一位都是符号位，正数的符号位为0，负数的符号位为1，后面的就是根据2进制规则的转化
• 反码：正数的反码等于其原码，负数的补码在原码的基础上符号位不变，其他位取反
• 补码：正数的补码等于其原码，负数的补码在原码的基础上加1
  反码和补码的意义就是将计算机内部的减法运算转换成加法运算，由于计算中只有加法器，没有减法器，只能做加法运算，将正数和负数通过补码存储后可以直接相加得到最终数值的补码，比如：

-124 + 123 = -1
-124
原码：1111 1100
反码：1000 0011
补码：1000 0100
123
补码：0111 1011

相加后补码：1111 1111
相加后反码：1111 1110
相加后原码：1000 0001
相加后表示数值：-1

这样计算机底层直接使用补码相加，就可以表示10进制数的补码了。

上面说byte数的范围是-128到127，那么-128怎么表示原码、反码和补码呢。-128是一个比较特殊的数值，它只有补码：1000 0000，没有反码和原码。这个补码的正确性可以通过加一个数进行验证：

-128 + 127 = -1
-128
补码：1000 0000
127
补码：0111 1111

相加后补码：1111 1111
相加后反码：1111 1110
相加后原码：1000 0001
相加后表示数值：-1

3 类型转换

当两个不同类型的数据进行运算的时候会存在自动类型提升，提升的规则是从占用字节数小的到大的进行转换。
byte->short->int->long->float->double
如果想要逆向转换需要进行强制类型转换，注意强制类型转换可能会损失精度。

int i = 234;
byte b = (byte) i;
System.out.println(b);
System.out.println(Integer.toBinaryString(b));

输出
-22
11111111111111111111111111101010

这里面能看到两个问题，第一个问题是从int类型转换成byte类型可能会损失精度，这里的int数是234，已经超过了byte能够存储的范围，所以强制转成byte类型后会造成截断误差，如下所示：

234
补码：00000000 00000000 00000000 11101010
由于byte只占一个字节，所以截断最后的8位，int类型，第32位是符号位，0表示正数，截断后，byte类型的第8位是符号位，1表示负数，所以截断后int类型的正数变成了byte类型负数。
b
补码：1110 1010
反码：1110 1001
原码：1001 0110
表示数值：-22

这就是截断误差的原理，截断了补码的部分位，所以最后的结果不正确，所以强转需要注意。
第二个问题就是自动类型提升了

byte类型：11101010
转换后int类型数据：11111111111111111111111111101010

可以看到，负数在自动类型提升的时候，会补齐32位，且前面补的是符号位相同的数值，正数也是一样，这样int存储的值就和byte存储的值一样了。

源码：11111111 11111111 11111111 11101010
反码：11111111 11111111 11111111 11101001
补码：10000000 00000000 00000000 00010110
表示数值：-22

常见操作b&0xff
在进行数据处理的时候，常见的转换操作是与上0xff，这样做的意义是什么呢？
由于负数的byte类型转换成int类型的时候高位会补1操作，导致补码改变，所以与上0xff就是高位全部置为0，最后一个字节跟byte类型的补码一致，这样做就保证了补码一致性。

4 包装类

4.1 包装类概述

Java是一种面向对象的语言，有时候需要对象操作才比较方便，所有的基本数据类型都有其对应的包装类。

基本数据类型和其包装类之间可以直接赋值，会自动装箱和拆箱。

Integer i1 = 20;
int i2 = i1;

查看运行的汇编指令，发现自动装箱其实调用的是Integer类中的valueOf方法，自动拆箱调用的是Integer类中的intValue方法。所以我们也可以调用包装类中的类似这两个方法来转换基本数类型和包装类型。

4.2 包装类面试题

比较常考的一个面试题就是Integer的对象相等问题

Integer i1 = 123;
Integer i2 = 123;
Integer i3 = 129;
Integer i4 = 129;
System.out.println(i1 == i2);
System.out.println(i3 == i4);
输出结果
true
false

为什么会有不一样的结果呢，看一下Integer中的源码

public static Integer valueOf(int i) {
        return i >= -128 && i <= Integer.IntegerCache.high ? Integer.IntegerCache.cache[i + 128] : new Integer(i);
    }

这里的high是Integer.IngerCache这个内部类中的静态初始化块中定义的，值为127。所以如果传入的值为-128到127之间，返回的是Integer.IntegerCache.cache[i + 128]这个数组值。如果超过这个值就重新创建一个Integer对象并返回。

high = h;
VM.initializeFromArchive(Integer.IntegerCache.class);
size = high - -128 + 1;
if (archivedCache == null || size > archivedCache.length) {
    Integer[] c = new Integer[size];
    int j = -128;

    for(int k = 0; k < c.length; ++k) {
        c[k] = new Integer(j++);
    }

    archivedCache = c;
}

cache = archivedCache;

cache这个数组的初始化也在该类的静态初始化块中，可以看到初始化的时候会创建一个Integer数组，大小是128*2=256，里面存储的数值是-128到127。由于是从数组索引0开始，所以0位置是-128，这就是上面要加128的原因。可以看到这相当于是一个缓存数组，在这个范围内的数都是直接返回的，不会去创建一个新的Integer对象。
使用new关键字创建的Integer对象永远不是同一个对象。