本文首先介绍java中的基本数据类型，后面详细介绍了自动拆装箱原理，如有问题，欢迎探讨交流。
数据类型
分类
基本数据类型分为三类：
- 数值型：数值型又分为整数型和浮点型；
- 字符型（char)
- 布尔型（boolean)
为什么会有基本数据类型？
因为，在java中new一个对象是存储在堆里的，对于我们经常操作的数据类型，每次创建对象这样太消耗资源，因此java提供了8个基本数据类型，存储在栈里。用起来更方便。
8种基本数据类型
为了先理解它们的表数范围，我们先来介绍一下一些基本知识。
计算机中都是使用二进制的补码进行运算的，首先，我们知道1字节=8bit，那么8bit可以表示的数字范围是[-128,127]。注意首位的1表示负数，0表示正数。
1000 0000：-128或-2^7-1
0111 1111:127或2^7-1
| 类型 | 占用存储空间 | 表数范围 | 默认值 |
|---|---|---|---|
| byte | 1字节 | -128 ~ 127 | 0 |
| short | 2字节 | -2^15 ~ 2^15 -1 | 0 |
| int | 4字节 | -2^31 ~ 2^31 -1 | 0 |
| long | 8字节 | -2^63 ~ 2^63 -1 | 0，或者0L或者0l |
| float | 4字节 | -3.403E38 ~ 3.403E38 | 0.0F或0.0f |
| double | 8字节 | -1.798E308 ~ 1.798E308 | 0.0D或0.0d |
| char | 2字节 | 0~2^16 -1 | 'u0000' |
| boolean | 1字节 | true/false | false |
自动类型转换
转换前的数据类型的位数低于转换后的数据类型。
例如: short数据类型的位数为16位，就可以自动转换位数为32的int类型，同样float数据类型的位数为32，可以自动转换为64位的double类型。
低 ------------------------------------> 高
byte,short,char—> int —> long—> float —> double
数据类型转换必须满足如下规则：
-
不能对boolean类型进行类型转换。
-
不能把对象类型转换成不相关类的对象。
-
由大到小会丢失精度：在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
强制类型转换
- 条件是转换的数据类型必须是兼容的。
- 格式：(type)value type是要强制类型转换后的数据类型
-
转换过程中可能导致溢出或损失精度，例如：
int i =128; byte b = (byte)i;//-128因为 byte 类型是 8 位，最大值为127，所以当 int 强制转换为 byte 类型时，值 128 时候就会导致溢出。
-
浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入，例如：
(int)23.7 == 23; (int)-45.89f == -45
包装类
出现原因
简单来说，就是让基本数据类型的变量具有类中对象的特征。
基本数据类型，使用起来非常方便，但是没有对应的方法来操作这些基本类型的数据，可以使用一个类，把基本数据类型的数据装起来，这个类叫做包装类（wrapper）。这样我们可以调用类中的方法。
开发中，用的最多的是字符串变为基本数据类型。
8种基本数据类型对应包装类：可以看到除了int和char类型，其它都是首字母大写。
| 基本数据类型 | 包装类 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Character |
| boolean | Boolean |
装箱
即对基本类型进行包装，基本类型->包装类
-
通过包装类的构造器实现（jdk1.5之前）
Integer t = new Integer(10); -
通过字符串参数构造包装类对象
Float f = new Float("4.56"); Long l = new Long("wer");//NumberFormatException -
自动装箱（jdk1.5之后）
Integer i = 100;替代了Integer i = new Integer(100);，因为Java帮我们提供了自动装箱的功能，不需要开发者手动去new一个Integer对象。Integer i = 100;//自动装箱 //相当于编译器自动作以下的语法编译：Integer i = Integer.valueOf(100);
拆箱
包装类->基本类型
-
调用包装类中的.xxxValue()方法
Integer t = 128; // 此时t就是一个包装类 System.out.println(t.intValue());//128 -
自动拆箱
Integer i = 10; //自动装箱 int t = i; //自动拆箱，实际上执行了 int t = i.intValue();
自动装箱和自动拆箱的实现原理
Integer integer = 1;
//自动装箱，相当于Integer integer = Integer.valueOf(1);
int i = integer;
//自动拆箱,相当于int i = integer.intValue();
对于上面的代码，Java是怎么做的呢？
自动装箱：调用valueOf（）方法将原始类型值转换成对象
自动拆箱：调用intValue()方法，其他的（xxxValue())这类的方法将对象转换成原始类型值。
类型间转换
基本数据类型->String类
- String类的valueOf()方法：
String fs = String.valueOf(2.34f); - 更直接的方式
5+""
String类->基本数据类型
- 通过包装类的构造器实现：
int i = new Integer("12") - 通过调用包装类的parseXxx(字符串)该静态方法：
Float f = Float.parseFloat("12.1");
包装类->String类
-
包装类对象的toString()方法
Integer t = new Integer(100); String s = t.toString();// s = "100"; //将数字转换为字符串 -
调用包装类的toString(形参)方法
String s1 = Integer.toString(314); // s1= "314" 将数字转换成字符串。
String类->包装类
-
通过字符串参数
Float f = new Float("3.14f");
自动拆装箱与缓存
总结
- int 是基本数据类型
- Integer是包装类，
Integer i = num，自动装箱而num值的范围如果取(-128<=num<=127)，那么就在IntegerCache中直接取已经创建好的对象，不会创建新的Integer对象 new Integer()在堆中创建新的Integer对象- 无论是
Integer i1 = num还是Integer i2 = new Integer(num);，i1与i2之间的比较==牵扯到对象的比较，对于对象比较,==比较的是地址。
具体请看下面的例子：
Integer和int比较
int 和 Integer在进行比较的时候，Integer会进行拆箱，转为int值与int进行比较
@Test
public void testInteger(){
Integer i = 10;
int i1 = 10;
System.out.println(i == i1); //true
Integer i2 = 300;
int i3 = 300;
System.out.println(i2 == i3); //true
}
Integer与Integer比较
Integer与Integer比较的时候，由于直接赋值的时候会进行自动装箱。那么这里就需要注意两个问题
- -128<= x<=127的整数，将会直接缓存在IntegerCache中，那么当赋值在这个区间的时候，不会创建新的Integer对象，而是从缓存中获取已经创建好的Integer对象。
- 大于这个范围的时候，直接new Integer来创建Integer对象。
@Test
public void testInteger2(){
System.out.println("Integer与Integer比较");
Integer i6 = 128;
Integer i7 = 128;
System.out.println(i6 == i7);//false
// i6自动装箱产生的Integer对象，大小超过了-128——127的范围，这里会直接创建该对象：new Integer(128)
// i7同理。它们在堆中的地址是不同的，因此false.
Integer i4 = 1;
Integer i5 = 1;
System.out.println(i4 == i5); //true
// i4、i5都是从IntegerCache中取出来的对象，故true;
Integer i8 = 127;
Integer i9 = 127;
System.out.println(i8 == i9);//true
// i8、i9都是从IntegerCache中取出来的对象，故true;
Integer i10 = new Integer(127);
Integer i11 = 127;
System.out.println(i10 == i11); //false
// i10是创建的一个Integer的对象，取值是127
// i11是进行自动装箱后生成的Integer对象，在-128——127之间，是直接从缓存IntegerCache中取出来的对象
// i10是自己new出来的对象，i11是从IntegerCache中取的对象，地址不同，故false.
Integer i12 = new Integer(128);
Integer i13 = 128;
System.out.println(i12 == i13);//false
// 说明：i12是创建的一个Integer的对象，取值是128
// i13 是进行自动装箱的实例，这里超出了-128——127的范围，创建了新的Integer对象。
// 二者存储在堆中，分配的地址不同，因此用==判断时，由于对象的地址不同，所以false.
}
}
参考链接
https://blog.csdn.net/wufaliang003/article/details/82347077#comments