精华内容
下载资源
问答
  • Java SE-基本数据类型对应包装类

    千次阅读 2016-06-30 21:45:09
    其次,包装类作为类是有属性有方法的,功能比基本数据类型要强大。 基本数据类型 对应包装类 byte Byte short Short int Integer long Long char Character float Float double Double

    包装类
    Java是面向对象的编程语言,包装类的出现更好的体现这一思想。
    其次,包装类作为类是有属性有方法的,功能比基本数据类型要强大。

    基本数据类型对应的包装类
    byteByte
    shortShort
    intInteger
    longLong
    charCharacter
    floatFloat
    doubleDouble
    booleanBoolean

    装箱与拆箱

    装箱是指由基本数据类型向对应的包装类型转换。例如,int包装成Integer类的对象。
    拆箱是指有包装类转换成基本数据类型。例如,把Integer类的对象简化成int。

    常见包装类应用(手动装箱与拆箱)
    1、实现int和Integer相互转换
    Integer类通过构造方法将int装箱,通过intValue()方法进行拆箱。

    int m = 50;
    Integer obj = new Interger(m);//手动装箱
    int n = obj.intValue();//手动拆箱

    2、自动装箱与拆箱
    Java 1.5之后,Java支持自动装箱和拆箱

    int m = 50;
    Integer obj = m;//自动装箱
    int n = obj;//自动拆箱

    包装类的优势
    1、带有将基本数据类型作为参数的构造函数

    Integer obj = new Integer(88);

    2、带有将字符串作为参数的构造函数

    Integer obj = new Integer("56");

    3、typeValue()方法
    4、parseType(String str)方法,将字符串转化为基本值,静态方法
    5、toString()方法,生成对应字符串
    6、hashCode()方法,生成哈希码
    7、equals()方法,对同一类的两个对象进行比较

    int与Integer区别
    1、int是作为Java提供的8种原始数据类型之一;Integer是一个类。
    2、初始值不同。

    int默认值是0;Integer默认值是null,即可以区分是否对其赋值。
    1)在JSP中使用el表达式,Integer默认是null,不显示;而int会显示为0.
    2)在Hibernate中使用Integer作为ID的类型,可以根据其是是否为null来判断这个对象是不是临时的。
    

    更于 2016-06-30 21:45

    展开全文
  • java基本数据类型对象包装类

    千次阅读 2017-10-30 22:37:35
    java基本数据类型对象包装类   一、包装类说明 为了方便操作基本数据类型值,将其封装成了对象,在对象中定义了属性和行为丰富了该数据的操作。用于描述该对象的类就称为基本数据类型对象包装类基本数据类型与...

    java基本数据类型对象包装类

     

    一、包装类说明

    为了方便操作基本数据类型值,将其封装成了对象,在对象中定义了属性和行为丰富了该数据的操作。用于描述该对象的类就称为基本数据类型对象包装类。

    基本数据类型相应的包装类

    byte             Byte

    short    Short

    int         Integer

    long             Long

    float     Float

    double Double

    char             Character

    boolean      Boolean

    二、包装类主要功能

    该包装对象主要用基本类型和字符串之间的转换。

    (1)基本类型--->字符串

    1、基本类型数值+""

    2、用String类中的静态方法valueOf(基本类型数值);

    3、用包装类的静态方法valueOf(基本类型数值);

    (2)字符串--->基本类型

    1、使用包装类中的静态方法:xxx parseXxx("xxx类型的字符串");

    eg:

    int parseInt("intstring");

    long parseLong("longstring");

    boolean parseBoolean("booleanstring");

    备注:只有Character没有parse方法,本身就是封装了字符,无须转换

    2、如果字符串被xxx包装类进行对象的封装。

    可使用另一个非静态的方法,xxxValue();

    将一个xxx包装类对象转成基本数据类型值。

    三、JDK1.5自动装箱拆箱

    (1)拆箱装箱概念

    装箱:自动将基本数据类型转换为包装器类型;

    拆箱:自动将包装器类型转换为基本数据类型。

    (2)jdk1.5后包装类新特性


    Integeri=4;//自动装箱,简化书写:Integer i=new Integer(4);
    i=i+6;//i=new Integer(i.intValue+6);//自动拆箱
    System.out.println(i.intValue());//10

    (3)拆箱装箱实现

    装箱:自动将基本数据类型转换为包装器类型;装箱过程是通过调用包装器的valueOf方法实现的

    拆箱:自动将包装器类型转换为基本数据类型。拆箱过程是通过调用包装器的 xxxValue方法实现的。(xxx代表对应的基本数据类型)。

    【1】实现代码案例

    package wrapper;
    
    
    public class Autoboxing_Unboxing {
    
    
    	public static void main(String[] args) {
    	Integer i = 10;//装箱
            int n = i;//拆箱
    	}
    	
    }

    【2】反编译代码发现

    反编译class文件之后得到如下内容:


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

    其他的也类似,比如Double、Character,不相信的朋友可以自己手动尝试一下。

     

    【3】结论

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

    装箱过程是通过调用包装器的valueOf方法实现的,

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

    四、包装类装箱之valueOf方法之思

    1、创建对象与valueOf方法【装箱】

    思考:由于装箱过程是调用包装器的valueOf方法实现的,

    即:当Integer i=3过程,创建Integer对象的时候,这样一个装箱过程,就会调用包装器的valueOf方法。所以,我们在此重点讨论这个valueOf方法。

    2、valueOf方法结论

    主要得出几个结论:

    2.1不同包装类之间,有共性的地方。分为三大派别:

    【1】Integer、Short、Byte、Character、Long这几个类的valueOf方法的实现是类似的。比较特殊,根据数值的大小范围而获得对象的方式不同

    【2】Double、Float的valueOf方法的实现是类似的,每次都返回不同的对象。

    【3】Boolean的valueOf方法实现,每次返回的都是同一个对象

    2.2对于类别【1】

    (1)有两种创建对象的情况:

    《1》在一些特定取值范围内,创建的对象是共享的,即:该数值范围的对象,在内存中只创建一个(一次),以后想创建该数值的对象,直接获取即可,不需要去new新的。

    这个范围的取值情况是:

    相同对象范围:在该范围内,同数值情况下,对象是相同的,是同一个。

    Integer    相同对象范围  [-128,127]

    Short      相同对象范围  [-128,127] 

    Byte      相同对象范围  [-128,127]  

    Character  相同对象范围  [0,127]    

    Long      相同对象范围 [-128,127]  

    《2》除了上述的取值范围内,对象只创建一个,这里所说的范围内,对象不会共享,相同数值情况下,会创建不同的对象

    这个范围的取值情况是:

    不同对象范围:在该范围内,同数值情况下,对象是不同的,是多个不同的。

    Integer    不同对象范围 i<128||i>=128

    Short     不同对象范围 s<128||s>=128

    Byte      不同对象范围  无

    Character  不同对象范围  c>=128

    Long      不同对象范围 L<128||L>=128

    综合《1》《2》得

    Integer    相同对象范围 [-128,127] 不同对象范围i<128||i>=128

    Short     相同对象范围 [-128,127] 不同对象范围s<128||s>=128

    Byte      相同对象范围 [-128,127] 不同对象范围

    Character  相同对象范围 [0,127]   不同对象范围c>=128

    Long     相同对象范围 [-128,127] 不同对象范围 L<128||L>=128

    (2)Integer的valueOf源码

    来源:CSDN博客

    博文:Java 自动装箱和拆箱

    博主:jackiehff

    网址:http://blog.csdn.net/jackiehff/article/details/8509056

    【1】valueOf工厂方法

       

     public static Integer valueOf(int i) {   
            if(i >= -128 &&i<=IntegerCache.high)   
              //如果i在-128~high之间,就直接在缓存中取出i的Integer类型对象 
              return IntegerCache.cache[i + 128];   
            else 
              return new Integer(i); //否则就在堆内存中创建  
        }   

    【2】IntegerCache内部类

     private static class IntegerCache {//内部类,注意它的属性都是定义为static final 
            static final inthigh; //缓存上界 
            static final Integer cache[];//cache缓存是一个存放Integer类型的数组 
         
            static {//静态语句块 
               final int low = -128;//缓存下界,值不可变 
         
               // high valuemay beconfigured by property 
               int h = 127;// h值,可以通过设置jdk的AutoBoxCacheMax参数调整(参见(3)) 
               if (integerCacheHighPropValue!=null) { 
                   // UseLong.decode here to avoid invoking methods that 
                   // requireInteger's autoboxing cache to be initialized 
                   // 通过解码integerCacheHighPropValue,而得到一个候选的上界值 
                   int i = Long.decode(integerCacheHighPropValue).intValue(); 
                   // 取较大的作为上界,但又不能大于Integer的边界MAX_VALUE 
                   i = Math.max(i, 127);//上界最小为127 
                   // Maximumarray size is Integer.MAX_VALUE 
                   h = Math.min(i, Integer.MAX_VALUE - -low); 
               } 
               high = h; //上界确定,此时high默认一般是127 
               // 创建缓存块,注意缓存数组大小 
               cache =new Integer[(high - low) +1]; 
               int j = low; 
               for(int k = 0; k <cache.length; k++) 
                   cache[k] =new Integer(j++);// -128到high值逐一分配到缓存数组 
           } 
         
            private IntegerCache() {}//构造方法,不需要构造什么 
        } 

    分析:取值范围[-128,127]共享对象,之外创建独立对象

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

    分析:取值范围[-128,127]共享对象,之外创建独立对象

     

    (4)Long的valueOf源码

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

    分析:取值范围[-128,127]共享对象,之外创建独立对象

    (5)Byte的ValueOf源码

    public static Byte valueOf(byte b) {
            final int offset = 128;
            return ByteCache.cache[(int)b +offset];
    }
     
    private static class ByteCache {
            private ByteCache(){}
            static final Byte cache[] =new Byte[-(-128) + 127 + 1];
            static {
                for(int i = 0; i < cache.length;i++)
                    cache[i] =new Byte((byte)(i - 128));
            }
        }


    分析:取值范围[-128,127]共享对象

    备注:基本数据类型byte的取值范围[-128,127]

    (6)Character的valueOf源码

      

     public static Character valueOf(char c) {
            if (c <= 127) {//must cache
                return CharacterCache.cache[(int)c];
            }
            return new Character(c);
    }

    分析:取值范围[0,127]共享对象,之外创建独立对象

    (7)一些测试案例

    《1》案例一

    package wrapper;
     
    public class CharacterTest {
     
        //测试结论: 0-127范围,对象共享;128开始,创建不同的新对象
        public static void main(String[] args) {
     
           Character c1=(char) 128;
           Character c2=(char)128;
           System.out.println(c1==c2);//false
           System.out.println(c1.equals(c2));//true
          
           Character c11=(char) 127;
           Character c12=(char)127;
           System.out.println(c11==c12);//true
           System.out.println(c11.equals(c12));//true
          
           Character c21=(char) 0;
           Character c22=(char)0;
           System.out.println(c21==c22);//true
           System.out.println(c21.equals(c22));//true
          
     
        }
     
    }


    《2》案例二

    package wrapper;
     
    public class ByteTest {
     
        //测试结论:byte取值的范围:-128-127
        //而在byte的范围内的对象都是可以共享的
       
        public static void main(String[] args) {
           //byte最大
           Byte b1=127;
           Byte b2=127;
           System.out.println(b1==b2);//true
           System.out.println(b1.equals(b2));//true
          
           //byte最小
           Byte b11=-128;
           Byte b12=-128;
           System.out.println(b11==b12);
           System.out.println(b11.equals(b12));
          
           //对于超出byte取值范围[-128,127]的,最终都会转为byte范围内的数字,所以一样得到了true的结果
          
    //     Byte b12=128;//报错
           Byte b13=(byte) 128;
           //int(32位)的128强制类型转为byte(8位)型,其中会把多余的24位剔除,从而转换成byte范围的数
           Byte b23=(byte) 128;
           System.out.println(b13==b23);//true
           System.out.println(b13.equals(b23));//true
          
           Byte b21=(byte) -129;
           Byte b22=(byte) -129;
           System.out.println(b21==b22);//true
           System.out.println(b21.equals(b22));//true
          
        }
     
    }


    2.3对于类别【2】Double、Float的valueOf方法的实现是类似的,每次都返回不同的对象】

    (1)Double 的ValueOf源码

       

     public static Double valueOf(double d) {
            returnnew Double(d);
    }

    分析:每次都创建不同的对象

    (2)Float 的ValueOf源码

       

    public static Float valueOf(floatf) {
            return new Float(f);
        }

    分析:每次都创建不同的对象

     

    2.4对于类别【3】Boolean的valueOf方法实现,每次返回的都是同一个对象

    Boolean 的ValueOf源码

      

      public static final Boolean TRUE =new Boolean(true);
        public static final Boolean FALSE =new Boolean(false);
        public static Boolean valueOf(booleanb) {
            return (b ?TRUE : FALSE);
    }

    分析:每次的对象都是同一个,因为那个对象是创建好的常量。

    五、包装类的equals方法

    1、方法结论

    1.1结论

    equals方法为true时,需要满足两个条件:

    1、类型相同  2、内容相同

    1.2源码分析

    (1)Integer的equals源码

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


    (2)Short的equals源码

     

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

    (3)Long的equals源码

      

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

    (4)Character的equals源码

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


    (5)Byte的equals源码

     

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

    (6)Float的equals源码

      

      public boolean equals(Objectobj) {
            return (obj instanceof Float)
                   && (floatToIntBits(((Float)obj).value) ==floatToIntBits(value));
        }

    (7)Double的equals源码

     

       public boolean equals(Objectobj) {
            return (obj instanceof Double)
                   && (doubleToLongBits(((Double)obj).value) ==
                          doubleToLongBits(value));
        }

    (8)Boolean的equals源码

      

      public boolean equals(Objectobj) {
            if (obj instanceof Boolean) {
                returnvalue == ((Boolean)obj).booleanValue();
            }
            return false;
        }

    六、包装类一些结论总结

    1、当一个基础数据类型封装类进行==运算时,会将封装类进行拆箱

    2、+运算时,会将封装类进行拆箱

    3、当封装类与基础类型进行==运行时,封装类会进行拆箱,拆箱结果与基础类型对比值;

    两个封装类进行==运行时,与其它的对象进行==运行一样,对比两个对象的地址,也即判断是否两个引用是否指向同一个对象。

    4、陷阱一:有拆箱操作时一定要特别注意封装类对象是否为null,如果为空,则不能调用对象的任何方法,否则会报错

    5、陷阱二:不同范围数值的对象产生情况不同(详情看:四、包装类装箱之valueOf方法之思)

    该结论来自以下参考文章,如果想了解详细,请看该文

    博文:详解Java的自动装箱与拆箱(Autoboxingand unboxing)

    博主:Mirhunana

    网址:http://blog.csdn.net/hp910315/article/details/48654777

    七、包装类综合实例应用

    package wrapper;
     
    public class Test {
     
        public static void main(String[] args) {
           /*
            * 当 "=="运算符的两个操作数都是包装器类型的引用,则是比较指向的是否是同一个对象,
            * 而如果其中有一个操作数是表达式(即包含算术运算)则比较的是数值(即会触发自动拆箱的过程)。
            * 另外,对于包装器类型,equals方法并不会进行类型转换
            */
            Integer a = 1;
            Integer b = 2;
            Integer c = 3;
            Integer d = 3;
            Integer e = 321;//大于一个字节表示范围(byte:-128-127)
            Integer f = 321;
            Long g = 3L;
            Long h = 2L;
     
     
            //如果装箱的是一个字节,该数据会被共享不会重新开辟空间
            System.out.println(c==d);//true
            System.out.println(e==f);//false 
           
            /*
             * a+b包含了算术运算,因此会触发自动拆箱过程(会调用intValue方法),
             * 因此它们比较的是数值是否相等。
             * 
             * 而对于c.equals(a+b)会先触发自动拆箱过程,再触发自动装箱过程,
             * 也就是说a+b,会先各自调用intValue方法,得到了加法运算后的数值之后,
             * 便调用Integer.valueOf方法,再进行equals比较。同理对于后面的也是这样,
             * 不过要注意倒数第二个和最后一个输出的结果(如果数值是int类型的,
             * 装箱过程调用的是Integer.valueOf;如果是long类型的,装箱调用的Long.valueOf方法)
             */
           
            /*
             * 3=(1+2)
             * a+b包含了算术运算,因此会触发自动拆箱过程(会调用intValue方法),
             * 因此它们比较的是数值是否相等。
             */
            System.out.println(c==(a+b));//true
           
            /*
             * 3.equals(1+2)
             * 先自动拆箱,左边数值为3,右边数值为3;
             * 然后出发自动装箱,装箱过程中调用Integer.valueOf方法,
             * 即:如果装箱的是一个字节,该数据会被共享不会重新开辟空间
             * 过左边和右边是同一个空间的地址,所以相等
             */
            System.out.println(c.equals(a+b));//true
           
    //       System.out.println("3L==(1+2)--"+(3L==(1+2)));
           
            /*
             * 3L==(1+2)
             * a+b包含了算术运算,因此会触发自动拆箱过程(会调用intValue方法),
             * 因此它们比较的是数值是否相等。
             * 左边为3L 右边为3 ,两者的值相等吗?
             * 相等:int与 long进行运算、比较时 int 会自动进行类型提升为 long类型
             *      类型自动提升
             */
            System.out.println(g==(a+b));//true
            /*
             * 3L.equals(1+2)
             * 先自动拆箱,左边数值为3L,右边数值为3;
             * 然后出发自动装箱,装箱过程中左边调用Double.valueOf方法,右边调用Integer.valueOf方法
             * 左边为Long型,右边为Integer型(原因:类型不同,内容相同)
             */
            System.out.println(g.equals(a+b));//false
     
            /*
             * 3L.equals(1+2L)
             * 先自动拆箱,左边数值为3L,右边数值为3L(运算的时候,由于自动类型转换,所以为3L);
             * 然后出发自动装箱,装箱过程中两边都调用Double.valueOf方法
             * 两边数值相等,故相等(类型和内容相同)
             */
            System.out.println(g.equals(a+h));//true
        }
     
    }

    八、参考文章

    1、参考文章一

    来源:CSDN博客

    博文:Java 自动装箱和拆箱

    博主:jackiehff

    网址:http://blog.csdn.net/jackiehff/article/details/8509056

    2、参考文章二

    来源:博客园

    博文:深入剖析Java中的装箱和拆箱

    博主:海 子

    网址:http://www.cnblogs.com/dolphin0520/p/3780005.html

    3、参考文章三

    来源:CSDN博客

    博文:Java自动装箱与拆箱及其陷阱

    博主:JairusChan

    网址:http://blog.csdn.net/jairuschan/article/details/7513045

    4、参考文章四

    来源:CSDN博客

    博文:详解Java的自动装箱与拆箱(Autoboxing and unboxing)

    博主:Mirhunana

    网址:http://blog.csdn.net/hp910315/article/details/48654777

    展开全文
  • Java是面向对象的编程语言,包装类的出现更好的体现这一思想,Java语言提供了八种基本类型。六种数字类型(四个整数型,两个浮点型),一种字符类型,还有一种布尔型。 下面通过本文给大家详细介绍,感兴趣的朋友...
  • Java有八大基本数据类型,相对应的有八种包装类。我们需要对这些基本数据类型进行理解和掌握。 2.Java基本数据类型 Java基本类型共有八种,基本类型可以分为三类,字符类型char,布尔类型boolean以及数值类型byte、...

    1. 前言

    最近在研究Java 基础知识,作为Java最重要的数据类型。Java有八大基本数据类型,相对应的有八种包装类。我们需要对这些基本数据类型进行理解和掌握。

    2.Java基本数据类型

    Java基本类型共有八种,基本类型可以分为三类,字符类型char,布尔类型boolean以及数值类型byte、short、int、long、float、double。数值类型又可以分为整数类型byte、short、int、long和浮点数类型float、double。JAVA中的数值类型不存在无符号的,它们的取值范围是固定的,不会随着机器硬件环境或者操作系统的改变而改变。实际上,JAVA中还存在另外一种基本类型void,它也有对应的包装类 java.lang.Void,不过我们无法直接对它们进行操作。8 中类型表示范围如下:

    • byte:8位,最大存储数据量是255,存放的数据范围是-128~127之间。
    • short:16位,最大数据存储量是65536,数据范围是-32768~32767之间。
    • int:32位,最大数据存储容量是2的32次方减1,数据范围是负的2的31次方到正的2的31次方减1。
    • long:64位,最大数据存储容量是2的64次方减1,数据范围为负的2的63次方到正的2的63次方减1。
    • float:32位,数据范围在3.4e-45~1.4e38,直接赋值时必须在数字后加上f或F。
    • double:64位,数据范围在4.9e-324~1.8e308,赋值时可以加d或D也可以不加。
    • boolean:只有true和false两个取值。
    • char:16位,存储Unicode码,用单引号赋值。

    3. Java包装类

    Java决定了每种简单类型的大小。这些大小并不随着机器结构的变化而变化。这种大小的不可更改正是Java程序具有很强移植能力的原因之一。下表列出了Java中定义的简单类型、占用二进制位数及对应的封装器类。

    简单类型booleanbytecharshortIntlongfloatdoublevoid
    二进制位数18161632643264
    封装类BooleanByteCharacterShortIntegerLongFloatDoubleVoid

    对于数值类型的基本类型的取值范围,我们无需强制去记忆,因为它们的值都已经以常量的形式定义在对应的包装类中了。如:

    • 基本类型byte 二进制位数:Byte.SIZE最小值:Byte.MIN_VALUE最大值:Byte.MAX_VALUE
    • 基本类型short二进制位数:Short.SIZE最小值:Short.MIN_VALUE最大值:Short.MAX_VALUE
    • 基本类型char二进制位数:Character.SIZE最小值:Character.MIN_VALUE最大值:Character.MAX_VALUE
    • 基本类型double 二进制位数:Double.SIZE最小值:Double.MIN_VALUE最大值:Double.MAX_VALUE

    基本类型的优势:数据存储相对简单,运算效率比较高

    包装类的优势:有的容易,比如集合的元素必须是对象类型,满足了java一切皆是对象的思想

    4. 数据类型之间的转换

    4.1 简单类型数据间的转换

    简单类型数据间的转换,有两种方式:自动转换和强制转换,通常发生在表达式中或方法的参数传递时。

    自动转换

    具体地讲,当一个较"小"数据与一个较"大"的数据一起运算时,系统将自动将"小"数据转换成"大"数据,再进行运算。而在方法调用时,实际参数较"小",而被调用的方法的形式参数数据又较"大"时(若有匹配的,当然会直接调用匹配的方法),系统也将自动将"小"数据转换成"大"数据,再进行方法的调用,自然,对于多个同名的重载方法,会转换成最"接近"的"大"数据并进行调用。这些类型由"小"到"大"分别为 (byte,short,char)–int–long–float—double。这里我们所说的"大"与"小",并不是指占用字节的多少,而是指表示值的范围的大小。

    强制转换

    将"大"数据转换为"小"数据时,你可以使用强制类型转换。即你必须采用下面这种语句格式: int n=(int)3.14159/2;可以想象,这种转换肯定可能会导致溢出或精度的下降。

    5. 自动拆箱和自动装箱

    自动装箱

    在Java SE5之前,如果要生成一个数值为10的Integer对象,必须这样进行:

    Integer i = new Integer(10);
    

    但是在Java SE5之后,开始提供了自动装箱的功能,如果要生成一个数值为10的Integer对象,只需要这样就可以了:

    Integer i = 10;
    

    自动拆箱

    顾名思义,跟装箱对应,就是自动将包装器类型转换为基本数据类型:

    Integer i = 10;  //装箱
    int n = i;   //拆箱
    

    简单一点说,装箱就是 自动将基本数据类型转换为包装器类型;拆箱就是 自动将包装器类型转换为基本数据类型。

    下面我们来看这样一个代码:

    public class JVM {
        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;
    
            out.println(c == d);
            out.println(e == f);
            out.println(c == (a+b));
            out.println(c.equals(a+b));
            out.println(g == (a+b));
            out.println(g.equals(a+b));
        }
    }
    

    执行结果:

    true
    false
    true
    true
    true
    false
    

    首先我们知道包装类的数据:

    包装类数据,如Integer, String, Double,Long等将相应的基本数据类型包装起来的类。这些类数据全部存在于堆中。

    下面我再分析一下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);
        }
    }
    

    从源码中我们可以看出Long包装类从类被加载的时候开始,就已经把-128到127之间的Long数据缓存到一个Long[]数组中去了,从JVM内存模型的角度来看。Long包装类已经把-128到127之间的Long数据生成得到java堆中。

    总结:

    1. 包装类的“==”运算在不遇到算术运算的情况下不会自动拆箱,equals()方法不处理数据转型的关系。
    2. 在自动装箱时,把int变成Integer的时候,是有规则的,当你的int的值在-128-IntegerCache.high(127) 时,返回的不是一个新new出来的Integer对象,而是一个已经缓存在堆中的Integer对象,(我们可以这样理解,系统已经把-128到127之 间的Integer缓存到一个Integer数组中去了,如果你要把一个int变成一个Integer对象,首先去缓存中找,找到的话直接返回引用给你就 行了,不必再新new一个),如果不在-128-IntegerCache.high(127) 时会返回一个新new出来的Integer对象。

    所以在e==f时,由于321没有在堆中缓存。所以堆中会创建两个Integer对象,并且这两个对象的值都是321。然后由e和f两个引用指向这两个对象。所以e==f返回false(因为它们两个引用指向的是两个对象)。c==d是因为在堆中已经缓存了-128L到127L的值的Long对象,所以c和d两个引用指向的是同一个对象。c==(a+b):由于a+b是一个操作运算,所以包装类会执行自动拆箱成两个基本数据类型进行运算,返回3. 然后c==3。 "=="运算遇到算式运算时会进行自动拆箱,c自动拆箱成基本数据类型进行比较,返回true。

    最后我来解释一下最后两个的运行结果为什么是true与false,先来看一下后两句话在进行编译之后在.class文件中的样子吧:

    System.out.println(g.longValue() == (long)(a.intValue() + b.intValue()));
    System.out.println(g.equals(Integer.valueOf(a.intValue() + b.intValue())));
    

    我们可以看到编译器对out.println(g == (a+b));进行编译的时候,进行了拆箱与向上转型的操作,所以此时比较的仅仅是两个变量的字面值,与基本数据类型的比较是一样的,所以是true,而最后仍然比较的是对象中的数据并且对a没有进行向上转型,Long中存在的数据肯定就和Integer中存在的数据不等了,所以为false。

    重要:我们能将字面值直接赋给Integer类是因为Java语法的存在,实际上Integer a = 1在经过编译之后是这样的:Integer a = new Integer(1),语法糖帮助我们简化了语法。

    展开全文
  • java基本数据类型包装类

    千次阅读 2013-08-12 09:59:48
    但是Java中的基本数据类型却是不面向对象的,这在实际使用时存在很多的不便,为了解决这个不足,在设计类时为每个基本数据类型设计了一个对应的类进行代表,这样八个和基本数据类型对应的类统称为包装类(Wrapper ...
    Java语言是一个面向对象的语言,但是Java中的基本数据类型却是不面向对象的,这在实际使用时存在很多的不便,为了解决这个不足,在设计类时为每个基本数据类型设计了一个对应的类进行代表,这样八个和基本数据类型对应的类统称为包装类(Wrapper Class),有些地方也翻译为外覆类或数据类型类。


    包装类均位于java.lang包,包装类和基本数据类型的对应关系如下表所示:


    基本数据类型 相应包装类
     byte Byte


    boolean Boolean

     
    short Short
     
    char Character
     
    int Integer
     
    long Long
     
    float Float
     
    double Double
     
       在这八个类名中,除了Integer和Character类以后,其它六个类的类名和基本数据类型一直,只是类名的第一个字母大写即可。


          对于包装类说,这些类的用途主要包含两种:
    a、作为和基本数据类型对应的类类型存在,方便涉及到对象的操作。

    b、包含每种基本数据类型的相关属性如最大值、最小值等,以及相关的操作方法。

    由于八个包装类的使用比较类似,下面以最常用的Integer类为例子介绍包装类的实际使用。


    1、实现int和Integer类之间的转换
         在实际转换时,使用Integer类的构造方法和Integer类内部的intValue方法实现这些类型之间的相互转换,实现的代码如下:

                       int n = 10;

                       Integer in = new Integer(100);


                   //将int类型转换为Integer类型

                       Integer in1 = new Integer(n);

                       //将Integer类型的对象转换为int类型

                       int m = in.intValue();
     
     2、Integer类内部的常用方法



        在Integer类内部包含了一些和int操作有关的方法,下面介绍一些比较常用的方法:
      a、parseInt方法
      public static int parseInt(String s)
           该方法的作用是将数字字符串转换为int数值。在以后的界面编程中,将字符串转换为对应的int数字是一种比较常见的操作。使用示例如下:

       String s = “123”;
        int n = Integer.parseInt(s);
     
        则int变量n的值是123,该方法实际上实现了字符串和int之间的转换,如果字符串都包含的不是都是数字字符,则程序执行将出现异常。(说明:异常的概念将在下一章进行讲述)

        另外一个parseInt方法:
       public static int parseInt(String s, int radix) 

        则实现将字符串按照参数radix指定的进制转换为int,使用示例如下:

             //将字符串”120”按照十进制转换为int,则结果为120

            int n = Integer.parseInt(“120”,10); 


             //将字符串”12”按照十六进制转换为int,则结果为18

             int n = Integer.parseInt(“12”,16);

             //将字符串”ff”按照十六进制转换为int,则结果为255

             int n = Integer.parseInt(“ff”,16);
     
        这样可以实现更灵活的转换。


        b、toString方法

        public static String toString(int i)

        该方法的作用是将int类型转换为对应的String类型。


        使用示例代码如下:

        int m = 1000;
        String s = Integer.toString(m);
     
        则字符串s的值是“1000”。

        另外一个toString方法则实现将int值转换为特定进制的字符串:
        public static int parseInt(String s, int radix) 



        使用示例代码如下:

        int m = 20;
        String s = Integer.toString(m);
     
        则字符串s的值是“14”。

    三.常用的方法还有:

      十进制转成其他进制:

        toBinaryString(int i) : 以二进制(基数 2)无符号整数形式返回一个整数参数的字符串表示形式。

        toOctalString(int i) : 八进制

        toHexString(int i ) ; 十六进制。

      其他进制转换成十进制:



    展开全文
  • 61. 基本数据类型优于包装类 Java 有一个由两部分组成的类型系统,包括基本类型(如 int、double 和 boolean)和引用类型(如 String 和 List)。每个基本类型都有一个对应的引用类型,称为包装类型。与 int、double...
  • java基本数据类型都有一个对应包装类,所对应的类都有哪些对应的常用方法
  • JAVA基本数据类型及其对应包装类

    万次阅读 2018-09-10 17:18:13
    一、JAVA中的八种基本类型 1、数字类型(6种)  ①byte:  占的位数:byte数据类型占八位;  最小值为:-128(-2^7);  最大值为:127(2^7-1);  默认值为:0;  作用:byte数据类型主要用于在大型...
  • 1、为了对基本数据类型进行更多的操作,Java针对每一种基本数据类型提供了对应的类类型:包装类类型。  byte   Byte  short  Short  int   &amp;amp;amp;nbsp;Integer  long   long  float   &...
  •  - 基本数据类型包装类(Wrapper class)  - 字符串相关类  - 时间处理类  - Math类  - File类 先从基本数据类型包装类开始学习。  基本数据类型包装类  为什么需要包装类? ...
  • java八种基本数据类型包装类详解

    万次阅读 多人点赞 2018-12-20 10:14:40
    java八种基本数据类型分为四类八种,四类分别为整型、浮点型、布尔型、字符型;八种分别为byte、short、int、long、float、double、boolean、char; java八种基本数据类型的字节数:分别为1、2、4、8个字节;1字节...
  • 基本数据类型不具有对象的特性,当有些地方必须要使用对象的时候,例如集合类(List,Set等),基本数据类型就不能使用了,所以Java提供了包装类基本数据类型可以进行加减乘除等运算,而包装类提供了很多实用的...
  • 字符串与其他数据类型之间的转换
  • 一、java中八种基本数据类型对应的包装类型:   原始类型 包装类 原始类型所占的字节数  short Short 2个字节  int Integer 4个字节  long Long 8个字节  float Float 4个字节  double Do
  • Java 八大基本数据类型以及包装类

    千次阅读 2018-08-10 10:54:09
    一、java中八种基本数据类型对应的包装类型: 原始类型 包装类 原始类型所占的字节数 short Short 2个字节 int Integer 4个字节 long Long 8个字节 float Float 4个字节 double Double ...
  • 它们所对应包装类均在java.lang包中,分别是Short,Integer,Long,Float,Double,Boolean,Character。 当有的地方必须要使用对象或引用数据类型的时候,例如集合类(List,Set等),基本数据类型就不能使用了,因为
  • 深入Java基础(一)——基本数据类型及其包装类

    万次阅读 多人点赞 2016-12-21 22:18:34
    这一系列打算慢慢地去接触源码,并且列出相关的题目,对于完全的初学者的话,我到时候会搜一套我认为比较好的培训机构的视频以及给些...2.数据类型包装类理解(含源码解析);3.数据类型转换、装包拆包等一些小坑。
  • Java数据类型包装类

    万次阅读 多人点赞 2020-12-16 16:16:27
    1. 为什么需要包装类JAVA是面向对象的语言,很多类和方法中的参数都需使用对象(例如集合),但基本数据类型却不是面向对象的,这就造成了很多不便 2. 拆装箱的概念:将基本数据类型转为包装类的过程叫装箱,将包装...
  • J2SE入门(二) JAVA基本类型数据类型包装类及自动拆装箱 我们知道基本数据类型包括byte, short, int, long, float, double, char, boolean,对应包装类分别是Byte, Short, Integer, Long, Float, Double, ...
  • java--基本数据类型对应包装类 基本数据类型 包装类 boolean
  • int我们肯定都熟悉吧,是Java当中的一个基本数据类型,这跟C语言当中的int也一样,对于Integer呢,我们或多或少也知道一点,Integer是Java当中的包装类,说白了它就是一个类。   我们首先来回顾以下Java当中的八大...
  • 基本数据类型包装类

    千次阅读 2018-12-29 22:35:08
    基本数据类型 Number类 缓存区间 包装类的共性 数据类型转换 基本数据类型 序号 类型名称 默认值 大小 最小值 最大值 包装类 缓冲区间 1 boolean false 1B 0(false) 1...
  • java的8种基本数据类型对应包装类 整数类型:byte(Byte) -128~127、short(Short)、int(Integer)、long(Long) 浮点类型:float(Float)、double(Double) 字符:char(Character) 布尔:boolean(Boolean,true、...
  • Java基本数据类型包装类

    千次阅读 2015-03-25 14:52:35
    Java 中的数据类型分为 1. 基本类型(原始数据类型) byte short int long float double char boolean 基本类型的变量持有原始值。 2. 符合数据类型(引用类型),引用类型持有引用值(即对某个对象的引用,而...
  • Java中的8种基本数据类型及其包装类 1、8种基本数据类型基本知识 对于上图的注意事项: 1、java八种基本数据类型分为四类八种,四类分别为整型、浮点型、布尔型、字符型;八种分别为byte、short、int、long、float、...
  • 八大基本数据类型均有对应包装类 byte、short、int、long、float、double、char、boolean分别对应Byte、Short、Integer、Long、Float、Double、Character、Boolean 包装类型的出现是为了方便基本数据类型能够和...
  • java基本类型包装类

    千次阅读 2015-05-03 18:50:20
    java中一切皆是对象,但是准确的说java中的8种基本数据类型不属于对象(因为它们没有属性和方法)。java在提供了基本类型的包装类。...代码如下: //JDK 1.5之前 基本类型和对应包装类之间的转换方式
  • 为了解决这个不足,Java 在设计类时为每个基本数据类型设计了一个对应的类进行代表,这样八个和基本数据类型对应的类统称为包装类(Wrapper Class)。 包装类均位于 java.lang 包,八种包装类基本数据类型的对应关系...
  • 8个基本数据类型包装类

    千次阅读 2017-02-20 15:03:55
    我们知道,java提供的8种基本数据类型并不支持面向对象的编程机制,不具备“对象“的特性,没有成员变量、方法可以被调用。java之所以提供这8种基本数据类型,主要是为了照顾程序员的传统习惯。 这8种基本数据类型...
  • java基本类型包装类

    万次阅读 多人点赞 2020-12-14 08:38:00
    1. 基本类型包装类概述为了方便操作基本数据类型值,将其封装成了对象,在对象中定义了属性和行为丰富了该数据的操作。用于描述该对象的类就称为基本数据类型对象包装类。将基本数据类型封装成对象...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 115,242
精华内容 46,096
关键字:

java基本数据类型对应的包装类

java 订阅