精华内容
下载资源
问答
  • Java 包装类

    千次阅读 2021-03-08 05:57:02
    1、Java 包装类Java有8种基本数据类型:整型(byte、short、int、long)、浮点型(float、double)、布尔型boolean、字符型char,相对应地,Java提供了8种包装类Byte、Short、Integer、Long、Float、Double、Boolean、...

    1、Java 包装类

    Java有8种基本数据类型:整型(byte、short、int、long)、浮点型(float、double)、布尔型boolean、字符型char,相对应地,Java提供了8种包装类Byte、Short、Integer、Long、Float、Double、Boolean、Character。包装类创建对象的方式就跟其他类一样。包装类提供了一种使用原始数据类型作为对象的方法。

    下表是原始类型和对应的包装类:原始数据类型包装类

    byteByte

    shortShort

    intInteger

    longLong

    floatFloat

    doubleDouble

    booleanBoolean

    charCharacter

    有时必须使用包装类,例如,在使用Collection对象时,例如,作为ArrayList,其中不能使用基本类型(列表只能存储对象):

    例如:ArrayList myNumbers = new ArrayList(); // 报错ArrayList myNumbers = new ArrayList(); // 正常创建方法

    2、创建包装类对象

    要创建包装类对象,需要使用包装类而不是原始类型。要获取值,可以只打印输出对象:

    例如:public class Main {

    public static void main(String[] args) {

    Integer myInt = 8;

    Double myDouble = 8.99;

    Character myChar = 'A';

    System.out.println(myInt);

    System.out.println(myDouble);

    System.out.println(myChar);

    }

    }

    由于使用的是包装类对象,因此可以使用某些方法来获取有关特定对象的信息。

    例如,以下方法用于获取与

    相应的包装对象:intValue(),byteValue(),shortValue(),longValue(),floatValue(),doubleValue(),charValue(),booleanValue()。

    下面示例将输出与以上示例相同的结果:

    例如:public class Main {

    public static void main(String[] args) {

    Integer myInt = 2;

    Double myDouble = 9.99;

    Character myChar = 'A';

    System.out.println(myInt.intValue());

    System.out.println(myDouble.doubleValue());

    System.out.println(myChar.charValue());

    }

    }

    另一个有用的方法是toString()方法,该方法用于将包装器对象转换为字符串。

    在下面的示例中,我们将Integer转换为String,并使用String对象的length()方法输出字符串的长度:

    例如:public class Main {

    public static void main(String[] args) {

    Integer myInt = 100;

    String myString = myInt.toString();

    System.out.println(myString.length());

    }

    }

    3、装箱和拆箱

    基本数据类型转换为包装类的过程称为装箱,例如把 int 包装成 Integer 类的对象;包装类变为基本数据类型的过程称为拆箱,例如把 Integer 类的对象重新简化为 int。

    例如,public class Main {

    public static void main(String[] args) {

    int m = 100;

    Integer obj = m; // 自动装箱

    int n = obj; // 自动拆箱

    System.out.println("n = " + n);

    Integer obj1 = 100;

    System.out.println("obj等价于obj1返回结果为" + obj.equals(obj1));

    }

    }

    展开全文
  • Java中的包装类

    万次阅读 多人点赞 2019-04-16 15:34:10
    一、包装类概述 二、包装类的自动装箱、自动拆箱机制 三、包装类中的缓存机制 四、包装类的四则运算、位运算、比较运算、逻辑运算 五、包装类作为方法的形参、返回值 六、包装类作为集合的元素 七、包装类使用...

    目录

    一、包装类概述

    二、包装类的自动装箱、自动拆箱机制 

    三、包装类中的缓存机制

    四、包装类的四则运算、位运算、比较运算、逻辑运算

    五、包装类作为方法的形参、返回值

    六、包装类作为集合的元素

    七、包装类使用过程中有可能引起的空指针异常

    八、为什么需要包装类?有了包装类又为什么要保留基本数据类型?(包装类的优缺点)


     

    一、包装类概述

    Java有8种基本数据类型:整型(byte、short、int、long)、浮点型(float、double)、布尔型boolean、字符型char,相对应地,Java提供了8种包装类Byte、Short、Integer、Long、Float、Double、Boolean、Character。包装类创建对象的方式就跟其他类一样。

    Integer num = new Integer(0);    //创建一个数值为0的Integer对象

    二、包装类的自动装箱、自动拆箱机制 

    上面的构造对象语句实际上是基本数据类型向包装类的转换。在应用中我们经常需要进行基本类型数据和包装类对象之间的互转。

    Integer num1 = new Integer(1);	//基本数据类型转为包装类
    int num2 = num1.intValue();		//包装类型转为基本数据类型
    System.out.println(num1 +"	"+ num2);

    而Java为了方便我们使用,以及出于其他目的如性能调优,给我们提供了自动装箱、拆箱机制。这种机制简化了基本类型和包装类型的转换。

    //1、包装类中的自动装箱拆箱机制
    Integer  num1 = 1;		//自动装箱
    int num2 = num1;		//自动拆箱
    System.out.println(num1 +"	"+ num2);

    当使用jad工具对上面的代码进行反编译时,结果如下。

    Integer integer = Integer.valueOf(1);
    int i = integer.intValue();
    System.out.println((new StringBuilder()).append(integer).append("\t").append(i).toString());

    可见,Java编译器帮我们完成了转换操作。另外,我们可以看到,除了使用new关键字,还可以使用Integer类的valueOf()方法创建一个Integer对象。这两个方式是有所区别的,我们下面会说到。

    三、包装类中的缓存机制

    前面说到创建包装类对象有两种方式:new关键字、valueOf()方法。我们来看一段代码感受一下它们的区别。

    //2、包装类中的缓存机制
    Integer num3 = 10;
    Integer num4 = 10;
    Integer num5 = new Integer(20);
    Integer num6 = new Integer(20);
    Integer num7 = 128;
    Integer num8 = 128;
    System.out.println((num3==num4) +"	"+ num3.equals(num4));
    System.out.println((num5==num6) +"	"+ num5.equals(num6));
    System.out.println((num7==num8) +"	"+ num7.equals(num8));

    运行结果为

    我们看下它的反编译代码

    Integer integer = Integer.valueOf(10);
    Integer integer1 = Integer.valueOf(10);
    Integer integer2 = new Integer(20);
    Integer integer3 = new Integer(20);
    Integer integer4 = Integer.valueOf(128);
    Integer integer5 = Integer.valueOf(128);
    System.out.println((new StringBuilder()).append(integer == integer1).append("\t").append(integer.equals(integer1)).toString());
    System.out.println((new StringBuilder()).append(integer2 == integer3).append("\t").append(integer2.equals(integer3)).toString());
    System.out.println((new StringBuilder()).append(integer4 == integer5).append("\t").append(integer4.equals(integer5)).toString());

    首先,我们查看Integer的valueOf()方法的源码

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

    再查看下Integer的内部类IntegerCache的cache数组成员、low、high成员

            static final int low = -128;
            static final int high;
            static final Integer 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;
            }

    可以发现,只要Integer类第一次被使用到,Integer的静态内部类就被加载,加载的时候会创建-128到127的Integer对象,同时创建一个数组cache来缓存这些对象。当使用valueOf()方法创建对象时,就直接返回已经缓存的对象,也就是说不会再新建对象;当使用new关键字or使用valueOf()方法创建小于-128大于127的值对象时,就会创建新对象。

    //2、包装类中的缓存机制
    Integer num3 = 10;
    Integer num4 = 10;
    Integer num5 = new Integer(20);
    Integer num6 = new Integer(20);
    Integer num7 = 128;
    Integer num8 = 128;
    

    由于num3、num4都小于等于127,它们指向的是同一个缓存的Integer对象,所以用==进行比较的结果是true;num5、num6由于使用new关键字指向的是两个不同的新对象,结果为false;num7、num8虽然是采用自动装箱的方式,但执行valueOf()方法的时候,由于不满足条件i >= IntegerCache.low && i <= IntegerCache.high,而同样新建了两个不同的新对象,结果同样是false。

    接着,我们再来看看源码中Integer的equals()方法的实现

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

    可见equals()方法比较的是Integer对象的值,而不是像==一样比较的是对象是否是同一个对象。所以,当需要比较两个Integer对象的值是否相等时,记住要用equals()方法。用==比较的话由于缓存机制的存在,可能产生一些让人困扰的结果。

    此外,在8种包装类型中,有缓存区的有Character、Byte、Short、Integer、Long,而且它们的实现方式基本一样,都是-128到127的缓存范围。Boolean虽然没有缓存区,但是因为只有两个值true、false,所以Boolean在成员变量中就创建了两个相应的对象。没有缓存区的只有Float、Double,之所以没有原因很简单,即便是0到1这么小的范围,浮点数也有无数个,使用缓存区缓存它们不具备可能性和实用性。

    缓存区的存在使得常用的包装类对象可以得到复用,这有利于提升性能。当我们需要创建新对象的时候再new一个,增加了灵活性。

    四、包装类的四则运算、位运算、比较运算、逻辑运算

    1、四则运算和位运算

    //四则运算、位运算
    Integer num9 = 1;
    Integer num10 = 2;
    Integer num11 = num9 + num10; 
    Short num12 = 5;
    Integer num13 = num9 + num12;
    Long num14 = num9 + 10L;
    System.out.println(num9 << 1);	//位运算
    System.out.println(num9 +"	"+ num10 +"	"+ num11 +"	"+ num12 +"	"+ num13 +"	"+ num14);

    反编译结果如下

            Integer integer = Integer.valueOf(1);
            Integer integer1 = Integer.valueOf(2);
            Integer integer2 = Integer.valueOf(integer.intValue() + integer1.intValue());
            Short short1 = Short.valueOf((short)5);
            Integer integer3 = Integer.valueOf(integer.intValue() + short1.shortValue());
            Long long1 = Long.valueOf((long)integer.intValue() + 10L);
            System.out.println(integer.intValue() << 1);
            System.out.println((new StringBuilder()).append(integer).append("\t").append(integer1).append("\t").append(integer2).append("\t").append(short1).append("\t").append(integer3).append("\t").append(long1).toString());
     

    可以看到Integer num11 = num9 + num10; 这一句被划分为3个步骤:将两个Integer对象分别进行拆箱;将拆箱得到的两个int数值相加求其和;将和值进行装箱,从而将num11指向缓存数组中值为3的Integer对象。

    而Short num12 = 5; 这一句则先将5强制转换成short类型,再将其装箱把值为5的Short对象的引用赋给num12。

    而Integer num13 = num9 + num12; 这一句除了Integer num11 = num9 + num10;的3个步骤,中间还有short+int=int的类型自动提升的过程。

    而Long num14 = num9 + 10L; 这一句Integer num11 = num9 + num10;的3个步骤,中间还有强制类型转换的过程。需要注意的是,如果是Long num14 = num9 + num10; 的话就会出现类型不匹配的错误,因为num9、num10拆箱之后相加的和是int类型,而Long.valueOf(long)需要的形参是long类型,自然会出错。我们也可以看到,当包装类型对象和基本类型数据进行四则运算的时候,对象是会被拆箱的,然后再按基本类型数据的运算规则进行运算。

    另外,如果仅仅是打印两个包装类型对象求和的结果,是不会有将和值重新转换成该包装类型的步骤的,如下面所示

    System.out.println(num9 + num10);
    System.out.println(integer.intValue() + integer1.intValue());

    这里还需要注意一点,尽管基本类型与自动类型提升/强制类型转换,包装类是没有类似的用法的。下面的做法是错的。

    Short num3 = 10;
    Integer num4 = num3;	//错误: 不兼容的类型: Short无法转换为Integer
    Long num5 = (Long)num4;	//错误: 不兼容的类型: Integer无法转换为Long
    Double num6 = num5;	//错误: 不兼容的类型: Long无法转换为Double

    小结:不同包装类型对象是不能直接转换的,不过有两种途径可以代替:一种是上面讨论的不同包装类对象进行四则运算后赋给某一种类型;另一种就是利用包装类的方法

    Integer a = 20;
    Long b = a.longValue();
    Short c = b.shortValue();
    System.out.println(a +"	"+ b +"	"+ c);

    2、比较运算和逻辑运算

    Integer num9 = 100;
    Integer num10 = 200;
    Short num11 = 50;
    Long num12 = 50L;
    System.out.println((num9<num10) +"	"+ (num9<200) +"	"+ (num9<num11) +"	"+ (num9<num12) +"	"+ (num9<10L));

    反编译结果为

    Integer integer = Integer.valueOf(100);
    Integer integer1 = Integer.valueOf(200);
    Short short1 = Short.valueOf((short)50);
    Long long1 = Long.valueOf(50L);
    System.out.println((new StringBuilder()).append(integer.intValue() < integer1.intValue()).append("\t").append(integer.intValue() < 200).append("\t").append(integer.intValue() < short1.shortValue()).append("\t").append((long)integer.intValue() < long1.longValue()).append("\t").append((long)integer.intValue() < 10L).toString());
     

    可以看到,两个同类型的包装类对象进行比较时比较的其实是各自的基本类型数值,如num9 < num10;两个不同类型的包装类对象进行比较时则在比较基本类型数值之前,会有类型提升or强制类型转换,如num9 < num11,num9 < num12。

    当想比较两个对象是否相等时,注意要使用equals()方法,从前面的讨论也知道,使用==的话比较的其实是引用的对象是否同一个,一般不满足我们的需求。

    Integer num13 = new Integer(100);
    System.out.println(num9.equals(num13) +"	"+ num9.equals(50));

    反编译结果为

    Integer integer2 = new Integer(100);
    System.out.println((new StringBuilder()).append(integer.equals(integer2)).append("\t").append(integer.equals(Integer.valueOf(50))).toString());
    

    逻辑运算举例:

    System.out.println((num9&1));

    反编译结果为

    System.out.println(integer.intValue() & 1);

    五、包装类作为方法的形参、返回值

    //包装类作为方法的形参、返回值
    	public static Integer intToInteger(int i) {
    		return i;
    	}  
    	public static int integerToInt(Integer i) {
    		return i;
    	}

    反编译结果为

        public static Integer intToInteger(int i)
        {
            return Integer.valueOf(i);
        }
    
        public static int integerToInt(Integer integer)
        {
            return integer.intValue();
        }

    六、包装类作为集合的元素

    //包装类作为集合元素
    List list = new ArrayList();
    list.add(1);
    list.add(new Object());
    Iterator it = list.iterator();
    while (it.hasNext()) {
    	System.out.println(it.next());
    }

    反编译结果为

     

    ArrayList arraylist = new ArrayList();
    arraylist.add(Integer.valueOf(1));
    arraylist.add(new Object());
    for(Iterator iterator = arraylist.iterator(); iterator.hasNext(); System.out.println(iterator.next()));

    可以发现,虽然集合元素要求是对象,add()方法的形参也是对象(public boolean add(E e)),但由于自动装箱,基本数据类型也可以直接加入集合中。

                    List<Integer> list = new ArrayList<>();
    		for (int i=0; i<5; i++) {
    			list.add(i);
    		}
    		Iterator it = list.iterator();
    		while (it.hasNext()) {
    			System.out.println(it.next());
    		}

    反编译结果为

            ArrayList arraylist = new ArrayList();
            for(int i = 0; i < 5; i++)
                arraylist.add(Integer.valueOf(i));
    
            for(Iterator iterator = arraylist.iterator(); iterator.hasNext(); System.out.println(iterator.next()));

    七、包装类使用过程中有可能引起的空指针异常

    //注意包装类可能产生的空引用异常
    		Boolean flag1 = false;
    		System.out.println(flag1?"命题为真":"命题为假");
    		Boolean flag2 = null;
    		System.out.println(flag2?"命题为真":"命题为假");
    		Boolean flag3 = true;

    运行结果为

    这里只是简单演示空指针异常。平时使用时需要注意这一点,比如当Boolean的对象作为形参时,在方法执行体的头部需要做下null检测。

    上述代码的反编译结果为

            Boolean boolean1 = Boolean.valueOf(false);
            System.out.println(boolean1.booleanValue() ? "\u547D\u9898\u4E3A\u771F" : "\u547D\u9898\u4E3A\u5047");
            Boolean boolean2 = null;
            System.out.println(boolean2.booleanValue() ? "\u547D\u9898\u4E3A\u771F" : "\u547D\u9898\u4E3A\u5047");
            Boolean boolean3 = Boolean.valueOf(true);

    可见三目运算符的条件表达式的位置一定是boolean值,如果你传入的是Boolean对象,则会自动拆箱转换为boolean值。

    另外,三目运算符的其他两个表达式位置也是如此,会把包装类对象转换为相应的基本类型对象。

    八、为什么需要包装类?有了包装类又为什么要保留基本数据类型?(包装类的优缺点)

    为什么需要包装类?

    首先,Java语言是一个面向对象的语言,但是Java中的基本数据类型却是不面向对象的,将每个基本数据类型设计一个对应的类进行代表,这种方式增强了Java面向对象的性质。

    其次,如果仅仅有基本数据类型,那么在实际使用时将存在很多的不便,很多地方都需要使用对象而不是基本数据类型。比如,在集合类中,我们是无法将int 、double等类型放进去的,因为集合的容器要求元素是Object类型。而包装类型的存在使得向集合中传入数值成为可能,包装类的存在弥补了基本数据类型的不足。

    此外,包装类还为基本类型添加了属性和方法,丰富了基本类型的操作。如当我们想知道int取值范围的最小值,我们需要通过运算,如下面所示,但是有了包装类,我们可以直接使用Integer.MAX_VALUE即可。

    //求int的最大值
    int max = 0;
    int flag = 1;
    for (int i=0; i<31; i++) {
    	max += flag;
    	flag = flag << 1;
    }
    System.out.println(max +"	"+ Integer.MAX_VALUE); //2147483647      2147483647

    为什么要保留基本数据类型?

    我们都知道在Java语言中,用new关键字创建的对象是存储在堆里的,我们通过栈中的引用来使用这些对象,所以,对象本身来说是比较消耗资源的。对于经常用到的类型,如int等,如果我们每次使用这种变量的时候都需要new一个对象的话,就会比较笨重了。所以,Java提供了基本数据类型,这种数据的变量不需要使用new在堆上创建,而是直接在栈内存中存储,因此会更加高效。

     

    展开全文
  • java包装类为什么会有包装类

    千次阅读 2019-05-26 23:22:30
    Java是面向对象的语言,但并不是“纯面向对象”的,因为我们经常用到的基本数据类型就不是对象。但是我们在实际应用中经常需要将基本数据转化成对象,以便于操作。比如:将基本数据类型存储到Object[]数组或集合中的...
    • Java是面向对象的语言,但并不是“纯面向对象”的,因为我们经常用到的基本数据类型就不是对象。但是我们在实际应用中经常需要将基本数据转化成对象,以便于操作。比如:将基本数据类型存储到Object[]数组或集合中的操作等等。
    • 为了解决这个不足,Java在设计类时为每个基本数据类型设计了一个对应的类进行代表,这样八个和基本数据类型对应的类统称为包装类(Wrapper Class)。
    • 包装类均位于java.lang包,八种包装类和基本数据类型的对应关系如表在这里插入图片描述 在这八个类名中,除了Integer和Character类以外,其它六个类的类名和基本数据类型一致,只是类名的第一个字母大写而已
    • 在这八个类中,除了Character和Boolean以外,其他的都是“数字型”,“数字型”都是java.lang.Number的子类**。Number类是抽象类,因此它的抽象方法**,所有子类都需要提供实现。Number类提供了抽象方法:intValue()、longValue()、floatValue()、doubleValue(),意味着所有的**“数字型”包装类都可以互相转型**。
    • 图1图二
    • 下面我们通过一个简单的示例认识一下包装类。
    public class WrapperClassTest {
        public static void main(String[] args) {
            Integer i = new Integer(10);
            Integer j = new Integer(50);
        }
    }
    

    内存分析如图
    内存分析

    展开全文
  • Java 包装类是什么

    万次阅读 多人点赞 2018-04-26 14:29:49
    包装类就是将基本的数据类型以及一些辅助方法封装到类中,例如 class IntDemo { private int num; public IntDemo(int num) { this.num = num; } public int intValue() { return this.num; } } Java...

     java中的数据类型int,double等不是对象,无法通过向上转型获取到Object提供的方法,而像String却可以,只因为String是一个对象而不是一个类型。基本数据类型由于这样的特性,导致无法参与转型,泛型,反射等过程。为了弥补这个缺陷,java提供了包装类。

     包装类顾名思义就是将基本的数据类型以及一些辅助方法包装到类中,例如自己实现一个int的包装类:

    class IntDemo {
        private int num;
        public IntDemo(int num) {
            this.num = num;
        }
        public int intValue() {
            return this.num;
        }
    }

    1. Java提供的包装类

     虽然上面的IntDemo类能实现一些辅助功能,而且可以支持泛型反射等功能,但是如果如果每次使用都自己封装这么一个类的话,就太繁琐了。所以,java为我们提供了基本数据类型的包装类,这些包装类分为两类,一种是对象型包装类,不继承任何其他类(Object的直接子类),另一种是数值型包装类,继承于Number类。

     对象型(Object 的直接子类)包装类:

    // boolean的包装类
    public final class Boolean implements java.io.Serializable,
                                          Comparable<Boolean>
    
    // char的包装类
    public final
    class Character implements java.io.Serializable, Comparable<Character>

     数值型(继承了Number类)包装类:

    // byte的包装类
    public final class Byte extends Number implements Comparable<Byte>
    
    // short的包装类
    public final class Short extends Number implements Comparable<Short> 
    
    // int的包装类
    public final class Integer extends Number implements Comparable<Integer>
    
    // long的包装类
    public final class Long extends Number implements Comparable<Long> 
    
    // float的包装类
    public final class Float extends Number implements Comparable<Float> 
    
    // double的包装类
    public final class Double extends Number implements Comparable<Double> 

     Boolean和Character两个类就是正常的属性方法封装,但是数值型的包装类继承了一个Number类。

    public abstract class Number implements java.io.Serializable

    其中定义的方法如下:

    Number类的方法

     其实Number中定义的方法就是用于拆箱装箱的。

    2. 拆箱与装箱

     装箱:

      将基本数据类型封装为包装类对象,利用每一个包装类提供的构造方法实现装箱操作。

     拆箱:

      将包装类中包装的基本数据类型数据取出。

    // 装箱
    Integer integer1 = new Integer(1);
    // 拆箱
    int integer2 = integer1.intValue(); 

     JDK1.5之后提供自动拆装箱。

    // 自动装箱
    Integer integer1 = 1;
    // 自动拆箱
    int integer2 = integer1; 

    3. 自动装箱的内存复用

     自动装箱时,对于Integer var = ?,如果var指向的对象在-128 至 127 范围内的赋值时,生成的Integer实例化对象是由 IntegerCache.cache() 方法产生,它会复用已有对象。和String的共享池操作是一个道理,cache()方法会将位于-128~127范围内产生的Integer对象入池,下次使用的时候,从池中拿去,就不会在创建了。

     所以,在这个数值区间内的 Integer对象的栈指向(属性名) 可以直接使用==进行判断,因为值相同,指向的就是同一片区域。但是这个区间之外的所有数据,自动装箱都会在堆上产生实例化,并不再复用已有对象,这是一个大坑,为了避免这个问题,推荐使用 equals 方法进行Integer的判断。

     对于所有数值型的包装类来说,都会涉及到上面这种问题,一定要多加注意。

     而对于手动装箱,即采用new进行包装类创建时,不会发生内存复用,因为new关键字每次使用,都会开辟新的空间,这和String采用构造方法创建字符串不入池相对应。

    4. 包装类编码规约

     所有的相同类型的包装类对象之间值的比较,全部使用equals()方法。

     所有的POJO(简单Java类,只包含基本属性,有参构造,get/set)类属性必须使用包装类数据类型,类属性即static属性。

     RPC(远程方法调用)方法返回值和参数必须使用包装数据类型。

     推荐所有的局部变量使用基本数据类型。

    5. 包装类对字符串与基本数据类型转换的支持

     实际工程中,各种数据的接收是通常是通过字符串完成的,所以要掌握包装类对字符串转换的方法。

    // String->int
    public static int parselnt(String s)throws NumberFormatException;
    
    // String->double 
    public static double parseDouble(String)throws NumberFormatException;
    
    // String->Boolean 
    public static boolean parseBoolean(String s)

     字符串转数值类型时字符串只能包含数字,否则会抛出 NumberFormatException 异常,这是一个非受查异常。

     但是字符串转Boolean是个特例,parseBoolean()方法会将”true”转为true,而将非”true”的字符串转为false。

    展开全文
  • Java 基本类型包装类

    千次阅读 2021-03-08 05:56:26
    Java基本类型包装类:基本数据类型 基本类型包装类byte Byteshort Shortint Integerlong Longfloat Floatdouble Doublechar Charac...
  • Java包装类作用及注意点

    万次阅读 多人点赞 2018-03-16 19:30:50
    Java中对每种基本类型都有一个对应的包装类,这里主要讲解包装类的作用和包装类使用时的一些注意点。 包装类的作用 作用主要有以下两方面: - 编码过程中只接收对象的情况,比如List中只能存入对象,不能存入...
  • Java包装类及自动装箱、拆箱

    千次阅读 多人点赞 2019-03-19 15:00:31
    Java包装类 基本类型 大小 包装器类型 boolean / Boolean char 16bit Boolean byte 8bit Byte short /16bit Short int 32bit Integer long 64bit Long float 32bit Float double 64bit Double...
  • Java内置包装类:Float 类

    千次阅读 2019-05-17 22:12:14
    Float 在对象中包装了一个基本类型 float 的值。Float 对象包含一个 float 类型的字段。此外,该提供了多个方法,能在 float 类型与 String 类型之间互相转换,同时还提供了处理 float 类型时比较常用的常量和...
  • Java内置包装类:Double类

    千次阅读 2019-05-15 18:40:00
    Double 在对象中包装了一个基本类型 double 的值。Double 对象包含一个 double 类型的字段。此外,该还提供了多个方法,可以将 double 类型与 String 类型相互转换,同时 还提供了处理 double 类型时比较常用...
  • 最近在业务中碰到了 Integer 默认值的判空 导致的业务逻辑问题,引起了兴趣,针对基本数据类型和其包装类有什么区别?测试过程中应该注意哪些问题呢?...回答这些问题前,我们先来看看java中基本数据类型和包装类有哪些
  • JAVA包装类的作用

    万次阅读 多人点赞 2019-04-16 12:04:37
    为了使用方便和解决这个不足,在设计类时为每个基本数据类型设计了一个对应的类进行代表,这样八种基本数据类型对应的类统称为包装类(Wrapper Class),包装类均位于java.lang包。 二、包装类的用途 为了使用方便Java...
  • Java包装类(wrapper)

    千次阅读 2018-12-01 21:51:43
    定义: Java语言是面向对象的...2、包装类是不可变类,在构造包装类对象后,不允许更改包装在其中的值。 3、方便在基本数据类型与字符串之间进行转换。 4、可以更加便捷的对基本数据类型进行操作。 5、方便在集...
  • Java 八大包装类(超详细!)

    千次阅读 2021-05-01 16:42:23
    一、8种基本数据类型对应的包装类型名 基本数据类型 包装类型 byte java.lang.Byte(父类Number) short java.lang.Short(父类Number) int java.lang.Integer(父类Number) long java.lang.Long...
  • Java包装类型有几种

    千次阅读 2021-03-14 16:35:05
    【相关学习推荐:java基础教程】Java包装类型有8种,分别是:Java中的基本类型功能简单,不具备对象的特性,为了使基本类型具备对象的特性,所以出现了包装类,就可以像操作对象一样操作基本类型数据。一、基本类型...
  • Java包装类对象比较中存在的问题

    千次阅读 2017-07-14 22:21:48
    本文章以Integer包装类为例,讲解一些包装类比较过程中存在的问题。 首先看一段代码: Integer i1 = 10; Integer i2 = 10; System.out.println(i1 == i2);//true Integer i3 = 1000; Integer i4 = 1000;
  • java中基本类型包装类

    万次阅读 多人点赞 2020-12-14 08:38:00
    1. 基本类型包装类概述为了方便操作基本数据类型值,将其封装成了对象,在对象中定义了属性和行为丰富了该数据的操作。用于描述该对象的类就称为基本数据类型对象包装类。将基本数据类型封装成对象...
  • 事件:包装类型为静态变量,与基本类型进行==比较过程中,报空指针异常 Exception in thread "main" java.lang.NullPointerException at com.lei.java8.TestCharaterNull.main(TestCharaterNull.java:9)
  • java 包装类 Boolean

    千次阅读 2018-07-28 21:03:47
    Boolean 一个Boolean类型的对象只包含一个类型为boolean的字段,此类还为boolean和String的相互转换提供了很多方法。 构造方法 Boolean(boolean value); 该方法创建一个表示value参数的Boolean对象 ...
  • Java包装类与基本类型进行比较的坑

    千次阅读 2017-08-09 18:58:19
    Java包装类与基本类型进行比较的坑
  • java八种基本数据类型及包装类详解

    万次阅读 多人点赞 2018-12-20 10:14:40
    java八种基本数据类型分为四类八种,四类分别为整型、浮点型、布尔型、字符型;八种分别为byte、short、int、long、float、double、boolean、char; java八种基本数据类型的字节数:分别为1、2、4、8个字节;1字节...
  • 像int类型的包装类Integar 我觉得int本来就是由很多整数组成的啊,我觉得int就是一个类,干嘛还要Integar这样的包装类
  • java基本数据类型对象包装类

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

    千次阅读 2019-09-16 13:27:54
    Java提供了两个类型系统,基本类型与引用类型,使用基本类型在于效率,然而很多情况,会创建对象使用,因为对象可以做更多的功能,如果想要我们的基本类型像对象一样操作,就可以使用基本类型对应的包装类,如下: ...
  • java包装类的实例化秘密

    千次阅读 2014-11-24 16:01:39
    包装类的实例化 所有的包装类都是不可变的 实例化方法: 构造方法 除了Character类,其他包 Integer(int x) Integer(String x) NumberFormatException异常 对于Boolean构造方法的参数不区分 大...
  • Java包装类的共同点

    千次阅读 2019-03-10 23:19:32
    渣渣海除了写点博客外,还有github哦...之前写过一篇博客,讲了基础的Java包装类的装包拆包过程,下面补充一下包装类它们的一些共同点。 1.所有包装类都重写了Object方法 我们也很容易知道Object的方法有: bo...
  • 八大基本数据类型均有对应的包装类 byte、short、int、long、float、double、char、boolean分别对应Byte、Short、Integer、Long、Float、Double、Character、Boolean 包装类型的出现是为了方便基本数据类型能够和...
  • Java初学阶段,想必很多人都会先学Java中的一些基本类型以及他们的包装类,如下 int --> Integer long --> Long double --> Double ...等等 很多人在学的时候感觉这用处不大啊,也不知道什么时候用,该...
  • 关于Java包装类的理解

    千次阅读 2017-07-14 16:03:42
    在学习了一段时间的Android之后,深知在Java基础体系中部分知识的缺失而使我在学习过程中碰到了许多不能理解的概念,就在最近,我打算重新学习Java语言的一些基础,就我现在大概几个星期系统的学习,Java语言体系...
  • 第1关:基本数据类型和包装类之间的转换 package step1; public class Task { public static void main(String[] args) { //请在此添加实现代码 /********** Begin **********/ //定义float对象 float f = ...
  • Java坑人面试题系列: 包装类(中级难度)

    万次阅读 多人点赞 2020-02-03 23:21:36
    这些问题的设计宗旨,主要是测试面试者对Java语言的了解程度,而不是为了用弯弯绕绕的手段把面试者搞蒙。 如果你看过往期的问题,就会发现每一个都不简单。 这些试题模拟了认证考试中的一些难题。 而 “中级...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 328,850
精华内容 131,540
关键字:

java包装类特征

java 订阅