自动装箱和拆箱源码分析JDK1.8（一）

傷城~ 2023-10-11 09:57 23阅读 0赞

### 目录 ###

*  1.自动拆、装箱的实现
 *  2.Long类
 *   *  自动装箱
     *   *  源码
         *  例一
     *  自动拆箱
     *   *  源码
 *  3.Short类
 *   *  自动装箱
     *   *  源码
     *  自动拆箱
     *   *  源码
 *  4.Byte类
 *   *  自动装箱
     *   *  源码
         *  例一
     *  自动拆箱
     *   *  源码
 *  5.Character类
 *   *  自动装箱
     *   *  源码
     *  自动拆箱

# 1.自动拆、装箱的实现 #

代码

public static void main(String[] args) {
        
    	Long lon = 100l; //自动装箱
    	long l = lon; //自动拆箱
    }

使用反编译工具**反编译**后：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RhYnVzaUdpbg_size_16_color_FFFFFF_t_70_pic_center]

可以看出，Long的自动装箱都是通过Long.valueOf()方法来实现的，Long的自动拆箱都是通过Long.longValue()来实现的。

# 2.Long类 #

## 自动装箱 ##

### 源码 ###

valueOf()

public static Long valueOf(long l) {
        
    	        final int offset = 128;
    	        //l大于等于-128 且小于等于127，
    	        if (l >= -128 && l <= 127) {
        
    	        	//LongCache.cache是什么下面有解释
    	        	//直接返回Long型数组中的一个元素，数组下标是l+offset的值
    	            return LongCache.cache[(int)l + offset];
    	        }
    	        //否则直接new一个Long类型对象
    	        return new Long(l);
    	    }

LongCache

//起到一个缓存的作用，当装箱的时候值在[-128,127]之间不用new，直接从缓存中拿
    private static class LongCache {
        
    	        private LongCache(){
        }
    	        //定义一个名为cache的Long型数组，数组的长度为256
    	        static final Long cache[] = new Long[-(-128) + 127 + 1];
    	        //这是一个静态代码块，不明白可以学习我的另一篇文档，最后有链接
    	        static {
        
    	        	//给cache数组中的每个元素初始化，每个元素都是一个Byte类型的对象，其属性值分别是[-128,127]
    	            for(int i = 0; i < cache.length; i++)
    	                cache[i] = new Long(i - 128);
    	        }
    	    }

### 例一 ###

代码

public class Demo {
        
    	public static void main(String[] args) {
        
    		Long l1 = 100l;
    		Long l2 = 100l;
    
    		Long l3 = 200l;
    		Long l4 = 200l;
    
    		System.out.println(l1 == l2);
    		System.out.println(l3 == l4);
    
    	}
    }

结果

true
    false

分析，因为100的时候自动装箱都是从缓存中拿的，内存地址当然一样，而200的时候都是新new的内存地址不一样。

## 自动拆箱 ##

### 源码 ###

longValue()

public long longValue() {
        
    			//就是返回Long型对象属性value的值
    	        return value;
    }

# 3.Short类 #

## 自动装箱 ##

### 源码 ###

valueOf()

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);
        }

ShortCache

private static class ShortCache {
        
            private ShortCache(){
        }
    
            static final Short cache[] = new Short[-(-128) + 127 + 1];
    
            static {
        
                for(int i = 0; i < cache.length; i++)
                    cache[i] = new Short((short)(i - 128));
            }
        }

同理，偷懒，不分析了。

## 自动拆箱 ##

### 源码 ###

shortValue()

public short shortValue() {
        
            return value;
    }

# 4.Byte类 #

## 自动装箱 ##

### 源码 ###

valueOf()

public static Byte valueOf(byte b) {
        
    			//定义一个final修饰的int类型的变量并初始化值为128
    	        final int offset = 128;
    	        //返回cache数组中的一个元素，数组下标为b+offset的值
    	        return ByteCache.cache[(int)b + offset];
    }

ByteCache

private static class ByteCache {
        
    	        private ByteCache(){
        }
    	        //定义一个元素为Byte类型的数组，数组名为cache，数组长度为256
    	        static final Byte cache[] = new Byte[-(-128) + 127 + 1];
    	        //此处为静态代码块，另一篇文章有详细介绍，最后有链接
    	        static {
        
    	        	//代码块中的内容很简单，就是为cache数组中的每个元素初始化一个Byte类型的对象
    	        	//这些对象的属性值为-128到127
    	            for(int i = 0; i < cache.length; i++)
    	                cache[i] = new Byte((byte)(i - 128));
    	        }
    	    }

分析：  
因为byte类型的值其取值范围是\[-128,127\]，ByteCache全部都在cache数组中缓存过了，所以经自动装箱产生的Byte类型对象只要数值相同，内存地址就一样。

### 例一 ###

代码

public class Demo {
        
    
    	public static void main(String[] args) {
        
    		
    		Byte b1 = -128;
    		Byte b2 = -128;
    		
    		Byte b3 = 0;
    		Byte b4 = 0;
    		
    		Byte b5 = 127;
    		Byte b6 = 127;
    		
    		System.out.println(b1 == b2);
    		System.out.println(b3 == b4);
    		System.out.println(b5 == b6);		
    	}
    }

结果

true
    true
    true

## 自动拆箱 ##

### 源码 ###

byteValue()

public byte byteValue() {
        
            return value;
        }

# 5.Character类 #

## 自动装箱 ##

### 源码 ###

valueOf()

public static Character valueOf(char c) {
        
    		//由此可知，当小于等于127的时候是从cache数组中拿对象
            if (c <= 127) {
         // must cache
                return CharacterCache.cache[(int)c];
            }
            //否则，new一个Character类型变量返回
            return new Character(c);
        }

ByteCache

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);
            }
        }

分析：同理，偷懒，不做说明了。

## 自动拆箱 ##

一模一样，就是方法名不同。

链接：[自动装箱和拆箱源码分析JDK1.8(二)][JDK1.8]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RhYnVzaUdpbg_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20200425101222291.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RhYnVzaUdpbg==,size_16,color_FFFFFF,t_70#pic_center
[JDK1.8]: https://blog.csdn.net/dabusiGin/article/details/101205754