精华内容
下载资源
问答
  • java装箱和拆箱

    2017-05-31 10:19:00
    java装箱和拆箱 Java 提供两种不同的类型:引用类型原始类型(或内置类型)。Int是java的原始数据类型,Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。 原始类型封装类:...

    java装箱和拆箱

    Java 提供两种不同的类型:引用类型和原始类型(或内置类型)。Int是java的原始数据类型,Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。


    原始类型封装类:
    boolean  Boolean
    char  Character
    byte  Byte
    short   Short
    intInte  ger
    long  Long
    float  Float
    double  Double

    引用类型和原始类型的行为完全不同,并且它们具有不同的语义。引用类型和原始类型具有不同的特征和用法,它们包括:大小和速度问题,这种类型以哪种类型的数据结构存储,当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null,而原始类型实例变量的缺省值与它们的类型有关。

    public class AutZhun {
        /**
         * 测试自动装箱,自动拆箱
         * 
         * @author clc
         * @param args
         */
        public static void main(String[] args) {
            test();
        }
        static void test() {
            Integer a = new Integer(1234);
            Integer a1 = 890;// jdk5.0之后 . 自动装箱,编译器帮我们改进代码:Integer a1 = new
                                // Integer(1000);
            int b = a1.intValue();
            System.out.println(b);
            int b1 = a1; // 自动拆箱,编译器改进:b.intValue();
            Integer a2 = null;
            // int c=a2;//空指针异常;
            System.out
                    .println("---------------------------------------------------------------------------");
            Integer q1 = 1234;
            Integer q2 = 1234;
            System.out.println(q1 == q2);
            System.out.println(q1.equals(q2));
            System.out
                    .println("------------------------------------------------------------------------------");
            // [-128,127]之间的数,仍然当做基本数据类型来处理。
            Integer q3 = 123;
            Integer q4 = 123;
            System.out.println(q3 == q4);
            System.out.println(q3.equals(q4));
        }
    }

     

    posted @ 2017-05-31 10:19 路迢迢 阅读(...) 评论(...) 编辑 收藏
    展开全文
  • java 装箱和拆箱

    2017-02-21 11:20:00
    深入剖析Java中的装箱和拆箱  自动装箱和拆箱问题是Java中一个老生常谈的问题了,今天我们就来一些看一下装箱和拆箱中的若干问题。本文先讲述装箱和拆箱最基本的东西,再来看一下面试笔试中经常遇到的与装箱拆箱...

    深入剖析Java中的装箱和拆箱

      自动装箱和拆箱问题是Java中一个老生常谈的问题了,今天我们就来一些看一下装箱和拆箱中的若干问题。本文先讲述装箱和拆箱最基本的东西,再来看一下面试笔试中经常遇到的与装箱、拆箱相关的问题。

      以下是本文的目录大纲:

      一.什么是装箱?什么是拆箱?

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

      三.面试中相关的问题

      若有不正之处,请谅解和批评指正,不胜感激。

      请尊重作者劳动成果,转载请标明原文链接:

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

    一.什么是装箱?什么是拆箱?

      在前面的文章中提到,Java为每种基本数据类型都提供了对应的包装器类型,至于为什么会为每种基本数据类型提供包装器类型在此不进行阐述,有兴趣的朋友可以查阅相关资料。在Java SE5之前,如果要生成一个数值为10的Integer对象,必须这样进行:

    1

    Integer i = new Integer(10);

      而在从Java SE5开始就提供了自动装箱的特性,如果要生成一个数值为10的Integer对象,只需要这样就可以了:

    1

    Integer i = 10;

      这个过程中会自动根据数值创建对应的 Integer对象,这就是装箱。

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

    1

    2

    Integer i = 10;  //装箱

    int n = i;   //拆箱

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

      下表是基本数据类型对应的包装器类型:

    int(4字节) Integer
    byte(1字节) Byte
    short(2字节) Short
    long(8字节) Long
    float(4字节) Float
    double(8字节) Double
    char(2字节) Character
    boolean(未定) Boolean

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

      上一小节了解装箱的基本概念之后,这一小节来了解一下装箱和拆箱是如何实现的。

      我们就以Interger类为例,下面看一段代码:

    1

    2

    3

    4

    5

    6

    7

    public class Main {

        public static void main(String[] args) {

             

            Integer i = 10;

            int n = i;

        }

    }

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

      

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

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

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

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

    三.面试中相关的问题

      虽然大多数人对装箱和拆箱的概念都清楚,但是在面试和笔试中遇到了与装箱和拆箱的问题却不一定会答得上来。下面列举一些常见的与装箱/拆箱有关的面试题。

    1.下面这段代码的输出结果是什么?

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

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

        }

    }

      也许有些朋友会说都会输出false,或者也有朋友会说都会输出true。但是事实上输出结果是:

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

      而其中IntegerCache类的实现为:

    复制代码

    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.下面这段代码的输出结果是什么?

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

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

        }

    }

      也许有的朋友会认为跟上面一道题目的输出结果相同,但是事实上却不是。实际输出结果为:

    View Code

      至于具体为什么,读者可以去查看Double类的valueOf的实现。

      在这里只解释一下为什么Double类的valueOf方法会采用与Integer类的valueOf方法不同的实现。很简单:在某个范围内的整型数值的个数是有限的,而浮点数却不是。

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

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

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

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

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

        }

    }

      输出结果是:

    View Code

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

    View Code

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

    View Code

      至此,大家应该明白了为何上面输出的结果都是true了。

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

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

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

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

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

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

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

        }

    }

      先别看输出结果,读者自己想一下这段代码的输出结果是什么。这里面需要注意的是:当 "=="运算符的两个操作数都是 包装器类型的引用,则是比较指向的是否是同一个对象,而如果其中有一个操作数是表达式(即包含算术运算)则比较的是数值(即会触发自动拆箱的过程)。另外,对于包装器类型,equals方法并不会进行类型转换。明白了这2点之后,上面的输出结果便一目了然:

    View Code

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

    如果对上面的具体执行过程有疑问,可以尝试获取反编译的字节码内容进行查看。

      如果有哪位朋友有补充的内容,欢迎下方留言,不胜感激。

    转载于:https://my.oschina.net/u/3054960/blog/842673

    展开全文
  • Java装箱和拆箱

    2018-09-03 11:14:24
    自动装箱就是Java自动将原始类型值转换成对应的对象,比如将int的变量转换成Integer对象,这个过程叫做装箱,反之将Integer对象转换成int类型值,这个过程叫做拆箱。因为这里的装箱和拆箱是自动进行的非人为转换,...

    什么是自动装箱和拆箱

    自动装箱就是Java自动将原始类型值转换成对应的对象,比如将int的变量转换成Integer对象,这个过程叫做装箱,反之将Integer对象转换成int类型值,这个过程叫做拆箱。因为这里的装箱和拆箱是自动进行的非人为转换,所以就称作为自动装箱和拆箱。原始类型byte,short,char,int,long,float,double和boolean对应的封装类为Byte,Short,Character,Integer,Long,Float,Double,Boolean。

    自动装箱拆箱要点

    • 自动装箱时编译器调用valueOf将原始类型值转换成对象,同时自动拆箱时,编译器通过调用类似intValue(),doubleValue()这类的方法将对象转换成原始类型值。
    • 自动装箱是将boolean值转换成Boolean对象,byte值转换成Byte对象,char转换成Character对象,float值转换成Float对象,int转换成Integer,long转换成Long,short转换成Short,自动拆箱则是相反的操作。

    何时发生自动装箱和拆箱

    自动装箱和拆箱在Java中很常见,比如我们有一个方法,接受一个对象类型的参数,如果我们传递一个原始类型值,那么Java会自动讲这个原始类型值转换成与之对应的对象。最经典的一个场景就是当我们向ArrayList这样的容器中增加原始类型数据时或者是创建一个参数化的类,比如下面的ThreadLocal。

    1

    2

    3

    4

    5

    6

    7

    8

    9

    ArrayList<Integer> intList = new ArrayList<Integer>();

    intList.add(1); //autoboxing - primitive to object

    intList.add(2); //autoboxing

     

    ThreadLocal<Integer> intLocal = new ThreadLocal<Integer>();

    intLocal.set(4); //autoboxing

     

    int number = intList.get(0); // unboxing

    int local = intLocal.get(); // unboxing in Java

    举例说明

    上面的部分我们介绍了自动装箱和拆箱以及它们何时发生,我们知道了自动装箱主要发生在两种情况,一种是赋值时,另一种是在方法调用的时候。为了更好地理解这两种情况,我们举例进行说明。

    赋值时

    这是最常见的一种情况,在Java 1.5以前我们需要手动地进行转换才行,而现在所有的转换都是由编译器来完成。

    1

    2

    3

    4

    5

    6

    7

    //before autoboxing

    Integer iObject = Integer.valueOf(3);

    Int iPrimitive = iObject.intValue()

     

    //after java5

    Integer iObject = 3; //autobxing - primitive to wrapper conversion

    int iPrimitive = iObject; //unboxing - object to primitive conversion

    方法调用时

    这是另一个常用的情况,当我们在方法调用时,我们可以传入原始数据值或者对象,同样编译器会帮我们进行转换。

    1

    2

    3

    4

    5

    6

    7

    8

    public static Integer show(Integer iParam){

       System.out.println("autoboxing example - method invocation i: " + iParam);

       return iParam;

    }

     

    //autoboxing and unboxing in method invocation

    show(3); //autoboxing

    int result = show(3); //unboxing because return type of method is Integer

    show方法接受Integer对象作为参数,当调用show(3)时,会将int值转换成对应的Integer对象,这就是所谓的自动装箱,show方法返回Integer对象,而int result = show(3);中result为int类型,所以这时候发生自动拆箱操作,将show方法的返回的Integer对象转换成int值。

    自动装箱的弊端

    自动装箱有一个问题,那就是在一个循环中进行自动装箱操作的情况,如下面的例子就会创建多余的对象,影响程序的性能。

    1

    2

    3

    4

    Integer sum = 0;

     for(int i=1000; i<5000; i++){

       sum+=i;

    }

    上面的代码sum+=i可以看成sum = sum + i,但是+这个操作符不适用于Integer对象,首先sum进行自动拆箱操作,进行数值相加操作,最后发生自动装箱操作转换成Integer对象。其内部变化如下

    1

    2

    sum = sum.intValue() + i;

    Integer sum = new Integer(result);

    由于我们这里声明的sum为Integer类型,在上面的循环中会创建将近4000个无用的Integer对象,在这样庞大的循环中,会降低程序的性能并且加重了垃圾回收的工作量。因此在我们编程时,需要注意到这一点,正确地声明变量类型,避免因为自动装箱引起的性能问题。

    重载与自动装箱

    当重载遇上自动装箱时,情况会比较有些复杂,可能会让人产生有些困惑。在1.5之前,value(int)和value(Integer)是完全不相同的方法,开发者不会因为传入是int还是Integer调用哪个方法困惑,但是由于自动装箱和拆箱的引入,处理重载方法时稍微有点复杂。一个典型的例子就是ArrayList的remove方法,它有remove(index)remove(Object)两种重载,我们可能会有一点小小的困惑,其实这种困惑是可以验证并解开的,通过下面的例子我们可以看到,当出现这种情况时,不会发生自动装箱操作。

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    public void test(int num){

        System.out.println("method with primitive argument");

     

    }

     

    public void test(Integer num){

        System.out.println("method with wrapper argument");

     

    }

     

    //calling overloaded method

    AutoboxingTest autoTest = new AutoboxingTest();

    int value = 3;

    autoTest.test(value); //no autoboxing

    Integer iValue = value;

    autoTest.test(iValue); //no autoboxing

     

    Output:

    method with primitive argument

    method with wrapper argument

    要注意的事项

    自动装箱和拆箱可以使代码变得简洁,但是其也存在一些问题和极端情况下的问题,以下几点需要我们加强注意。

    对象相等比较

    这是一个比较容易出错的地方,”==“可以用于原始值进行比较,也可以用于对象进行比较,当用于对象与对象之间比较时,比较的不是对象代表的值,而是检查两个对象是否是同一对象,这个比较过程中没有自动装箱发生。进行对象值比较不应该使用”==“,而应该使用对象对应的equals方法。看一个能说明问题的例子。

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    public class AutoboxingTest {

     

        public static void main(String args[]) {

     

            // Example 1: == comparison pure primitive – no autoboxing

            int i1 = 1;

            int i2 = 1;

            System.out.println("i1==i2 : " + (i1 == i2)); // true

     

            // Example 2: equality operator mixing object and primitive

            Integer num1 = 1; // autoboxing

            int num2 = 1;

            System.out.println("num1 == num2 : " + (num1 == num2)); // true

     

            // Example 3: special case - arises due to autoboxing in Java

            Integer obj1 = 1; // autoboxing will call Integer.valueOf()

            Integer obj2 = 1; // same call to Integer.valueOf() will return same

                                // cached Object

     

            System.out.println("obj1 == obj2 : " + (obj1 == obj2)); // true

     

            // Example 4: equality operator - pure object comparison

            Integer one = new Integer(1); // no autoboxing

            Integer anotherOne = new Integer(1);

            System.out.println("one == anotherOne : " + (one == anotherOne)); // false

     

        }

     

    }

     

    Output:

    i1==i2 : true

    num1 == num2 : true

    obj1 == obj2 : true

    one == anotherOne : false

    值得注意的是第三个小例子,这是一种极端情况。obj1和obj2的初始化都发生了自动装箱操作。但是处于节省内存的考虑,JVM会缓存-128到127的Integer对象。因为obj1和obj2实际上是同一个对象。所以使用”==“比较返回true。

    容易混乱的对象和原始数据值

    另一个需要避免的问题就是混乱使用对象和原始数据值,一个具体的例子就是当我们在一个原始数据值与一个对象进行比较时,如果这个对象没有进行初始化或者为Null,在自动拆箱过程中obj.xxxValue,会抛出NullPointerException,如下面的代码

    1

    2

    3

    4

    5

    6

    private static Integer count;

     

    //NullPointerException on unboxing

    if( count <= 0){

      System.out.println("Count is not started yet");

    }

    缓存的对象

    这个问题就是我们上面提到的极端情况,在Java中,会对-128到127的Integer对象进行缓存,当创建新的Integer对象时,如果符合这个这个范围,并且已有存在的相同值的对象,则返回这个对象,否则创建新的Integer对象。

    在Java中另一个节省内存的例子就是字符串常量池,感兴趣的同学可以了解一下。

    生成无用对象增加GC压力

    因为自动装箱会隐式地创建对象,像前面提到的那样,如果在一个循环体中,会创建无用的中间对象,这样会增加GC压力,拉低程序的性能。所以在写循环时一定要注意代码,避免引入不必要的自动装箱操作。

    如想了解垃圾回收和内存优化,可以查看本文Google IO:Android内存管理主题演讲记录

    总的来说,自动装箱和拆箱着实为开发者带来了很大的方便,但是在使用时也是需要格外留意,避免引起出现文章提到的问题


    要理解装箱和拆箱的概念,就要理解Java数据类型

    装箱:把基本类型用它们相应的引用类型包装起来,使其具有对象的性质。int包装成Integer、float包装成Float

    拆箱:和装箱相反,将引用类型的对象简化成值类型的数据

    Integer a = 100;                  这是自动装箱  (编译器调用的是static Integer valueOf(int i))
    int     b = new Integer(100); 这是自动拆箱

    展开全文
  • Java 装箱和拆箱

    2015-06-29 17:12:27
    Java中的包装类 装箱和拆箱java中,数据类型总共可分为两大种,基本数据类型(值类型)类类型(引用数据类型)。基本类型的数据不是对象,不能作为对象调用其toString()、hashCode()、getClass()、equals()...
    Java中的包装类 装箱和拆箱
    在java中,数据类型总共可分为两大种,基本数据类型(值类型)和类类型(引用数据类型)。基本类型的数据不是对象,不能作为对象调用其toString()、hashCode()、getClass()、equals()等等方法。
     所以在java中,针对8种基本数据类型,提供了针对每个基本数据类型的包装类。如下:
    INDEX 基本数据类型 包装类
    1 int Integer
    2 char Character
    3 float Float
    4 double Double
    5 byte Byte
    6 short Short
    7 long Long
    8 boolean Boolean
    所谓装箱,就是把基本类型用它们相对应的引用类型包起来,使它们可以具有对象的特质,如我们可以把int型包装成Integer类的对象,或者把double包装成Double,等等。
     所谓拆箱,就是跟装箱的方向相反,将Integer及Double这样的引用类型的对象重新简化为值类型的数据。
     //JDK1.5 之前使用手动方式进行装箱 和拆箱的 操作
    public class IntegerDemo
    {
    public static void main (String []agrs)
    {
    int i=10;
    Integer j=new Integer(i); //手动装箱操作
    int i1=j.intValue();//手动拆箱操作
    System.out.println(i1*i1);
    }
    }; //output:100

    //JDK1.5之后可自动进行的装箱和拆箱的操作,比较方便
    public class IntegerDemo02
    {
    public static void main (String []agrs)
    {
    int i=10
    Integer j=i;
    int k=j;
    System.out.println(++k);
    }
    }; //output:11
     
    包装类的另外一个比较有用的是可以将String 字符串类型转换为相应的基本数据类型。下面以将String转为int为例:
    public class IntegerDemo04
    {
    public static void main (String[] args)
    {
    String str="1500";
    try
    {
    int i=Integer.parseInt(str);
    System.out.println(++i);
    }
    catch (Exception e)
    {
    e.printStackTrace(); //打印异常信息
    }
    }
    };// output: 1501
     如果在上述方法中str="15er00";则在调用parseInt方法时候会产生NumberFormatException异常,见JDK API中对该方法的描述:
    public static int parseInt(String s) throws NumberFormatException

    将字符串参数作为有符号的十进制整数进行解析。除了第一个字符可以是用来表示负值的 ASCII 减号 '-' ('\u002D') 外,字符串中的字符都必须是十进制数字。返回得到的整数值,就好像将该参数和基数 10 作为参数赋予 parseInt(java.lang.String, int) 方法一样。 

    参数:
    s - 包含要解析的 int 表示形式的 String。 
    返回:
    用十进制参数表示的整数值。 
    抛出: 
    NumberFormatException - 如果字符串不包含可解析的整数。
      总结在包装类中将String转换为包装类所对应的基本数据类型的方法如下,所有的方法都将抛出NumberFormatException异常,需要在调用时候使用try ..catch 进行捕获
     
    index 包装类 返回的基本数据类型 方法名
    1 Integer int static int Integer.parseInt(Sting s)
    2 Character char static char Character.parseChar(String s)
    3 Float float static float Float.parseFloat(String s)
    4 Dobule double static double Double.parseDouble(String s)
    5 Byte byte static byte Byte.parseByte(String s)
    6 Short short static short Short.parseShort(String s)
    7 Long long static long Long.parseLong(String s)
    8 Boolean boolean static boolean Boolean.parseBoolean(String s)
     
    类似的一个方法为 parseXXX(String s,int radix),对于Integer包装类,这个radix表示进制. parseInt(String s)默认为十进制。 其他包装类的radix参数意义,请参见API文档
    展开全文
  • 直解Java装箱和拆箱

    2020-12-09 23:11:49
    Java装箱和拆箱 什么是装箱和拆箱 首先要清楚Java为8种基本类型都提供了对应的包装类 装箱和拆箱是Java5提供的特性,装箱简单来说就是直接将基本类型转换为包装类,拆箱简单来说就是直接将包装类转换为基本类型,举个...
  • Java装箱和拆箱详解

    千次阅读 多人点赞 2018-07-12 17:47:10
    Java装箱和拆箱详解 题外话 今天早上在学习公司代码,然后准备学习下MVP框架,于是找了个简单的MVP框架例子,结果在框架中,发现了一个类叫SparseArray的类,秉持着一种遇到问题就深究下去的精神,我就转去看...
  • Java 装箱拆箱 128陷阱问题装箱与拆箱概念小例子Java中需要装箱拆箱的类型128陷阱额外小记:拆箱时的空指针错误 装箱与拆箱 概念 装箱:在程序设计中,值类型实例到对象的转换,它暗示在运行时实例将携带完整的...
  • 关于java装箱和拆箱

    2020-11-18 19:47:23
    关于java装箱和拆箱 转载http://www.cnblogs.com/dolphin0520/p/3780005.html Integer a = 100 ==> Integer a = Integer.valueof(100) int n = a ==> n = Integer.intvalue(a) 变为数值 Java 基本类型的...
  • JAVA装箱和拆箱 从Java SE5开始就提供了自动装箱的特性,如果要生成一个数值为10的Integer对象,只需要这样就可以了。原文链接: http://www.cnblogs.com/dolphin0520/p/3780005.htmlInteger i = 10; //装箱int n ...
  • Java装箱和拆箱的基本概念及使用

    千次阅读 2014-04-02 11:54:05
    Java装箱和拆箱的基本概念及使用 要理解装箱和拆箱的概念,就要理解Java数据类型 装箱:把基本类型用它们相应的引用类型包装起来,使其具有对象的性质。int包装成Integer、float包装成Float 拆箱装箱相反...
  • 文章目录001、基本类型010、装箱011、拆箱100、用途 001、基本类型 在java中有八种基本数据类型对应每种基本类型又有八种包装类型: 基本类型:boolean, char, int, byte,short,long, float,double 包装器...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 41,017
精华内容 16,406
关键字:

java的装箱和拆箱

java 订阅