精华内容
下载资源
问答
  • Java自动装箱和拆箱的实现原理

    千次阅读 2019-10-02 10:02:31
    一、装箱拆箱 原始类型转换为对象类型就是装箱,反之就是拆箱。 原始类型byte,short,char,int,long,float,double,...自动装箱时编译器调用valueOf将原始类型值转换成对象,同时自动拆箱时,编译器通过调用类似intV...

    一、装箱和拆箱

    原始类型转换为对象类型就是装箱,反之就是拆箱。
    原始类型byte,short,char,int,long,float,double,boolean对应的封装类为Byte,Shor,Character,Integer,Long,Float,Double,Boolean.

    二、源码解读

    自动装箱时编译器调用valueOf将原始类型值转换成对象,同时自动拆箱时,编译器通过调用类似intValue(),doubleValue()这类的方法将对象转换成原始类型值。
    以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 i = 40;相当于调用了Integer.valueOf(40)方法:
    首先判断i是否在-128和127之间,如果在,直接从IntegerCache缓存中获取指定数字的包装类;不存在则new出一个新的包装类。
    IntegerCache内部实现了一个Integer的静态常量数组,在类加载的时候,执行static静态代码块进行初始化-128到127之间的Integer对象,存到cache数组中。cache属于常量,存放在Java的方法区中。

    这就解释了以下的结果:

    Integer i = 40;
    Integer j = 40;
    Integer k = 200;
    i == j    为true;
    i == k   为false;
    Integer i4 = new Integer(40);  
    Integer i5 = new Integer(40);  
    Integer i6 = new Integer(0); 
    i4 == i5   为false,因为直接new,地址不同
    i4 == i5+i6  为true,因为涉及到缓存。
    

    Java8种基本类型的自动装箱源码:

     //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一个新对象。
    使用缓存的策略是因为缓存的这些对象都是经常使用到的,防止每次自动装箱都创建一次对象的实例。

    缓存对象的范围:
    在这里插入图片描述

    展开全文
  • 文章目录1 自动装箱和自动拆箱2 包装类还可以实现基本类型字符串之间的转换3 包装类可以与基本类型比较4 一个容易出错的情况 1 自动装箱和自动拆箱 自动装箱: 允许将一个基本类型数据直接赋值给一个它对应的...


    1 自动装箱和自动拆箱

    自动装箱:

    允许将一个基本类型数据直接赋值给一个它对应的包装类变量。

    自动拆箱:

    允许将一个包装类变量直接赋值给它对象的基本类型变量。

    例子:
    在这里插入图片描述

    在jdk1.5直接基本数据类型和其包装类的转换必须用new Constructor()和WrapperClassInstance.xxxValue()。如下:
    在这里插入图片描述


    2 包装类还可以实现基本类型和字符串之间的转换

    字符串向基本类型转换:

    1. 通过WrapperClass.parseXXX(String str)(出Character包装类其他包装类都提供了)
    2. 通过new WrapperClass(String str)的构造函数

    基本类型向字符串转换:

    通过String.valueOf()方法

    在这里插入图片描述


    3 包装类可以与基本类型比较

    这种比较是取出包装类实例所包装的基本类型的数值进行比较的。


    4 一个容易出错的情况

    public class Main {
    	public static void main(String[] args) {
    		Integer a=3;
    		Integer b=3;
    		Integer e=new Integer(3);
    		Integer c=199;
    		Integer d=199;
    		System.out.println(a==b);//
    		System.out.println(3==e);//与包装类比较是取出包装类实例的基本类型值进行比较的
    		System.out.println(b.equals(e));//两个不同对象实例
    		System.out.println(c==d);//-128到127的都已经被存到cache里面了
    	}
    
    }
    

    输出结果:
    在这里插入图片描述

    为什么a==b为true,c==d为false呢?
    原因是这样的
    在这里插入图片描述

    系统先把-128-127的数自动装箱到cache中,以后发生自动装箱时,如果基本类型的值是-128到127之间,它就指向cache数值里面的对象。所以a==b为true,c==d为false。

    Integer,Short,Byte,Long,Boolean都实现了这种缓存机制。

    public static void main(String[] args) {
    		System.out.println("int");
    		Integer a=3;
    		Integer b=3;
    		Integer e=new Integer(3);
    		Integer c=199;
    		Integer d=199;
    		//Byte,Short,Long与Integer一样保存了-128-127的对象
    		System.out.println(a==b);//
    		System.out.println(3==e);//与包装类比较是取出包装类实例的基本类型值进行比较的
    		System.out.println(b.equals(e));//两个不同对象实例
    		System.out.println(c==d);//-128到127的都已经被存到cache里面了
    		
    		//double,float,char就没有实现
    		System.out.println("double");
    		Double da=3.0;
    		Double db=3.0;
    		System.out.println(da==db);
    			
    		//Boolean也是把true和false自动装箱了,并保持到两个静态变量中了
    		System.out.println("boolean");
    		Boolean ba=true;
    		Boolean bb=true;
    		System.out.println(ba=bb);
    		
    		
    	}
    
    展开全文
  • Java自动装箱自动拆箱(包装类)

    千次阅读 多人点赞 2019-06-15 10:18:39
    包装类的作用: Java 语言中,一切都是对象,但是有例外: 8 个基本数据类型不是对象,因此在很多时候非常不方便。 为此, Java提供为 8 个基本类型提供了对应的包装类: byte ------- Byte short ------ Short ....

    一、基本介绍

    包装类的作用: Java 语言中,一切都是对象,但是有例外: 8 个基本数据类型不是对象,因此在很多时候非常不方便。 为此, Java提供为 8 个基本类型提供了对应的包装类:
                           byte ------- Byte 
                           short ------ Short 
                           int ---------- Integer 
                           long -------- Long 
                           char -------- Character 
                           float -------- Float                                                                                                                                                                                 double ----- Double 
                           boolean----- Boolean 

    包装类如何使用? JDK1.5 , 新增了 2 个功能:自动装箱自动拆箱

    • 自动装箱 当我们把一个基本类型的值( 20),赋值给引用变量时候,系统可以 自动将它“包装”为相应的包装类的实例程序需要对象时, 如果给的只是一个基本类型的值, 系统会将它自动装箱为包装类的实例达到的效果: 有了自动装箱之后, 基本类型的值可以当成对象用—— 其实是【假相】 。
    • 自动拆箱: 当我们需要一个基本类型的值时, 但实际上传入的包装类的对象。 系 统会自动把对象“剥”开,得到它的值。 达到的效果: 有了自动拆箱之后, 包装类的对象可当成基本类型的值 用——其实是【假相】 。

    自动装箱 ----- 基本类型的值 → 包装类的实例

    自动拆箱 ----- 基本类型的值 ← 包装类的实例

    事实上,包装类比基本类型更好用——基本类型能做的事情,包装类也能做。 但包装类能做的,基本类型不一定能做,比 如要赋一个 null 值。

    二、装箱和拆箱是如何实现的

    public class Main {
        public static void main(String[] args) {         
            Integer i = 10;
            int n = i;
        }
    }

    反编译为:

    package com.mao.a_box;
    
    public class Test01
    {
    
    	public Test01()
    	{
    	}
    
    	public static void main(String args[])
    	{
    		Integer i = Integer.valueOf(10);
    		int n = i.intValue();
    	}
    }

            从反编译得到的字节码内容可以看出,在装箱的时候自动调用的是Integer的valueOf(int)方法。而在拆箱的时候自动调用的是Integer的intValue方法

    因此可以用一句话总结装箱和拆箱的实现过程:

      装箱过程是通过调用包装器的valueOf方法实现的,而拆箱过程是通过调用包装器的 xxxValue方法实现的。(xxx代表对应的基本数据类型)

     三、面试中相关的问题

    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

    输出结果表明i1和i2指向的是同一个对象,而i3和i4指向的是不同的对象。此时只需一看源码便知究竟,下面这段代码是Integer的valueOf方法的具体实现:

    public static Integer valueOf(int i) {
            if(i >= -128 && i <= IntegerCache.high)
                return IntegerCache.cache[i + 128];
            else
                return new Integer(i);
    }
    private static class IntegerCache {
            static final int high;
            static final Integer cache[];
    
            static {
                final int low = -128;
    
                // high value may be configured by property
                int h = 127;
                if (integerCacheHighPropValue != null) {
                    // Use Long.decode here to avoid invoking methods that
                    // require Integer's autoboxing cache to be initialized
                    int i = Long.decode(integerCacheHighPropValue).intValue();
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - -low);
                }
                high = h;
    
                cache = new Integer[(high - low) + 1];
                int j = low;
                for(int k = 0; k < cache.length; k++)
                    cache[k] = new Integer(j++);
            }
    
            private IntegerCache() {}
        }

    从这2段代码可以看出,在通过valueOf方法创建Integer对象的时候,如果数值在[-128,127]之间,便返回指向IntegerCache.cache中已经存在的对象的引用否则创建一个新的Integer对象

      上面的代码中i1和i2的数值为100,因此会直接从cache中取已经存在的对象,所以i1和i2指向的是同一个对象,而i3和i4则是分别指向不同的对象。

     

    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

    在这里只解释一下为什么Double类的valueOf方法会采用与Integer类的valueOf方法不同的实现。

    很简单:在某个范围内的整型数值的个数是有限的,而浮点数却不是

      注意,Integer、Short、Byte、Character、Long这几个类的valueOf方法的实现是类似的。

         Double、Float的valueOf方法的实现是类似的。

     

    3.下面这段代码输出结果是什么:

    public class Main {
        public static void main(String[] args) {
             
            Boolean i1 = false;
            Boolean i2 = false;
            Boolean i3 = true;
            Boolean i4 = true;
             
            System.out.println(i1==i2);
            System.out.println(i3==i4);
        }
    }
    //true
    //true

    至于为什么是这个结果,同样地,看了Boolean类的源码也会一目了然。下面是Boolean的valueOf方法的具体实现:

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

    而其中的 TRUE 和FALSE又是什么呢?在Boolean中定义了2个静态成员属性:

    public static final Boolean TRUE = new Boolean(true);
    
        /** 
         * The <code>Boolean</code> object corresponding to the primitive 
         * value <code>false</code>. 
         */
        public static final Boolean FALSE = new Boolean(false);

     

    4.谈谈Integer i = new Integer(xxx)和Integer i =xxx;这两种方式的区别。

      当然,这个题目属于比较宽泛类型的。但是要点一定要答上,我总结一下主要有以下这两点区别:

      1)第一种方式不会触发自动装箱的过程;而第二种方式会触发;

      2)在执行效率和资源占用上的区别。第二种方式的执行效率和资源占用在一般性情况下要优于第一种情况(注意这并不是绝对的)。

     

    5.下面程序的输出结果是什么?

    public class Main {
        public static void main(String[] args) {
             
            Integer a = 1;
            Integer b = 2;
            Integer c = 3;
            Integer d = 3;
            Integer e = 321;
            Integer f = 321;
            Long g = 3L;
            Long h = 2L;
             
            System.out.println(c==d);
            System.out.println(e==f);
            System.out.println(c==(a+b));
            System.out.println(c.equals(a+b));
            System.out.println(g==(a+b));
            System.out.println(g.equals(a+b));
            System.out.println(g.equals(a+h));
        }
    }
    /*true
    false
    true
    true
    true
    false
    true*/

    其反编译为:

    package com.mao.a_box;
    
    import java.io.PrintStream;
    
    public class Main
    {
    
    	public Main()
    	{
    	}
    
    	public static void main(String args[])
    	{
    		Integer a = Integer.valueOf(1);
    		Integer b = Integer.valueOf(2);
    		Integer c = Integer.valueOf(3);
    		Integer d = Integer.valueOf(3);
    		Integer e = Integer.valueOf(321);
    		Integer f = Integer.valueOf(321);
    		Long g = Long.valueOf(3L);
    		Long h = Long.valueOf(2L);
    		System.out.println(c == d);
    		System.out.println(e == f);
    		System.out.println(c.intValue() == a.intValue() + b.intValue());
    		System.out.println(c.equals(Integer.valueOf(a.intValue() + b.intValue())));
    		System.out.println(g.longValue() == (long)(a.intValue() + b.intValue()));
    		System.out.println(g.equals(Integer.valueOf(a.intValue() + b.intValue())));
    		System.out.println(g.equals(Long.valueOf((long)a.intValue() + h.longValue())));
    	}
    }

    第一个和第二个输出结果没有什么疑问。第三句由于  a+b包含了算术运算,因此会触发自动拆箱过程(会调用intValue方法),因此它们比较的是数值是否相等。而对于c.equals(a+b)会先触发自动拆箱过程,再触发自动装箱过程,也就是说a+b,会先各自调用intValue方法,得到了加法运算后的数值之后,便调用Integer.valueOf方法,再进行equals比较。同理对于后面的也是这样,不过要注意倒数第二个和最后一个输出的结果(如果数值是int类型的,装箱过程调用的是Integer.valueOf;如果是long类型的,装箱调用的Long.valueOf方法)。

     

    作者:Matrix海子  

    出处:http://www.cnblogs.com/dolphin0520/

    转自:http://www.cnblogs.com/dolphin0520/p/3780005.html

    展开全文
  • 如何理解Java中的自动拆箱和自动装箱? 自动拆箱?自动装箱?什么鬼,听都没听过啊,这…这…知识盲区… 回到家后小伟赶紧查资料,我透,这不就是问基本类型跟封装类型吗,面试官整啥名词呢… 别问结果,问就是没过...

    小伟刚毕业时面的第一家公司就被面试官给问住了,记忆尤深啊…

    如何理解Java中的自动拆箱和自动装箱?

    自动拆箱?自动装箱?什么鬼,听都没听过啊,这…这…知识盲区…

    回到家后小伟赶紧查资料,我透,这不就是问基本类型跟封装类型吗,面试官整啥名词呢…

    别问结果,问就是没过。

    1、 什么是自动装箱,自动拆箱

    定义:基本数据类型和包装类之间可以自动地相互转换

    理解:装箱就是自动将基本数据类型转换为封装类型,拆箱就是自动将封装类型转换为基本数据类型。

    我们知道,Java中提供了四大类基本数据类型,分别是:整数、浮点数、字符型和布尔型,其中:

    • 整数包含:byte、int、short、long
    • 浮点数包含:float、double
    • 字符类型:char
    • 布尔类型:boolean

    基本数据类型相信大家一定很熟悉了吧,来来来,说说他们的取值范围~

    数据类型取值范围
    byte-128 ~ 127
    short-32786 ~ 32767
    int-4294967296 ~ 4294967295
    long-264 ~ 264 -1
    float3.4e-038 ~ 3.4e+038
    double1.7e-308 ~ 1.7e+308
    char\u0000 ~ \uffff
    booleantrue 、false

    日常开发中,靠这些基本数据类型几乎能够满足我们的需求,但是基本类型终究不是对象,往重了说不满足面向对象的开发思想,往轻了说就是使用不方便。怎么讲?例如做一些数据类型转换,获取int数据类型的取值范围等等。

    我们知道,类的优点在于它可以定义成员变量、成员方法,提供丰富便利的功能,因此Java在JDK1.0的时候就设计了基本数据类型的包装类,而在JDK1.5中引入了新特性:自动装箱和拆箱。

    我们来看一下基本类型跟封装类型之间的对应关系:

    数据类型封装类
    byteByte
    shortShort
    intInteger
    longLong
    floatFloat
    doubleDouble
    charCharacter
    booleanBoolean

    2、 使用包装类型后的便捷

    我们以上边提到的数据类型转换为例,看看使用包装类型后的便捷性。

    小伟在数据库中存放商品库存用的是 varchar 类型来存储的,所以在代码中的实体与之对应的是 String,那么问题来了,既然是库存,那么势必就要用到加减乘除之类的运算,所以就需要先转换成 数值类型(int\long\float等)来运算,我们看一下通过包装类是如何快速转换的「int\long\float」:

    public class Test {
        public static void main(String[] args) {
            // 数据库中的商品数量 number
            String number = "666";
            // 借助封装了 Integer 转换为 int
            int intVal = Integer.valueOf(number);
            // 借助封装了 Float 转换为 float
            float floatVal = Float.valueOf(number);
            // 借助封装了 Long 转换为 long
            long longVal = Long.valueOf(number);
            // 依次输出三个值的内容
            System.out.println("int="+intVal);
            System.out.println("floatVal="+floatVal);
            System.out.println("longVal="+longVal);
        }
    }
    

    3、 落实自动装箱、拆箱

    看完了包装类型的便捷性后,我们再来落实到自动装箱、自动拆箱上…

    怎么就自动装箱,自动拆箱了呢?

    上一段代码,看看哪是自动装箱跟自动拆箱:

    // 自动装箱
    1. Integer a = 100;
    // 自动拆箱
    2. int b = a;
    

    自动装箱,相当于Java编译器替我们执行了 Integer.valueOf(XXX);

    自动拆箱,相当于Java编译器替我们执行了Integer.intValue(XXX);

    我们证实一下,首先通过 javac 编译得到 class 文件,接着反编译看看:

    指令为:javap -c class文件名,得到下图所示:

    看完编译器替我们做的,接下来我们再通过源码看看,首先是自动装箱 valueOf() 方法:

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

    我们可以看到,首先是if方法, 对传入的int 数值进行判断,如果 i >= -128i <= 127 那么就会从IntegerCache缓存中获取指定数字的封装类,如果不存在则 new 出一个新的封装类,关于 IntegerCache ,其内部实现了一个Integer的静态常量数组,在类加载的时候,执行static静态块进行初始化-128~127之间的Integer对象,存放到cache数组中,cache属于常量,存放在java的方法区中,对方法区不太了解的小伙伴可以先留空,后面我会单独水一篇的~

    额外补充一下:上边我们只看了Integer封装类的自动装箱方法,从方法中我们了解了在-128~127之间使用了缓存,那么是不是意味着别的封装类也是这样呢?其实不是的,首先Integer使用缓存原因是该区间会被经常使用到,且数量个数比较确定,就256个值,所以为了提高效率,防止每次自动装箱都创建一次对象实例,然后就你懂得~,而double、float浮点型是没有使用缓存的,因为小数点的原因,所以在这个区间范围内个数是比较泛的,即不适合缓存,没有意义。

    我们通过一段代码看看这个缓存的效果吧:

    public class Test2 {
        public static void main(String[] args) {
            Integer a = 100;
            Integer b = 100;
            Integer c = 200;
            Integer d = 200;
            System.out.println(a==b); // 打印true
            System.out.println(a==b); // 打印false
        }
    }
    

    接着再来看自动拆箱 intValue() 方法:

    private final int value;
    
    public int intValue() {
    	return value;
    }
    

    这个方法就比较简单了,调用时直接返回了基本数据类型的 value 值。

    至此我们看完了自动装箱、自动拆箱,以Integer为例我们知道了使用 valueOf() 方法实现装箱,使用 intValue() 方法实现拆箱,接下来我们再结合几行代码重新回顾一下:

    1. Integer a = new Integer(100);
    2. Integer b = 100;
    3. b+=100;
    
    • 第一行代码:new 了一个 Integer 对象实例,将 int 类型的数据传入包装成了 Integer 类型。

    • 第二行代码:首先我们知道 100 是 int 类型的,但是等待复制的 b 是 Integer 类型,此时就用到了自动装箱,b = Integer.valueOf(100),将100包装成包装类了「通过反编译验证」

    • 第三行代码:用到了自动装箱+自动拆箱,b = b + 100 = Integer.intValye(b) + 100 此时计算结果得到的应该是 int 类型的 b,但是 b 又被限定了是 Integer 类型,所以就又要用到 Integet.valueOf() 自动装箱。

    4、 上才艺

    才艺一:如何理解Java中的自动拆箱和自动装箱?

    答:自动装箱就是将基本数据类型自动转换为封装类型,自动拆箱是将封装类型自动转换为基本数据类型。

    才艺二:能说一下是通过哪些方法实现自动拆箱、装箱的吗?

    答:以Integer为例,使用Integer.valueOf()方法实现装箱,使用Integer.intValue()方法实现拆箱。

    推荐阅读:

    跟小伟一起学习类加载机制

    为什么有这么多领优惠劵的群?

    单招计算机类哪个专业比较好

    本文首发于博客园:https://www.cnblogs.com/niceyoo

    展开全文
  • 什么是自动装箱自动拆箱 自动装箱就是自动将基本数据类型转换为包装器类型; 自动拆箱就是自动将包装器类型转换为基本数据类型。 基本数据类型 int、short、long、float、double、byte、char、boolean。 包装器...
  • 基本数据(Primitive)类型的自动装箱(autoboxing)、拆箱(unboxing)是自J2SE 5.0开始提供的功能。java语言规范中说道:在许多情况下包装与解包装是由编译器自行完成的(在这种情况下包装成为装箱,解包装称为拆箱
  • 自动装箱 基本数据类型转换成包装类 自动拆箱 将包装类转成基本数据类型 参考图 案例 //自动装箱:这样定义系统转成Integer i = Integer.valueOf(100); Integer i= 100; //自动拆箱:这样定义系统转成 int ...
  • java 什么是拆箱和装箱 1、什么是自动装箱拆箱 很简单,下面两句代码就可以看到bai装箱和拆箱过程 //自动装箱 Integertotal=99; //自定拆箱 inttotalprim=total; 简单一点说,装箱就是自动将基本数据类型转换...
  • Java 自动装箱和拆箱

    万次阅读 多人点赞 2013-01-17 10:52:35
     在介绍Java自动装箱和拆箱之前,先来了解一下Java的数据类型。  在Java中,数据类型可以分为两大种,Primitive Type(基本类型)Reference Type(引用类型)。基本类型的数值不是对象,不能作为对象调用其...
  • 什么是自动装箱拆箱 基本数据类型的自动装箱(autoboxing)、拆箱(unboxing)是自J2SE 5.0开始提供的功能。  一般我们要创建一个类的对象实例的时候,我们会这样:  Class a = new Class(parameter);  当我们创建一...
  • Java 自动装箱和自动拆箱注意的问题

    千次阅读 2016-06-15 17:00:48
    自动装箱和自动拆箱不是什么复杂的技术,自动装箱就是基本类型(int,long)数据可以先自动转换为对应的封装类(Integer,Long)对象,而自动拆箱相反。 在本文中,笔者向大家介绍下Java中一个非常重要也非常有趣的...
  • 自动装箱和拆箱是根据什么原理实现的? 自动装箱时编译器调用valueOf将原始类型值转换成对象, 自动拆箱时,编译器通过调用类似intValue(),doubleValue()这类的方法将对象转换成原始类型值。 这种方式在Java中很常见...
  • java基础--06(自动装箱拆箱

    千次阅读 多人点赞 2019-02-11 16:40:27
    1.自动装箱自动拆箱 1.自动装箱自动拆箱 装箱就是自动将基本数据类型转换为包装器类型;拆箱就是 自动将包装器类型转换为基本数据类型。 java的数据类型: 自动装箱: 最主要的就是Integer b=a;这...
  • 1.回顾一下Java基础数据类型 基础类型 字节 包装类型 int 4字节 Integer byte 1字节 Byte short 2字节 Short long 8字节 Long float 4字节 Float double ...
  • 关于Java自动装箱拆箱的面试题

    千次阅读 2019-01-27 18:11:45
    答案如上注释部分,核心考察点就是上道题的答案,即 java 1.5 开始的自动装箱拆箱机制其实是编译器自动完成的替换,装箱阶段自动替换为了 valueOf 方法,拆箱阶段自动替换为了 xxxValue 方法。对于 Integer 类型的 ...
  • 发现报错, 提示告诉我是在setFont传入最后一个参数的时候传入的是一个Integer而不是一个int, 但是按照Java自动装箱拆箱机制, 在此处的Integer应该会自动拆箱调用intValue方法变成int, 但是并没有, 查询资料之后...
  • 基本数据类型的自动装箱(autoboxing)、拆箱(unboxing)是自J2SE 5.0开始提供的功能。 一般我们要创建一个类的对象实例的时候,我们会这样:  Class a = new Class(parameter); 1、自动装箱 例如:Integer i = ...
  • 主要给大家介绍了关于Java自动装箱拆箱引起的耗时的相关资料,文中通过示例代码介绍的非常详细,对大家学习或者使用Java具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • 1.自动装箱拆箱的定义装箱就是自动将基本数据类型转换为包装器类型;拆箱就是 自动将包装器类型转换为基本数据类型。Java中的数据类型分为两类:一类是基本数据类型,另一类是引用数据类型。如下图:由上可知Java...
  • JAVA中最常用的语法糖--自动装箱和拆箱 一,究竟什么是自动装箱和拆箱 1.1 我们直接来看一段非常简单的实例代码: public static void main(String[] args) { int intValue = 100; Integer boxValue = int...
  • Java自动装箱和自动拆箱机制是每个小白学习java基础必备知识点,有利于小白更好地理解基本数据类型引用类型,加强对两者之间的转换的理解,有利于未来的编程。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 38,413
精华内容 15,365
关键字:

java的自动装箱和自动拆箱

java 订阅