自动装箱与自动拆箱

最新推荐文章于 2022-10-27 22:29:52 发布

steamyao

最新推荐文章于 2022-10-27 22:29:52 发布

阅读量148

点赞数

分类专栏： java

java 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

一定义

装箱：将基本类型转换成包装类对象
int i=10;
Integer x=new Integer(i);手动装箱
Integer y=10;自动装箱

拆箱：将包装类对象转换成基本类型的值
Integer j=new Integer(8);
int m=j.intValue();//手动拆箱
int n=j;//自动拆箱

实现：javac编译器的语法糖

二原因

一个基本类型包装成一个类，可以使这个类型具有很多可以调用的方法
符合JAVA面向对象的编程思想
在泛型中，基本类型是不可以做泛型参数的。如：List <int> list = new ArrayList<int> ();这是不合法的。你只能这个样写List<Integer> list = new ArrayList<Integer> ();

三详解

Integer total = 99;
执行上面那句代码的时候，系统为我们执行了：
Integer total = Integer.valueOf(99);

int totalprim = total;
执行上面那句代码的时候，系统为我们执行了：
int totalprim = total.intValue();

源码实现（以Integer类为例）：

public static Integer valueOf(int i) {
        //判断i是否在-128和127之间，存在则从IntegerCache中获取包装类的实例，否则new一个新实例
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }


    //使用亨元模式，来减少对象的创建（亨元设计模式大家有必要了解一下，我认为是最简单的设计模式，也许大家经常在项目中使用，不知道他的名字而已）
    private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];

        //静态方法，类加载的时候进行初始化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() {}
    }

对于Integer total = 99; 系统为我们执行了Integer total = Integer.valueOf(99);

首先判断i值是否在-128和127之间，如果在-128和127之间则直接从IntegerCache.cache缓存中获取指定数字的包装类；不存在则new出一个新的包装类。
IntegerCache内部实现了一个Integer的静态常量数组，在类加载的时候，执行static静态块进行初始化-128到127之间的Integer对象，存放到cache数组中。cache属于常量，存放在java的方法区中。

8种基本类型的自动装箱

 //boolean原生类型自动装箱成Boolean
    public static Boolean valueOf(boolean b) {
        return (b ? TRUE : FALSE);
    }

    //byte原生类型自动装箱成Byte
    public static Byte valueOf(byte b) {
        final int offset = 128;
        return ByteCache.cache[(int)b + offset];
    }

    //byte原生类型自动装箱成Byte
    public static Short valueOf(short s) {
        final int offset = 128;
        int sAsInt = s;
        if (sAsInt >= -128 && sAsInt <= 127) { // must cache
            return ShortCache.cache[sAsInt + offset];
        }
        return new Short(s);
    }

    //char原生类型自动装箱成Character
    public static Character valueOf(char c) {
        if (c <= 127) { // must cache
            return CharacterCache.cache[(int)c];
        }
        return new Character(c);
    }
    
    //int原生类型自动装箱成Integer
    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

    //int原生类型自动装箱成Long
    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);
    }

    //double原生类型自动装箱成Double
    public static Double valueOf(double d) {
        return new Double(d);
    }

    //float原生类型自动装箱成Float
    public static Float valueOf(float f) {
        return new Float(f);
    }

只有double和float的自动装箱代码没有使用缓存，每次都是new 新的对象，其它的6种基本类型都使用了缓存策略。
使用缓存策略是因为，缓存的这些对象都是经常使用到的（如字符、-128至127之间的数字），防止每次自动装箱都创建一次对象的实例。
而double、float是浮点型的，没有特别的热的（经常使用到的）数据的，缓存效果没有其它几种类型使用效率高。

下面对Integer派别进行一个总结，如下图：

四实践

1.

public class Main {
    public static void main(String[] args) {

        Integer i1 = 100;
        Integer i2 = 100;
        Integer i3 = 200;
        Integer i4 = 200;

        System.out.println(i1==i2);
        System.out.println(i3==i4);
    }
}
//结果为：true false

