java 自动装拆箱

title: “java 自动装拆箱”
tags:

Java

将基本数据类型封装成对象的过程叫做装箱（boxing），反之基本数据类型对应的包装类转换为基本数据类型的过程叫做拆箱（unboxing）;

基本数据类型与其他对象的区别

基本数据类型

Java是一门面向对象的强类型语言，但它又不像python那样一切皆对象，Java中有一部分使用最频繁的数据结构并不是面向对象的，他们就是基本数据类型，也叫内置类型，他们在栈中储存，比起其他用new创建的对象，更加高效，Java有9中基本数据类型，分为五类

类型	标识符	备注
整型	byte, short, int, long
浮点	float, dauble
字符	char
布尔	boolean
空	void	不能操作

基本数据类型的范围

整型的范围

byte：占一个字节，也就是8位，最高一位作为符号位，有效位只有7位（采用补码存储）。

最大值：0，111 1111（127）
最小值：1，000 0000（-128）

怎么算的？
最高一位是符号位，这是固定的，正数用0表示，负数用1表示，然后后面的七位最大是7个1，最小是7个0，这就是用补码表示的byte能表示的最大最小数，把补码转换为原码（正数的补码就是源码，负数的补码变源码取反加一）然后转换为10进制。

short：占两个字节，16位，有效15位

最大值：2^15 -1: 32,767
最小值：-(2^15): -32,768

int: 占4个字节，最大值【2^31 - 1】(2,147,483,647), 最小值【-2^31】(-2,147,483,648)
long: 占8字节，最大值【2^63 - 1】(9,223,372,036,854,775,807)，最小值【-2^63】(-9,223,372,036,854,775,808)

包装类型

Java中其他的对象都是继承自object的，有自己的属性和方法，为了方便基本基本数据类型和其他对象的的操作，Java为每个基本数据类型提供了对应的包装类型，

基本数据类型	包装类
byte	Byte
boolean	Boolean
short	Short
char	Character
int	Integer
long	Long
float	Float
double	Double

为什么要使用包装类型

Java是一门面向对象的语言，大部分操作都是针对对象的，比如容器，容器中能存入的最大的范围就是object，而基本数据类型不属于对象，那他就无法存入容器，为了解决这个问题，必须把基本数据类型“包装”起来，让他作为一个对象参与到编程中。

装箱和拆箱

把基本数据类型包装成对象的过程叫做装箱，反之把对象转换为基本数据类型的过程叫做拆箱。
Java SE5 后，为了简化开发，提供了自动装拆箱机制，Java会在适当时刻自动转换基本数据类型和包装类型，如：

public class Demo1 {public static void main(String[] args) {Integer integer = 3; // 自动装箱int i = integer;  // 自动拆箱}
}

通过Javap反编译得到

  public static void main(java.lang.String[]);Code:0: iconst_31: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;4: astore_15: aload_16: invokevirtual #3                  // Method java/lang/Integer.intValue:()I9: istore_210: return

在自动装箱时，其实是调用了包装类的valueOf()方法，而在自动拆箱时则调用了包装类的intValue()方法，所以如果在JavaSE5之前，没有自动装拆箱机制，上面的代码我们需要这样写

public class Demo1 {public static void main(String[] args) {Integer integer = Integer.valueOf(3); // 装箱int i = Integer.intValue(integer);  // 拆箱}
}

除int和Integer之外,其他基本类型和包装类的自动转换也一样，装箱时调用valueOf()方法，拆箱时调用xxxValue()方法。

什么时候自动装箱

1. 初始化，赋值，函数返回时

当把基本数据类型赋值给包装类时或者基本数据类型作为函数返回值但函数声明要求返回包装类型时，会自动装箱，如上面的例子

2. 将基本数据类型放入容器中

public void func2(){List<Integer> list = new ArrayList<>();list.add(1);}

反汇编之后

