Java中自动拆装箱问题详解

为什么会有基本数据类型？

因为，在java中new一个对象是存储在堆里的，对于 我们经常操作的数据类型，每次创建对象这样太消耗资源，因此java提供了8个基本数据类型，存储在栈里。用起来更方便。
自动类型转换
转换前的数据类型的位数低于转换后的数据类型。
例如: short数据类型的位数为16位，就可以自动转换位数为32的int类型，同样float数据类型的位数为32，可以自动转换为64位的double类型。

               自动类型转换
低  ------------------------------------>  高byte,short,char—> int —> long—> float —> double 
数据类型转换必须满足如下规则：
不能对boolean类型进行类型转换。
不能把对象类型转换成不相关类的对象。
由大到小会丢失精度：在把容量大的类型转换为容量小的类      型时必须使用强制类型转换。

强制类型转换

条件:

    转换的数据类型必须是兼容的。

存在问题:

    转换过程中可能导致溢出或损失精度，例如：

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 In因为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())这类的方法将对象转换成原始类型值。

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
}


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.
}
}