2.

public class Main {
    public static void main(String[] args) {

        Double i1 = 100.0;
        Double i2 = 100.0;
        Double i3 = 200.0;
        Double i4 = 200.0;

        System.out.println(i1==i2);
        System.out.println(i3==i4);
    }
}
//结果为：false false

3.

1 Integer num1 = 400;  
2 int num2 = 400;  
3 System.out.println(num1 == num2); //true

对num1进行拆箱操作。

4.

1 Integer num1 = 100;  
2 int num2 = 100;  
3 System.out.println(num1.equals(num2));  //true

1 @Override
2 public boolean equals(Object o) {
3     return (o instanceof Integer) && (((Integer) o).value == value);
4 }

DEGUG一下

执行了装箱操作。

5.

1 Integer num1 = 100;  
2 int num2 = 100;  
3 Long num3 = 200l;  
4 System.out.println(num1 + num2);  //200
5 System.out.println(num3 == (num1 + num2));  //true
6 System.out.println(num3.equals(num1 + num2));  //false

1、当一个基础数据类型与封装类进行==、+、-、*、/运算时，会将封装类进行拆箱，对基础数据类型进行运算。
2、对于num3.equals(num1 + num2)为false的原因很简单，我们还是根据代码实现来说明：

1 @Override
2 public boolean equals(Object o) {
3     return (o instanceof Long) && (((Long) o).value == value);
4 }

它必须满足两个条件才为true：
1、类型相同
2、内容相同
上面返回false的原因就是类型不同。

6.

1 Integer num1 = 100;
2 Ingeger num2 = 200;
3 Long num3 = 300l;
4 System.out.println(num3 == (num1 + num2)); //true

1 int num1 = 100;
2 int num2 = 200;
3 long mum3 = 300;
4 System.out.println(num3 == (num1 + num2)); //true

所以，当 “==”运算符的两个操作数都是包装器类型的引用，则是比较指向的是否是同一个对象，而如果其中有一个操作数是表达式（即包含算术运算）则比较的是数值（即会触发自动拆箱的过程）。

陷阱1：

1  Integer integer100=null;  
2  int int100=integer100;

这两行代码是完全合法的，完全能够通过编译的，但是在运行时，就会抛出空指针异常。其中，integer100为Integer类型的对象，它当然可以指向null。但在第二行时，就会对integer100进行拆箱，也就是对一个null对象执行intValue()方法，当然会抛出空指针异常。所以，有拆箱操作时一定要特别注意封装类对象是否为null。

陷阱2：

Integer num1 = 100;
Integer num2 = 100;
System.out.println(num1==num2);

对于在-128至127之间的赋值，Integer对象是在缓存中产生的，会复用已有对象，可以用“==”，而范围之外，是在堆上产生新的对象，必须用equals。

总结：
1、需要知道什么时候会引发装箱和拆箱
2、装箱操作会创建对象，频繁的装箱操作会消耗许多内存，影响性能，所以可以避免装箱的时候应该尽量避免。

3、equals(Object o) 因为原equals方法中的参数类型是封装类型，所传入的参数类型（a）是原始数据类型，所以会自动对其装箱，反之，会对其进行拆箱

4、当两种不同类型用==比较时，包装器类的需要拆箱。同种包装类型比较用equals，

转载：

https://www.jianshu.com/p/0ce2279c5691

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

steamyao

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
自动装箱与自动拆箱

一定义装箱：将基本类型转换成包装类对象int i=10;Integer x=new Integer(i);手动装箱Integer y=10;自动装箱拆箱：将包装类对象转换成基本类型的值Integer j=new Integer(8);int m=j.intValue();//手动拆箱int n=j;//自动拆箱实现：javac编译器的语法糖二原因一个基本类型...
复制链接

扫一扫