java中的自动拆装箱详解

2019-08-16 11:57:50来源:博客园 阅读 ()

新老客户大回馈,云服务器低至5折

java中的自动拆装箱详解

本文首先介绍java中的基本数据类型,后面详细介绍了自动拆装箱原理,如有问题,欢迎探讨交流。

数据类型

分类

基本数据类型分为三类:

  1. 数值型:数值型又分为整数型和浮点型;
  2. 字符型(char)
  3. 布尔型(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比较的时候,由于直接赋值的时候会进行自动装箱。那么这里就需要注意两个问题

  1. -128<= x<=127的整数,将会直接缓存在IntegerCache中,那么当赋值在这个区间的时候,不会创建新的Integer对象,而是从缓存中获取已经创建好的Integer对象。
  2. 大于这个范围的时候,直接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

https://blog.csdn.net/wangyang1354/article/details/52623703

https://www.cnblogs.com/wang-yaz/p/8516151.html


原文链接:https://www.cnblogs.com/benjieqiang/p/11305777.html
如有疑问请与原作者联系

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:Spring再次学习(3)

下一篇:死磕Synchronized底层实现,面试你还怕什么?