  public void func2();Code:0: new           #4                  // class java/util/ArrayList3: dup4: invokespecial #5                  // Method java/util/ArrayList."<init>":()V7: astore_18: aload_19: iconst_110: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;13: invokeinterface #6,  2            // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z18: pop19: return

在第10步，使用了自动装箱

什么时候自动拆箱

1. 初始化，赋值，函数返回时

把包装类对象赋值给基本数据类型的变量时，会自动拆箱（函数返回值原理一样）

2. 包装类型做算数运算时

算数运算（包括比较大小）是针对基本数据类型的，所以无论是基本数据类型与包装类型还是包装类型与包装类型之间做运算都会转换成两个基本数据类型

public void func3(){Integer integer = 3;int i = 1;Integer integer1 = 1;boolean b1 = integer > i; // 基本数据类型与包装类型比较大小boolean b2 = integer > integer1; // 两个包装类型比较大小}

反汇编后

public void func3();Code:0: iconst_31: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;4: astore_15: iconst_16: istore_27: iconst_18: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;11: astore_312: aload_113: invokevirtual #3                  // Method java/lang/Integer.intValue:()I16: iload_217: if_icmple     2420: iconst_121: goto          2524: iconst_025: istore        427: aload_128: invokevirtual #3                  // Method java/lang/Integer.intValue:()I31: aload_332: invokevirtual #3                  // Method java/lang/Integer.intValue:()I35: if_icmple     4238: iconst_139: goto          4342: iconst_043: istore        545: return

通过13步，说明基本数据类型与包装类型比较大小会转换为两个基本数据类型再比较
通过28，32步，说明两个包装类型比较大小也会转换为基本数据类型

普通的加减乘除也一样

public void func4() {Integer integer = 3;int i = 1;Integer integer1 = 1;int s = integer + integer1;int s1 = integer + i;}

public void func4();Code://...13: invokevirtual #3                  // Method java/lang/Integer.intValue:()I16: aload_317: invokevirtual #3                  // Method java/lang/Integer.intValue:()I20: iadd21: istore        423: aload_124: invokevirtual #3                  // Method java/lang/Integer.intValue:()I//...

3. 三目运算

如果三目运算的第二三位一个是基本数据类型另一个是包装类型时，会自动拆箱成两个基本数据类型

public void func5() {boolean flag = true;Integer i = 8;int j;j = 3;int k = flag ? i: j;
}

  public void func5();Code:0: iconst_11: istore_12: bipush        84: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;7: astore_28: iconst_39: istore_310: iload_111: ifeq          2114: aload_215: invokevirtual #3                  // Method java/lang/Integer.intValue:()I18: goto          2221: iload_322: istore        424: return

因为i是包装类型，j是基本数据类型，所以在14行把i自动拆箱成了基本数据类型（并不是应为三目运算返回的是int），所以做三目运算时应该注意，尤其是基本数据类型和对象混杂时，如果对象没被赋值，可能导致NPL（空指针异常）

只有一个是基本数据类型，一个是包装类对象时才会自动拆箱，两个对象是不拆的。

装箱和拆箱时的缓存问题

public class Demo2 {public static void main(String[] args) {Integer a1 = 1;Integer a2 = 1;int a3 = 1;System.out.println(a1 == a2);  // trueSystem.out.println(a1.equals(a2));  // trueSystem.out.println(a1 == a3);  // trueSystem.out.println(a1.equals(a3));  // true}
}

public class Demo2 {public static void main(String[] args) {Integer a1 = 133;Integer a2 = 133;int a3 = 133;boolean b1 = a1 == a2;boolean b2 = a1.equals(a2);boolean b3 = a1 == a3;boolean b4 = a1.equals(a3);System.out.println(b1);  // falseSystem.out.println(b2);  // trueSystem.out.println(b3);  // trueSystem.out.println(b4);  // true}
}

两次结果不同，原因就是自动拆装箱时存在缓存问题，当我们第一次使用Integer时，Java会初始化一个Integer[] cache然后通过循环把-128到127之间的数加入到这个缓存中，如果新new的Integer的值在这个范围内，就直接返回这个创建好的对象，equals()比较值，==比较是不是同一对象，所以不管怎样，equals的结果都是true,而==在-128 到 127 之间是true，超出这个范围是false。