java 解决拆包 java拆箱装箱有什么用

转载

mob64ca13f7ab19 2023-09-01 12:26:04

文章标签 java 解决拆包 java装箱和拆箱的意义 System 包装类 java 文章分类 Java 后端开发

一、拆箱与装箱

拆箱：将 包装类型的值 转为 基本数据类型的值

装箱：将 基本数据类型的值 转为 包装类型的值

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

二、实现过程

先写一段代码，让他触发装箱操作和拆箱操作：

public class IntegerTest {
    public static void main(String[] args) {
        // 装箱操作
        Integer i = 1;
        // 拆箱操作
        int n = i;
    }
}

在命令框输入命令javac将文件编译为class文件：

E:MyProjectlearn-code>javac E:MyProjectlearn-codesrcmainjavaorgexampletestIntegerTest.java

在命令框输入命令javap -c对class文件进行反编译，查看Java编译器为我们生成的字节码：

E:MyProjectlearn-code>javap -c E:MyProjectlearn-codesrcmainjavaorgexampletestIntegerTest.class
Compiled from "IntegerTest.java"
public class org.example.test.IntegerTest {
  public org.example.test.IntegerTest();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: iconst_1
       1: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
       4: astore_1
       5: aload_1
       6: invokevirtual #3                  // Method java/lang/Integer.intValue:()I
       9: istore_2
      10: return
}

根据注解 #2 和 #3 ，我们可以发现：

#2 -> Integer的装箱方法，调用的是Integer.valueOf(int)方法；

#3 -> int的拆箱方法，调用的是Integer.intValue(Integer)方法。

通过对其他数据类型同样操作，我们可以总结出：

装箱过程是使用包装类型的valueOf()方法来实现，
拆箱过程是使用包装类型的xxxValue()方法来实现。

三、装箱与自动装箱

装箱：在Java JDK5 之前，要创建一个包装类型对象，只能通过包装类型的构造方法生成数据，如：

Integer i = new Integer(1);

自动装箱：从Java JDK5 开始，可以直接将数值复制给包装类型，这时候会调用包装类型的valueOf方法，触发自动装箱操作，如：

Integeer i = 1;

因为自动装箱拥有缓存机制，所以在比较上自动装箱会比装箱具有更高的效率（注意并非绝对）。

四、相关面试题

public static void main(String[] args) {
    // 第一道：Integer面试
    Integer i1 = 127;
    Integer i2 = 127;
    System.out.println("i1 == i2 : " + (i1 == i2));
    Integer i3 = 128;
    Integer i4 = 128;
    System.out.println("i3 == i4 : " + (i3 == i4));

    // 第二道：Double面试
    Double d1 = 127D;
    Double d2 = 127D;
    System.out.println("d1 == d2 : " + (d1 == d2));
    Double d3 = 128D;
    Double d4 = 128D;
    System.out.println("d3 == d4 : " + (d3 == d4));
    
    // 第五道
    Integer in1 = 100;
    Integer in2 = 100;
    int in3 = 100;
    Long lo1 = 200L;
    System.out.println("in1 == in2 : " + (in1 == in2));
    System.out.println("in1 == in3 : " + (in1 == in3));
    System.out.println("lo1 == (in1 + in3) : " + (lo1 == (in1 + in3)));
    System.out.println("in1.equals(in2) : " + (in1.equals(in2)));
    System.out.println("in1.equals(in3) : " + (in1.equals(in3)));
    System.out.println("lo1.equals(in1 + in3) : " + (lo1.equals(in1 + in3)));
}

正确答案如下：

i1 == i2 : true
i3 == i4 : false
d1 == d2 : false
d3 == d4 : false
in1 == in2 : true
in1 == in3 : true
lo1 == (in1 + in3) : true
in1.equals(in2) : true
in1.equals(in3) : true
lo1.equals(in1 + in3) : false

根据上面这些离奇的答案，我们需要查看源码才能知道原因。

五、源码分析

1.Integer

Integer.valueOf方法：

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

IntegerCache类：

private static class IntegerCache {
    static final int low = -128;
    static final int high;
    static final Integer cache[];

    static {
        // high value may be configured by property
        int h = 127;
        String integerCacheHighPropValue =
            sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
        if (integerCacheHighPropValue != null) {
            try {
                int i = parseInt(integerCacheHighPropValue);
                i = Math.max(i, 127);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
            } catch( NumberFormatException nfe) {
                // If the property cannot be parsed into an int, ignore it.
            }
        }
        high = h;

        cache = new Integer[(high - low) + 1];
        int j = low;
        for(int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);

        // range [-128, 127] must be interned (JLS7 5.1.7)
        assert IntegerCache.high >= 127;
    }

