精华内容
下载资源
问答
  • 对比的基本类型
    千次阅读
    2018-04-06 21:09:39

    1、基本型和基本型封装型进行“==”运算符的比较,基本型封装型将会自动拆箱变为基本型

    后再进行比较。

    2、两个Integer类型进行“==”比较,如果其值在-128至127,那么返回true,否则

    返回false, 这跟Integer.valueOf()的缓冲对象有关。

    3、两个基本型的封装型进行equals()比较,首先equals()会比较类型,如果类型相同,则继续

    比较值,如果值也相同,返回true。

    4、基本型封装类型调用equals(),但是参数是基本类型,这时候,先会进行自动装箱,基本型

    转换为其封装类型,再进行比较。

    代码如下:

    public static void main(String[] args) {
    		int i = 12;
    		Integer j = 12;
    		
    		System.out.println(j==i);       // true
    		System.out.println(j.equals(i));  // true
    		
    		Integer jj = 223;
    		Integer kk = 223;
    		
    		System.out.println(jj == kk);      // false
    		System.out.println(kk.equals(jj));  // true
    		
    		Integer m = 23;
    		Integer n = 23;
    		
    		System.out.println(m == n);     // true
    		System.out.println(m.equals(n)); // true
    		
    		Integer mm = new Integer(23);
    		Integer nn = new Integer(23);
    		
    		System.out.println(mm == nn);    // false
    		System.out.println(mm.equals(nn)); // true
    	}

    更多相关内容
  •  基本数据类型是可以用“==”进行比较,而引用数据类型则不可以,一般是通过equals方法来实现比较。 二 、再说说基本数据类型与引用数据类型的区别? 特点: 1、从概念方面来说  基本数据类型:变量名指向具体的...
  • 基本类型的包装类对象使用 == 和 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面试题与答案】整理推荐

     

    展开全文
  • 基本数据类型与其包装类的比较

    千次阅读 2018-02-08 20:15:28
    在java中不能定义基本数据类型对象,为了能将基本数据类型视为对象处理,并且能够调用方法简化其使用过程,java为每个基本类型都提供了包装类。 下面是8种基本数据类型图解 下面是基本数据类型及其包装类对照表...

    最近刷题的时候碰到了不少基本数据类型和包装类进行比较的问题,一开始做的有点蒙,错多了之后就自己整理了一下,特记录下来加深印象。


    在java中不能定义基本数据类型对象,为了能将基本数据类型视为对象处理,并且能够调用方法简化其使用过程,java为每个基本类型都提供了包装类。
    下面是8种基本数据类型图解
    8种基本数据类型
    下面是基本数据类型及其包装类对照表:

    基本数据类型包装类
    intInteger
    byteByte
    shortShort
    longLong
    floatFloat
    doubleDouble
    charChar
    booleanBoolean

    包装类提供了多种常用方法,如下图:
    Integer类的方法
    其中equals方法在本篇中有所涉及,摘录其源码如下:

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

    可以看出,先通过instanceof判断比较对象obj是否是Integer的类实例,如果不是,则return false,若是,则强制转换为Integer类并通过intValue()方法取值,比较调用方法的对象的值和该值是否相等,返回比较结果。
    包装类往往涉及到比较两个对象或者比较对象和基本数据类型的大小的问题。
    下面以最常用的Integer类为例,用程序说明几种判断方式。
    通过总结得到以下四点:
    1.同样被new出的两个相同类型的对象一定是不“==”的,因为==比较的是位置,而new出的对象一定是全新地址的,但是用equals比较时是比较的数值,是相等的。

        Integer a=new Integer(5);
        Integer b=new Integer(5);
        System.out.println(a==b);//return false
        System.out.println(a.equals(b));//return true

    2.在“==”进行比较时,有以下原则:
    1)不用new得到新对象,当要赋的值在区间[-128,127]时,该值会被缓存到IntegerCache.cache中,此时赋值的是同一对象,用“==”比较会返回ture;

        Integer a=5;
        Integer b=5;
        System.out.println(a==b);//return true

    2)当要赋的值在(-∞,-128)或(127,+∞)时,即时不用new得到新对象,用“==”比较也会返回false;

        Integer a=128;
        Integer b=128;
        Integer c=-129;
        Integer d=-129;
        System.out.println(a==b);//return false
        System.out.println(c==d);//return false

    3)当用new赋值时,一定返回false;
    3.当Integer对象与基本类型做比较时,默认将Integer对象做拆箱操作,比较基本类型,而基本类型的比较只与数值有关,因此数值一样就返回true;

        Integer a=new Integer(5);
        int c=5;
        System.out.println(a==c);//return true

    4.若两个Byte对象相加,则会自动升格为int,只能赋值给int或更高精度的类型,因此赋值给Byte一定出错。

            Byte a = new Byte((byte) 5);
            Byte b = new Byte((byte) 5);
            Byte c = a + b;
            /*
             * 报错如下:
             * Type mismatch: cannot convert from int to Byte 
             */

    希望有缺漏的地方各位能够予以补充。

    展开全文
  • 一、基本类型 Java一种静态编程语言,所有变量和表达式是在编译时就确定的。同时,Java又是一种强类型语言,所有的变量和表达式都有具体的类型,并且每种类型是严格定义的。类型限制了变量可以hold什么样的值,...

    一、基本类型

    Java一种静态编程语言,所有变量和表达式是在编译时就确定的。同时,Java又是一种强类型语言,所有的变量和表达式都有具体的类型,并且每种类型是严格定义的。类型限制了变量可以hold什么样的值,表达式最终会产生什么样的值,可以进行哪些操作。在Java中共有8中基本类型数据,同时每种基本类型又有对应的包装类。

    最简单的理解,基本类型有默认值,而包装类型初始为null。然后再根据这两个特性进行分业务使用,在阿里巴巴的规范里所有的POJO类必须使用包装类型,而在本地变量推荐使用基本类型。 

    基本类型介绍

    Java语言提供了八种基本类型。六种数字类型(四个整数型,两个浮点型),一种字符类型,还有一种布尔型。 

    1、整数:包括int、short、byte、long初始值为0。

    2、浮点型:float、double初始值为0.0

    3、字符:char初始值为空格,即'' ",如果输出,在Console上是看不到效果的。

    4、布尔:boolean初始值为false 

    基本型别大小最小值最大值包装类
    boolean----------------Boolean
    char16-bitUnicode 0Unicode 2^16-1Character
    byte8-bit-128+127Byte
    short16-bit-2^15+2^15-1Short
    int32-bit-2^31+2^31-1Integer
    long64-bit-2^63+2^63-1Long
    float32-bitIEEE754IEEE754Float
    double64-bitIEEE754IEEE754Double

     基本类型的运算和相互转换

    基本类型运算

    boolean类型数据可以进行逻辑运算(&&、||、!),其他的基本类型都可以进行数值计算(+、-、*、/、%等)。逻辑运算比较简单易懂,完全与逻辑数学的规则一致。而数值运算涉及到运算后的结果的类型问题,稍微比较复杂一点。一般来说,运算最终结果的类型与表达式中的最大(占用空间最大)的类型。

    long l = 1 + 2L;      // 与1L的类型一致
    int i = 1 + 2L;       //编译不通过
    float f = 1 + 2 + 1.2f;      //与1.2f的类型一致
    double d = 1 + 2 + 1.2;        //与1.2的类型一致

    如果两种相同的类型的数据进行运算,按理来说,运算结果应该还是那个类型。但事实上,bytecharshort等类型是满足这个结论的。

    // 编译不通过,编辑器报:Type mismatch: cannot convert from int to byte 。
    byte s1 = 1;
    byte s2 = 1;
    byte s = s1 + s2;
    
    // 编译不通过,编辑器报:Type mismatch: cannot convert from int to char 。
    char s1 = 1;
    char s2 = 1;
    char s = s1 + s2;
    
    // 编译不通过,编辑器报:Type mismatch: cannot convert from int to short 。
    short s1 = 1;
    short s2 = 1;
    short s = s1 + s2;

    从字面上来看,1+1=2绝对没有超过这个类型的范围。下面的例子都可以编译通过

    byte s1 = 1 + 1;
    char s2 = 1 + 1;
    short s3 = 1 + 1;

    这是因为Java中的数值运算最低要求是int类型,如果参与运算的变量类型都没有超过int类型,则它们都会被自动升级为int类型再进行运算,所以它们运算后的结果类型也是int类型。这种方式所得到结果是否超过了对应类型所表示的范围只能在运行时才能确定,在编译时是无法知晓的。而编译器会直接将byte s1 = 1 + 1编译成byte s1 = 2,这个表达式在编译器就可以确定是合法表达式,故可以通过编译。可以通过字节码来进行佐证。

    short s = 1 + 1;

    上面伪代码所对应的字节码如下,iconst_2表示直接生成常量,然后赋值给s变量。

    Code:
          stack=1, locals=2, args_size=1
             0: iconst_2
             1: istore_1
             2: return

    类型转换

    Java中除了boolean类型之外,其他7中类型相互之间可以进行转换。转换分为自动转换和强制转换。对于自动转换(隐式),无需任何操作,而强制类型转换需要显式转换,即使用转换操作符(type)。7种类型按照其占用空间大小进行排序:

    byte <(short=char)< int < long < float < double

    类型转换的总则是:小可直接转大、大转小会失去精度。这句话的意思是较小的类型直接转换成较大的类型,没有任何印象;而较大的类型也可以转换为较小的类型,但是会失去精度。他们之间的转换都不会抛出任何运行时异常。小转大是Java帮我们自动进行转换的,与正常的赋值操作完全一样;大转小需要进行强制转换操作,其语法是target-type var =(target-type) value。

    // 自动转换
    long l = 10;
    double d = 10;
    float = 10;
    
    // 强制转换
    int a = (int) 1.0;
    char c = (char) a;

    值得注意是,大转小是一个很不安全的动作,可能导致莫名其妙的错误。譬如在下面的代码中,1111111111111L强转成int类型后,其值(-1285418553)与转换前的值相差巨大。这是由于在进行强制转换时,在二进制层面上直接截断,导致结果“面目全非”。

    二、包装类型 

    Java中每一种基本类型都会对应一个唯一的包装类,基本类型与其包装类都可以通过包装类中的静态或者成员方法进行转换。每种基本类型及其包装类的对应关系如下,值得注意的是,所有的包装类都是final修饰的,也就是它们都是无法被继承和重写的。

    包装类与基本类型的转换

    基本类型------>包装器类
    Integer obj=new Integer(145);
    
    包装器类------>基本类型
    int num=obj.intValue();
    
    字符串------>包装器类
    Integer obj=new Integer("-45.36");
    
    包装器类------>字符串包装器类
    String str=obj.toString();
    
    字符串------>基本类型
    int num=Integer.parseInt("-45.36");
    
    基本类型------>字符串包装器类
    String str=String.valueOf(5);

     

     “莫名其妙”的NullPointException在笔者开发经历中,碰到过不少因为请求参数或者接口定义字段设置为int(或者其他基本类型)而导致NullPointException。代码大致地运行步骤如下所示,当然不会跟这个完全一样。

    Integer a =null;...intb = a;// 抛出NullPointException上面的代码可以编译通过,但是会抛出空指针异常(NullPointException)。前面已经说过了,int b = a实际上是int b = a.intValue(),由于a的引用值为null,在空对象上调用方法就会抛出NullPointException。

    三、拆箱与装箱 

    JDK1.5的新特性:自动装包/拆包(Autoboxing/unboxing)

      自动装包/拆包大大方便了基本类型数据和它们包装类地使用。

      自动装包:基本类型自动转为包装类.(int >> Integer)

      自动拆包:包装类自动转为基本类型.(Integer >> int)

      在JDK1.5之前,我们总是对集合不能存放基本类型而耿耿于怀,现在自动转换机制解决了我们的问题。

    Java作为一种强类型的语言,对象直接赋值给引用类型变量,而基础数据只能赋值给基本类型变量,这个是毫无异议的。那么基本类型和包装类型为什么可以直接相互赋值呢?这其实是Java中的一种“语法糖”。“语法糖”是指计算机语言中添加的某种语法,这种语法对语言的功能并没有影响,但是更方便程序员使用。通常来说使用语法糖能够增加程序的可读性,从而减少程序代码出错的机会(来自百度百科)。换句话说,这其实是一种障眼法,那么实际上是怎么样的呢?下面是Integer a = 1;语句编译的字节码。

    0: iconst_1
    1: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
    4: astore_1

    首先,生成一个常量1,然后调用Integer.valueOf(int)方法返回Integer对象,最后将对象的地址(引用)赋值给变量a。Integer a = 1;其实相当于Integer a = Integer.valueOf(1);。其他的也类似,比如Double、Character,不相信的朋友可以自己手动尝试一下。

    Integer

    在Java中,“==”符号判断的内存地址所对应的值得相等性,具体来说,基本类型判断值是否相等,引用类型判断其指向的地址是否相等。看看下面的代码,两种类似的代码逻辑,但是得到截然不用的结果。

    Integer a1 = 1;
    Integer a2 = 1;
    System.out.println(a1 == a2); // true
    
    Integer b1 = 222;
    Integer b2 = 222;
    System.out.println(b1 == b2); // false

     这个必须从源代码中才能找到答案。Integer类中的valueOf()方法的源代码如下:

    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high) // 判断实参是否在可缓存范围内,默认为[-128, 127]
            return IntegerCache.cache[i + (-IntegerCache.low)]; // 如果在,则取出初始化的Integer对象
        return new Integer(i); // 如果不在,则创建一个新的Integer对象
    }

    由于1属于[-128, 127]集合范围内,所以valueOf()每次都会取出同一个Integer对象,故第一个“==”判断结果为true;而222不属于[-128, 127]集合范围内,所以valueOf()每次都会创建一个新的Integer对象,由于两个新创建的对象的地址不一样,故第一个“==”判断结果为false。 

    Double

    下面这段代码的输出结果又为什么不一样呢? 

            Double i1 = 100.0;
            Double i2 = 100.0;
            System.out.println(i1==i2);   //false
    
            Double i3 = 200.0;
            Double i4 = 200.0;       
            System.out.println(i3==i4);   //false

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

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

    Boolean

    下面这段代码输出结果又是什么?

            Boolean i1 = false;
            Boolean i2 = false;
            System.out.println(i1==i2);     //true
    
            Boolean i3 = true;
            Boolean i4 = true;         
            System.out.println(i3==i4);     //true

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

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

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

    public static final Boolean TRUE = new Boolean(true);
    
    public static final Boolean FALSE = new Boolean(false);

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

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

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

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

    • 1)第一种方式不会触发自动装箱的过程;而第二种方式会触发;
    • 2)在执行效率和资源占用上的区别。第二种方式的执行效率和资源占用在一般性情况下要优于第一种情况(注意这并不是绝对的)。

    再来看看这个题,加深对装箱拆箱操作的理解

            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);            //true
            System.out.println(e==f);            //false
            System.out.println(c==(a+b));        //true
            System.out.println(c.equals(a+b));   //true
            System.out.println(g==(a+b));        //true
            System.out.println(g.equals(a+b));   //false
            System.out.println(g.equals(a+h));   //true

    注意:

    • 当 "=="运算符的两个操作数都是 包装器类型的引用,则是比较指向的是否是同一个对象
    • 如果其中有一个操作数是表达式(即包含算术运算)则比较的是数值(即会触发自动拆箱的过程)
    • 对于包装器类型,equals方法并不会进行类型转换

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

    三、基本类型与包装类型的异同 

    1、在Java中,一切皆对象,但八大基本类型却不是对象。

    2、声明方式的不同,基本类型无需通过new关键字来创建,而封装类型需new关键字。

    3、存储方式及位置的不同,基本类型是直接存储变量的值保存在堆栈中能高效的存取,封装类型需要通过引用指向实例,具体的实例保存在堆中。

    4、初始值的不同,封装类型的初始值为null,基本类型的的初始值视具体的类型而定,比如int类型的初始值为0,boolean类型为false;

    5、使用方式的不同,比如与集合类合作使用时只能使用包装类型。

    6、什么时候该用包装类,什么时候用基本类型,看基本的业务来定:这个字段允不允许null值,如果允许null值,则必然要用封装类,否则值类型就可以了,用到比如泛型和反射调用函数.,就需要用包装类! 

    展开全文
  • 基本数据类型和封装类型的区别

    千次阅读 多人点赞 2019-09-23 13:27:34
    基本数据类型和封装类型的区别基本数据类型基本数据类型介绍封装数据类型基本数据类型对应的封装类介绍基本数据类型与封装类对应关系对照表String类他们的区别总结合理的创建标题,有助于目录的生成如何改变文本的...
  • 基本类型和包装类型的区别详解

    千次阅读 多人点赞 2019-11-30 22:20:01
    他当时扔了一个面试题把我砸懵了:说说基本类型和包装类型的区别吧。 我当时二十三岁,正值青春年华,从事 Java 编程已有 N 年经验(N < 4),自认为所有的面试题都能对答如流,结果没想到啊,被“刁难”了——...
  • java中引用类型和基本类型的区别

    千次阅读 2022-05-09 20:53:58
    java中引用类型和基本类型的区别 一、数据类型 1.基本类型 基本数据类型只有8种,可按照如下分类 ①整数类型:long、int、short、byte ②浮点类型:float、double ③字符类型:char ④布尔类型:boolean 2.引用类型...
  • 其中,前面 7 个被称为基本类型,又叫原始类型(Primitive Type); object,被称为引用类型(Reference Type),或叫做对象类型(Object Type)。 区别 基本类型在栈中存储,而引用类型对象部分在堆中存储,栈中...
  • 基本类型与包装类型

    千次阅读 2018-12-14 21:48:08
    阿里开发手册中关于基本类型的问题 7. 【强制】所有的相同类型的包装类对象之间值的比较,全部使用equals方法比较。 说明:对于Integer var = ? 在-128至127范围内的赋值,Integer对象是在IntegerCache.cache产生...
  • QML 基本类型

    千次阅读 2019-01-08 08:07:34
    QML 有许多基本类型,例如整型int或字符串类型string,这和 QML 对象类型形成对比,QML 对象类型是指具有属性、信号、方法等的对象,与对象类型不同的是,基本类型不能用于声明 QML 对象,例如不能声明 int{}对象或...
  • C语言数据的基本类型

    千次阅读 2021-05-19 13:44:11
    现在大家只需要学习一下基本类型。其他三种类型更适合在后续分享相关知识点时详细介绍。1.整型整型很好理解,就是整数类型,比如1,2,3,4,5,100等等,这些整数都属于整型数据,而且是无符号的(正数都可以理解为...
  • Java基本数据类型比较

    千次阅读 2018-03-27 18:51:46
    可以比较基本数据类型 , 也可以比较引用数据类型 equals: 只能比较引用数据类型, 默认比较的是地址值*(string类中重写了eqals方法),如果我们想建立自己的比较方式, 需要重写equals方法通过对比字符串比较来理解,...
  • 面试官:兄弟,说说基本类型和包装类型的区别吧

    万次阅读 多人点赞 2019-09-29 08:36:07
    Java 的每个基本类型都对应了一个包装类型,比如说 int 的包装类型为 Integer,double 的包装类型为 Double。基本类型和包装类型的区别主要有以下 4 点。
  • 八大基本数据类型大小比较

    千次阅读 2020-11-12 10:39:54
    位和字节 1.bit就是位,也叫比特位,是计算机表示数据最小的单位 2.byte就是字节 3.1byte=8bit 。 整型 byte: 1字节 short: 2字节 int: 4字节 long:8字节 ...boolean:只有true和false两种取值(执行或不执行) ...
  • 基本类型和引用类型的区别

    千次阅读 2021-08-31 22:12:19
    基本类型存在栈中,引用类型在栈中存的是堆地址,具体数据存于堆中 2. 使用方式不同 基本类型可以使用所有的运算符进行处理 引用类型只可以使用运算符==和!=,但是可以使用方法和属性 3. 作为方法参数时的效果...
  • 基本类型和包装类型的区别

    千次阅读 2019-11-06 17:26:13
    数据类型 默认值 byte 0 short 0 int 0 long 0L float 0.0f double ...2.包装类型可以为 null,而基本类型不可以 在第一点我们说了,基本类型有初始值,而包装类型的默认值是null。而...
  • 基本类型和引用类型区别

    千次阅读 2020-03-13 16:13:28
    1.基本类型包括: string,number,boolean,null,undefined,symbol 2.引用类型包括: Function,Array,Object 基本类型和引用类型也有人叫原始类型和对象类型,拥有方法的类型和不能拥有方法的类型,可变类型和不可...
  • Java 基本数据类型存储位置

    万次阅读 多人点赞 2018-11-05 10:48:13
    Java 基本数据类型 及 == 与 equals 方法的区别 转载地址:https://www.cnblogs.com/Latiny/p/8099581.html  Java数据类型分为基本数据类型与引用数据类型。    1 基本数据类型 byte:Java中最小的数据类型...
  • python基本类型介绍

    千次阅读 2018-09-19 16:46:34
    之前一直觉得语言这东西,只要懂点语法,会用就行。然而昨天百度的面试,让我对此有了...python的基本数据类型有Number(数字)、String(字符串)、Tuple(元组)、List(列表)、Dictionary(字典)、Set(集合)...
  • 基本类型通过==比较的是它们的值大小,而引用类型比较的是他们的引用地址。 基本类型和包装类型通过==比较的是值的大小,通过equals比较的也是值得大小。 public boolean equals(Object obj) { if (obj ...
  • js基本类型

    千次阅读 2021-06-09 16:19:21
    1.JavaScript(以下简称js)的数据类型分为两种:原始类型(即基本数据类型)和对象类型(即引用数据类型); 2.js常用的基本数据类型包括undefined、null、number、boolean、string; 3.js的引用数据类型也就是...
  • Java的基本类型

    万次阅读 2021-12-17 21:25:42
    文章目录前言Java 虚拟机的 boolean 类型Java 的基本类型 前言 如果你了解面向对象语言的发展史,那你可能听说过 Smalltalk 这门语言。它的影响力之大,以至于之后诞生的面向对象语言,或多或少都借鉴了它的设计和...
  • java基本类型与引用类型

    万次阅读 多人点赞 2018-01-04 17:30:32
    java基本类型与引用类型 目录 java基本类型与引用类型 目录 一基本数据类型 二引用类型 三基本类型与引用类型的区别 默认值 内存分配 自动装箱自动拆箱 自动装箱拆箱带来的问题 程序的性能 空指针异常 ...
  • java中的基本类型包装类

    千次阅读 2022-01-19 18:16:43
    2.我们都有基本类型了,为什么还要去定义这些包装类呢? Java语言是一个面向对象的语言,但是Java中的基本数据类型却是不面向对象的,这在实际使用时存在很多的不便,为了解决这个不足,在设计类时为每个基本数据...
  • 在 Java中共有8种基本类型数据,同时每种基本类型又有对应的包装类。 基本数据类型(默认值) 包装类(默认值) 取值范围 byte (0) Byte (null) -128~127 short (0) Short(null) -32768~...
  • 基本数据类型比较是值的比较var a = '{}'var b = '{}'console.log(a == b) //true直接比较值,看起来一样那么他就是一样的。2.引用类型比较是引用的比较var a = {}var b = {}console.log(a == b) //false问:看...
  • 作为面Java为什么要有基本数据类型和包装类型? 这个问题看似简单,其实也不好回答。毕竟这个问题不仅你我感觉到困惑,许多大佬也感觉到困惑,一些人希望把基本数据类型剔除,一些人希望继续保留。 ...
  • C语言中基本的数据类型有哪些

    万次阅读 2021-05-19 13:45:07
    C语言中基本的数据类型有哪些发布时间:2020-11-26 15:10:13来源:亿速云阅读:76作者:Leah本篇文章给大家分享的是有关C语言中基本的数据类型有哪些,小编觉得挺实用的,因此分享给大家学习,希望大家阅读完这篇...
  • String是java中的基本数据类型

    千次阅读 2021-02-26 15:45:32
    1. 首先String不属于8种基本数据类型,String是一个对象。因为对象的默认值是null,所以String的默认值也是null;但它又是一种特殊的对象,有其它对象没有的一些特性。2.Java代码new String()和new String(“”)都是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,726,806
精华内容 690,722
热门标签
关键字:

对比的基本类型