精华内容
下载资源
问答
  • 在Java初学阶段,想必很多人都会先学Java中的一些基本类型以及他们的包装类,如下 int --> Integer long --> Long double --> Double ...等等 很多人在学的时候感觉这用处不大啊,也不知道什么时候用,该...

    在Java初学阶段,想必很多人都会先学Java中的一些基本类型以及他们的包装类,如下

    int --> Integer
    long --> Long
    double --> Double
    ...等等
    

    很多人在学的时候感觉这用处不大啊,也不知道什么时候用,该怎么用。接下来是楼主的一些见解,也是工作中算最常用到的,如果有大神看到文章觉得我说的不对,请指出我的问题。

    我们这拿int基本类型来举例。

    1.基本类型的包装类是复杂类型

    Integer为复杂类型,具有一些与其他类型转换的方法。而基本类型做不到。

    String str="1";
    Integer.parseInt(str)
    2.基本类型默认为0,包装类型为NULL

    楼主这就不讲什么底层原理七七八八,直接就是讲最直接的比较,我们这用一个Student类来解释。

    public class Student{
        private String name;//学生名称
        private int score;//学生成绩
    }
    

    这里如果是一场考试的话,那么这场考试中 int 类型只能表示一种情况,学生来考试了,只不过有成绩和0分。

    但是真正的情况下,还有一种情况,那就是这学生没来考试。 我们要知道,0分跟没来严格来说是由区别的,那么这时候包装类默认类型为NULL就派上用场了。这也是楼主当初理解包装类和基本类型最直接的一种理解方式了。

    3.如何使用基本类型和包装类型

    大部分情况下,使用这两种类型不会有太大区别。但是楼主在开发过程中,最常用的还是在定义属性的时候,会根据这个对象的要求来去定义是包装类型还是基本类型。

    举例1:对象中有返回的统计属性 还拿学生成绩来说,返回三科总成绩,楼主就习惯会用int,因为已经说到统计,你肯定得让这个字段存在,如果真的没有,那就默认统计为0。

    举例2:张三去没去考试,结果只会出现去 或者没去 ,boolean基本类型 默认值是false,设置了true才会是true。

    总结

    用基本类型还是包装类型 只要你在开发中经常写,遇到情况的时候你就深有体会,渐渐的你也懂我上面说的意思,总的来说就是结果或者你希望的结果只有2种情况的时候 你就用基本类型,想让他存在NULL的情况就用包装类型。

    展开全文
  • Java中的包装类

    万次阅读 多人点赞 2019-04-16 15:34:10
    目录 ...七、包装类使用过程中有可能引起的空指针异常 八、为什么需要包装类?有了包装类又为什么要保留基本数据类型?(包装类的优缺点) 一、包装类概述 Java有8种基本数据类型:整型(byt...

    目录

    一、包装类概述

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

    三、包装类中的缓存机制

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

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

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

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

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


     

    一、包装类概述

    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在堆上创建,而是直接在栈内存中存储,因此会更加高效。

     

    展开全文
  • 基本类型的包装类对象使用 == 和 equals进行比较的结果 1、值不同,使用==和equals比较都返回false 2、值相同 使用==比较: 基本类型-基本类型、基本类型-包装对象返回true 包装对象-包装对象返回...

    基本类型的包装类对象使用 == 和 equals进行比较的结果

    1、值不同,使用==和equals比较都返回false

     

    2、值相同

    使用==比较:

    • 基本类型-基本类型、基本类型-包装对象返回true
    • 包装对象-包装对象返回false
    • 缓存中去的包装对象比较返回true(JVM 缓存部分基本类型常用的包装类对象,如 Integer 缓存 -128 ~ 127 )
            Integer i1 = 100;
            Integer i2 = 100;
            Integer i3 = 200;
            Integer i4 = 200;
             
            System.out.println(i1==i2); //打印true
            System.out.println(i3==i4); //打印false

    使用equals比较:

    • 包装对象-基本类型返回true
    • 包装对象-包装对象返回true

     

    3、不同类型的对象对比,返回 false

     

    JDK1.8,实验代码

                    byte b1 = 127;
    		Byte b2 = new Byte("127");
    		Byte b3 = new Byte("127");
    		System.out.println("Byte 基本类型和包装对象使用 == 比较 : " + (b1 == b2));
    		System.out.println("Byte 基本类型和包装对象使用 equals 比较 : " + b2.equals(b1));
    		System.out.println("Byte 包装对象和包装对象使用 == 比较 : " + (b2 == b3));
    		System.out.println("Byte 包装对象和包装对象使用 equals 比较 : " + b2.equals(b3));
    		System.out.println();
    		
    		short s1 = 12;
    		Short s2 = new Short("12");
    		Short s3 = new Short("12");
    		System.out.println("Short 基本类型和包装对象使用 == 比较 : " + (s1 == s2));
    		System.out.println("Short 基本类型和包装对象使用 equals 比较 : " + s2.equals(s1));
    		System.out.println("Short 包装对象和包装对象使用 == 比较 : " + (s2 == s3));
    		System.out.println("Short 包装对象和包装对象使用 equals 比较 : " + s2.equals(s3));
    		System.out.println();
    		
    		char c1 = 'A';
    		Character c2 = new Character('A');
    		Character c3 = new Character('A');
    		System.out.println("Character 基本类型和包装对象使用 == 比较 : " + (c1 == c2));
    		System.out.println("Character 基本类型和包装对象使用 equals 比较 : " + c2.equals(c1));
    		System.out.println("Character 包装对象和包装对象使用 == 比较 : " + (c2 == c3));
    		System.out.println("Character 包装对象和包装对象使用 equals 比较 : " + c2.equals(c3));
    		System.out.println();
    		
    		int i1 = 10000;
    		Integer i2 = new Integer(10000);
    		Integer i3 = new Integer(10000);
    		System.out.println("Integer 基本类型和包装对象使用 == 比较 : " + (i1 == i2));
    		System.out.println("Integer 基本类型和包装对象使用 equals 比较 : " + i2.equals(i1));
    		System.out.println("Integer 包装对象和包装对象使用 == 比较 : " + (i2 == i3));
    		System.out.println("Integer 包装对象和包装对象使用 equals 比较 : " + i2.equals(i3));
    		System.out.println();
    		
    		long l1 = 1000000000000000L;
    		Long l2 = new Long("1000000000000000");
    		Long l3 = new Long("1000000000000000");
    		System.out.println("Long 基本类型和包装对象使用 == 比较 : " + (l1 == l2));
    		System.out.println("Long 基本类型和包装对象使用 equals 比较 : " + l2.equals(l1));
    		System.out.println("Long 包装对象和包装对象使用 == 比较 : " + (l2 == l3));
    		System.out.println("Long 包装对象和包装对象使用 equals 比较 : " + l2.equals(l3));
    		System.out.println();
    		
    		float f1 = 10000.111F;
    		Float f2 = new Float("10000.111");
    		Float f3 = new Float("10000.111");
    		System.out.println("Float 基本类型和包装对象使用 == 比较 : " + (f1 == f2));
    		System.out.println("Float 基本类型和包装对象使用 equals 比较 : " + f2.equals(f1));
    		System.out.println("Float 包装对象和包装对象使用 == 比较 : " + (f2 == f3));
    		System.out.println("Float 包装对象和包装对象使用 equals 比较 : " + f2.equals(f3));
    		System.out.println();
    		
    		double d1 = 10000.111;
    		Double d2 = new Double("10000.111");
    		Double d3 = new Double("10000.111");
    		System.out.println("Double 基本类型和包装对象使用 == 比较 : " + (d1 == d2));
    		System.out.println("Double 基本类型和包装对象使用 equals 比较 : " + d2.equals(d1));
    		System.out.println("Double 包装对象和包装对象使用 == 比较 : " + (d2 == d3));
    		System.out.println("Double 包装对象和包装对象使用 equals 比较 : " + d2.equals(d3));
    		System.out.println();
    		
    		boolean bl1 = true;
    		Boolean bl2 = new Boolean("true");
    		Boolean bl3 = new Boolean("true");
    		System.out.println("Boolean 基本类型和包装对象使用 == 比较 : " + (bl1 == bl2));
    		System.out.println("Boolean 基本类型和包装对象使用 equals 比较 : " + bl2.equals(bl1));
    		System.out.println("Boolean 包装对象和包装对象使用 == 比较 : " + (bl2 == bl3));
    		System.out.println("Boolean 包装对象和包装对象使用 equals 比较 : " + bl2.equals(bl3));

    运行结果

    Byte 基本类型和包装对象使用 == 比较 : true
    Byte 基本类型和包装对象使用 equals 比较 : true
    Byte 包装对象和包装对象使用 == 比较 : false
    Byte 包装对象和包装对象使用 equals 比较 : true
    
    Short 基本类型和包装对象使用 == 比较 : true
    Short 基本类型和包装对象使用 equals 比较 : true
    Short 包装对象和包装对象使用 == 比较 : false
    Short 包装对象和包装对象使用 equals 比较 : true
    
    Character 基本类型和包装对象使用 == 比较 : true
    Character 基本类型和包装对象使用 equals 比较 : true
    Character 包装对象和包装对象使用 == 比较 : false
    Character 包装对象和包装对象使用 equals 比较 : true
    
    Integer 基本类型和包装对象使用 == 比较 : true
    Integer 基本类型和包装对象使用 equals 比较 : true
    Integer 包装对象和包装对象使用 == 比较 : false
    Integer 包装对象和包装对象使用 equals 比较 : true
    
    Long 基本类型和包装对象使用 == 比较 : true
    Long 基本类型和包装对象使用 equals 比较 : true
    Long 包装对象和包装对象使用 == 比较 : false
    Long 包装对象和包装对象使用 equals 比较 : true
    
    Float 基本类型和包装对象使用 == 比较 : true
    Float 基本类型和包装对象使用 equals 比较 : true
    Float 包装对象和包装对象使用 == 比较 : false
    Float 包装对象和包装对象使用 equals 比较 : true
    
    Double 基本类型和包装对象使用 == 比较 : true
    Double 基本类型和包装对象使用 equals 比较 : true
    Double 包装对象和包装对象使用 == 比较 : false
    Double 包装对象和包装对象使用 equals 比较 : true
    
    Boolean 基本类型和包装对象使用 == 比较 : true
    Boolean 基本类型和包装对象使用 equals 比较 : true
    Boolean 包装对象和包装对象使用 == 比较 : false
    Boolean 包装对象和包装对象使用 equals 比较 : true
    

     

    ps:可以延伸一个问题,基本类型与包装对象的拆/装箱的过程

     


    【Java面试题与答案】整理推荐

     

    展开全文
  • Java中包装类作用及注意点

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

    Java中对每种基本类型都有一个对应的包装类,这里主要讲解包装类的作用和包装类使用时的一些注意点。

    包装类的作用

    作用主要有以下两方面:
    - 编码过程中只接收对象的情况,比如List中只能存入对象,不能存入基本数据类型;比如一个方法的参数是Object时,不能传入基本数据类型,但可以传入对应的包装类;
    - 方便类型之间的转换,比如String和int之间的转换可以通过int的包装类Integer来实现,具体如下。
    int a = new Integer("123");
    或者
    int a = Integer.parseInt("123");

    包装类使用时的注意点

    这里先看一段代码:

    public class StudyBox {
        public static void main(String[] args) {
    
            Integer a = 100, b = 100, c = 150, d = 150;
            Long e = 150l;
            System.out.println(a == b);
            System.out.println(c == d);
            System.out.println(c.equals(d));
            System.out.println(d.equals(e));
            System.out.println(e.equals(d));
        }
    
    }
    

    这段代码的输出结果如下:

    true
    false
    true
    false
    false

    第一个、第三个输出很好理解,但是其他三个输出可能就会让人有些疑惑。

    代码解释

    这里以int型对应的包装类Integer为例来说明:
    在上段代码中,初始化Integer类型的a,是将int型数据100装箱然后赋值给变量a,其中装箱操作使用的是静态工厂方法valueOf(int i),下面我们看一下这个方法的源码:

    /**
     * Returns an {@code Integer} instance representing the specified
     * {@code int} value.  If a new {@code Integer} instance is not
     * required, this method should generally be used in preference to
     * the constructor {@link #Integer(int)}, as this method is likely
     * to yield significantly better space and time performance by
     * caching frequently requested values.
     *
     * This method will always cache values in the range -128 to 127,
     * inclusive, and may cache other values outside of this range.
     *
     * @param  i an {@code int} value.
     * @return an {@code Integer} instance representing {@code i}.
     * @since  1.5
     */
    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

    在这个方法注释的第二段中,说明了这个方法一定会缓存-128到127的值,也有可能会缓存这个范围以外的值,这就是上面代码中第二个输出是false的原因。即-128到127的值会被Integer类缓存起来(在Integer类中通过IntegerCache类来实现),从valueOf(int i)的代码中可以看出,对象a和b是同一个对象,所以==比较是true;而c和d是不同的对象,所以==比较是false。

    另外,使用equals()来进行对象比较时,Integer会先检查类型是否一致,若不一致直接返回false,这也就是第四个和第五个输出false的原因。具体如以下源码:

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

    以上内容若有错误之处,还请各位大神指点,不胜感激,同时也欢迎各位一起来探讨相关问题。

    参考资料

    解决Java包装类比较时遇到的问题

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

    千次阅读 2019-05-26 23:22:30
    包装类均位于java.lang包,八种包装类和基本数据类型的对应关系如表 在这八个类名中, 除了Integer和Character类以外,其它六个类的类名和基本数据类型一致,只是类名的第一个字母大写而已 。 在这八个类中,除了...
  • 类别Java基础数据类型以及其包装类。 ... 通过表格类比了一下, 包装类用的场景多些。 所以,只要在第一项 Calculate(计算)+-*/%^ 才使用基本数据类型,其他场景均可以用包装类 ;-)  ...
  • 然后再根据这两个特性进行分业务使用,在阿里巴巴的规范里所有的POJO必须使用包装类型,而在本地变量推荐使用基本类型。 Java语言提供了八种基本类型。六种数字类型(四个整数型,两个浮点型),一种字符类型,...
  • 包装类

    千次阅读 多人点赞 2018-08-06 09:16:29
    包装类(Wrapper Class): Java是一个面向对象的编程语言,但是Java中的八种基本数据类型却是不面向对象的,为了使用方便和解决这个不足,在设计类时为每个基本数据类型设计了一个对应的类进行代表,这样八种基本...
  • 包装类是对象,拥有方法和字段.对象的调用都是通过引用对象的地址,产生对象时直接用引用指向这个对象(引用变量是在存在栈内存中,对象是在堆内存中的,堆中分配内存...包装类创建的对象,可以使用api提供的一些有用的
  • Java判断基本数据类型变量内容是否相等时用“==”,判断其他类... 然而,包装类则介于基本数据类型与类之间,使用“==”符号时就会涉及到自动拆装箱。  先看下面一段代码(题目来源牛客网): public class CodeOne {
  • Java内置包装类:Double类

    千次阅读 2019-05-15 18:40:00
    Double 在对象中包装了一个基本类型 double 的值。Double 对象包含一个 double 类型的字段。此外,该还提供了多个方法,可以将 double 类型与 String 类型相互转换,同时 还提供了处理 double 类型时比较常用...
  • java中的POJO属性建议使用包装数据类型

    千次阅读 多人点赞 2018-03-15 14:09:16
    POJO 属性没有初值是提醒使用者在需要使用时,必须自己显式地进行赋值,任何NPE(NullPointerException,空指针异常) 问题,或者入库检查,都由使用者来保证。 2、举例说明 正例: (1)所有的sql使用的默认...
  • 深入理解Java包装类与自动拆装箱

    千次阅读 2020-06-21 22:36:30
    你真的理解Java包装类和自动拆装箱吗?有些知识你绝对不知道!
  • 包装类及常用方法简介

    千次阅读 2018-08-24 19:40:08
    包装类及常用方法简介 JAVA 是一种面向对象语言,JAVA 中的类把方法与数据连接在一起,构成 了自包含式的处理单元。但在 JAVA 中不能定义基本类型(primitive type)对象, 为了能将基本类型视为对象进行处理,并...
  • Java包装类的共同点

    千次阅读 2019-03-10 23:19:32
    渣渣海除了写点博客外,还有github哦...之前写过一篇博客,讲了基础的Java包装类的装包拆包过程,下面补充一下包装类它们的一些共同点。 1.所有包装类都重写了Object方法 我们也很容易知道Object的方法有: bo...
  • Java内置包装类:Float 类

    千次阅读 2019-05-17 22:12:14
    Float 在对象中包装了一个基本类型 float 的值。Float 对象包含一个 float 类型的字段。此外,该提供了多个方法,能在 float 类型与 String 类型之间互相转换,同时还提供了处理 float 类型时比较常用的常量和...
  • 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...
  • 最近在业务中碰到了 Integer 默认值的判空 导致的业务逻辑问题,引起了兴趣,针对基本数据类型和其包装类有什么区别?测试过程中应该注意哪些问题呢? 回答这些问题前,我们先来看看java中基本数据类型和包装类有...
  • 使用std::function包装类成员函数

    千次阅读 2020-04-01 09:08:08
    std::function std::function是一个函数包装器模板,最早来自boost库,对应其boost::function函数包装器。在c++11中,std::function能...包装类成员函数示例 #include <functional> #include <iostream&...
  • Java8编程实战

    万人学习 2016-12-31 18:03:03
    Java一直作为优秀的编程语言活跃于软件开发行业,掌握Java不仅是一件兴奋的事,更是一把可以帮助你轻松进入软件行业大门的一把金钥匙,本套课程将为读者讲解Java8的所有核心技术知识,一共240集的Java8开发课程,...
  • java中包装类的比较用法

    千次阅读 2018-01-12 10:14:27
    java中包装类的比较用法 一、前言 java中 ,包装类是一个对象,也是一个具体的数值。对于对象比较可以用 equals()方法,对于数值的比较可以用 == 进行比较,那么对于包装类该用那种方法比较合适呢? ...
  • JAVA中包装类的作用

    万次阅读 多人点赞 2019-04-16 12:04:37
    包装类(Wrapper Class): Java是一个面向对象的编程语言,但是Java中的八种基本数据类型却是不面向对象的,为了使用方便和解决这个不足,在设计类时为每个基本数据类型设计了一个对应的类进行代表,这样八种基本...
  • 包装类和基本类型

    万次阅读 多人点赞 2019-03-06 09:18:53
    所谓包装类,就是能够直接将简单类型的变量表示为一个类,在执行变量类型的相互转换时,我们会大量使用这些包装类包装类 包装类有以下用途 1.集合不允许存放基本数据类型,故常用包装类 2.包含了每种基本类型的...
  • 八大基本数据类型均有对应的包装类 byte、short、int、long、float、double、char、boolean分别对应Byte、Short、Integer、Long、Float、Double、Character、Boolean 包装类型的出现是为了方便基本数据类型能够和...
  • StringBuilder类与StringBuffer类的异同 StringBuffer,StringBuilder 可以改变变字符串的长度和内容,是一个字符串缓冲区, 在做大量字符串拼接的时候不会开辟新的空间。...包装类 基本数据类型的包装...
  • 包装类是什么 为了对基本数据类型进行更多的操作,更方便的操作,java就针对每一种基本数据类型提供了对应的类类型,称为包装类。 byte——Byte short——Short int——Integer long——Long float——Float ...
  • 这个问题的重心不仅仅在于考察对包装类存在合理性的认识,也在考察对基本数据类型存在意义的理解。 我们都知道在Java语言中,new一个对象存储在堆里,我们通过栈中的引用来使用这些对象。但是对于经常用到的一系列类...
  • java八种基本数据类型及包装类详解

    万次阅读 多人点赞 2018-12-20 10:14:40
    的特征,所以实际使用中很不便所以为java八种基本数据类型提供了对应的包装类。 基本数据类型 对应包装类 包装类的父类 byte java.lang.Byte ...
  • 什么是包装类? java中的基本数据类型如int,double等不是对象,无法通过向上转型获取到Object提供的方法. 而String却可以,因为String是一个对象而不是一个类型。 基本数据类型由于这样的特性,导致无法参与转型,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 516,708
精华内容 206,683
关键字:

包装类的使用