    private IntegerCache() {}
}

通过这IntegerCache的代码，我们可以发现IntegerCache.low = -128，IntegerCache.high = 127，并且初始化了一个长度为256的Integer数组，范围在[-128， 127]。

说明数值在[-128， 127] 区间的，Integer会之间使用IntegerCache.cache数组的值，也就意味这区间内的数值可以重复使用，但是超过这个区间就会创建一个新对象。

所以第一道面试题中，数值为127时两个Integer对象都是IntegerCache.cache数组的值，指向地址是相等的；而数值在128时两个Integer对象都是重新创建的，两者指向地址是不相同的。

2、Double

Double.valueOf方法：

public static Double valueOf(double d) {
    return new Double(d);
}

Double每次使用装箱时，都是创建一个新对象，不像Integer有个缓存机制。

所以第二道面试题中，不管数值如何，两个Double对象指向地址都是不相同的。

3、其他类型

类型	缓存	范围
Byte	是	[-128， 127]
Short	是	[-128， 127]
Integer	是	[-128， 127]
Long	是	[-128， 127]
Float	否	无
Double	否	无
Character	是	[0， 127]
Boolean	是	TRUE， FALSE

Byte、Short、Long这三种类型的valueOf方法源码相似，如下：

public final class Long {
    private static class LongCache {
        private LongCache(){}

        static final Long cache[] = new Long[-(-128) + 127 + 1];

        static {
            for(int i = 0; i < cache.length; i++)
                cache[i] = new Long(i - 128);
        }
    }
    
    public static Long valueOf(long l) {
        final int offset = 128;
        if (l >= -128 && l <= 127) { // will cache
            return LongCache.cache[(int)l + offset];
        }
        return new Long(l);
    }
}

Float和Double这两种类型的valueOf方法源码相似，这边就不重复贴出。
Character的valueOf源码如下：

public final class Character {
    private static class CharacterCache {
        private CharacterCache(){}

        static final Character cache[] = new Character[127 + 1];

        static {
            for (int i = 0; i < cache.length; i++)
                cache[i] = new Character((char)i);
        }
    }
}

Boolean的valueOf源码如下：

public final class Boolean {
    public static final Boolean TRUE = new Boolean(true);
    public static final Boolean FALSE = new Boolean(false);

    public static Boolean valueOf(boolean b) {
        return (b ? TRUE : FALSE);
    }
}

4."==" 和 "equals"

1.使用"=="比较

1.两个包装类型比较时，判断的是两个对象的指向地址：

Integer i1 = 100;
Integer i2 = 100;
// 判断i1和i2的指向地址，因为Integer的缓存机制，两者指向同一对象
System.out.println(i1 == i2); // 结果为true

2.一个包装类型和一个基本数据类型比较时，会将包装类型进行拆箱，再判断两个对象的数值：

Integer i1 = 100;
int i2 = 100;
// 将i1进行拆箱，然后比较i1和i2的数值，两边相等
System.out.println(i1 == i2); // 结果为true

3.出现算数运算时，会将包装类型进行拆箱，再判断两边的数值：

Integer i1 = 100;
int i2 = 100;
Long l1 = 200l;
// 1.将i1进行拆箱得到数值100，和i2进行相加等到数值200；
// 2.将l1进行拆箱得到数值200，两边数值比较相等
System.out.println(l1 == (i1 + i2)); // 结果为true

2.使用"equals"比较

equals源码如下：

public boolean equals(Object obj) {
    if (obj instanceof Integer) {
        return value == ((Integer)obj).intValue();
    }
    return false;
}

1.两个包装类比较时，判断的时两个对象的类型和数值：

Integer i1 = 100;
Integer i2 = 100;
// 判断i1和i2的对象类型，再判断i1和i2的数值，两边均相同
System.out.println(i1.equals(i2)); // 结果为true

2.一个包装类型和一个基本数据类型比较时，会将基本数据类型进行装箱，再判断两个对象的类型和数值：

Integer i1 = 100;
int i2 = 100;
// 将i2封装为Integer类型，然后判断类型和数值，两边均相同
System.out.println(i1.equals(i2)); // 结果为true

3.出现算数运算时，会将包装类型进行拆箱再装箱，再判断两个对象的类型和数值：

Integer i1 = 100;
int i2 = 100;
Long l1 = 200l;
// 1.将i1进行拆箱得到数值100，和i2进行相加等到数值200；
// 2.l1的equals方法将上面的200装箱为Integer对象；
// 3.因为Long和Integer类型不相同，且equals不会进行类型转换，返回false
System.out.println(l1.equals(i1 + i2)); // 结果为false

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。