精华内容
下载资源
问答
  • * 基本类型 可不指定 * 用于复杂类型 eg: Object | List<Object> * @return */ Class<?> classType() default void.class; /** * 是否是集合类型 * 如果是集合类型必须指定其 * 1. 集合中存放...
  • 面试官:兄弟,说说基本类型和包装类型的区别吧

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

    六年前,我从苏州回到洛阳,抱着一幅“海归”的心态,投了不少简历,也“约谈”了不少面试官,但仅有两三个令我感到满意。其中有一位叫老马,至今还活在我的手机通讯录里。他当时扔了一个面试题把我砸懵了:说说基本类型和包装类型的区别吧。

    我当时二十三岁,正值青春年华,从事 Java 编程已有 N 年经验(N < 4),自认为所有的面试题都能对答如流,结果没想到啊,被“刁难”了——原来洛阳这块互联网的荒漠也有技术专家啊。现在回想起来,脸上不自觉地泛起了羞愧的红晕:主要是自己当时太菜了。不管怎么说,是时候写篇文章剖析一下基本类型和包装类型的区别了。

    Java 的每个基本类型都对应了一个包装类型,比如说 int 的包装类型为 Integer,double 的包装类型为 Double。基本类型和包装类型的区别主要有以下 4 点。

    01、包装类型可以为 null,而基本类型不可以

    别小看这一点区别,它使得包装类型可以应用于 POJO 中,而基本类型则不行。

    POJO 是什么呢?这里稍微说明一下。

    POJO 的英文全称是 Plain Ordinary Java Object,翻译一下就是,简单无规则的 Java 对象,只有属性字段以及 setter 和 getter 方法,示例如下。

    class Writer {
    	private Integer age;
    	private String name;
    
    	public Integer getAge() {
    		return age;
    	}
    
    	public void setAge(Integer age) {
    		this.age = age;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    }
    

    和 POJO 类似的,还有数据传输对象 DTO(Data Transfer Object,泛指用于展示层与服务层之间的数据传输对象)、视图对象 VO(View Object,把某个页面的数据封装起来)、持久化对象 PO(Persistant Object,可以看成是与数据库中的表映射的 Java 对象)。

    那为什么 POJO 的属性必须要用包装类型呢?

    《阿里巴巴 Java 开发手册》上有详细的说明,我们来大声朗读一下(预备,起)。

    数据库的查询结果可能是 null,如果使用基本类型的话,因为要自动拆箱(将包装类型转为基本类型,比如说把 Integer 对象转换成 int 值),就会抛出 NullPointerException 的异常。

    02、包装类型可用于泛型,而基本类型不可以

    泛型不能使用基本类型,因为使用基本类型时会编译出错。

    List<int> list = new ArrayList<>(); // 提示 Syntax error, insert "Dimensions" to complete ReferenceType
    List<Integer> list = new ArrayList<>();
    

    为什么呢?因为泛型在编译时会进行类型擦除,最后只保留原始类型,而原始类型只能是 Object 类及其子类——基本类型是个特例。

    03、基本类型比包装类型更高效

    基本类型在栈中直接存储的具体数值,而包装类型则存储的是堆中的引用。

    很显然,相比较于基本类型而言,包装类型需要占用更多的内存空间。假如没有基本类型的话,对于数值这类经常使用到的数据来说,每次都要通过 new 一个包装类型就显得非常笨重。

    03、两个包装类型的值可以相同,但却不相等

    两个包装类型的值可以相同,但却不相等——这句话怎么理解呢?来看一段代码就明明白白了。

    Integer chenmo = new Integer(10);
    Integer wanger = new Integer(10);
    
    System.out.println(chenmo == wanger); // false
    System.out.println(chenmo.equals(wanger )); // true
    

    两个包装类型在使用“”进行判断的时候,判断的是其指向的地址是否相等。chenmo 和 wanger 两个变量使用了 new 关键字,导致它们在“”的时候输出了 false。

    chenmo.equals(wanger) 的输出结果为 true,是因为 equals 方法内部比较的是两个 int 值是否相等。源码如下。

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

    瞧,虽然 chenmo 和 wanger 的值都是 10,但他们并不相等。换句话说就是:将“==”操作符应用于包装类型比较的时候,其结果很可能会和预期的不符

    04、自动装箱和自动拆箱

    既然有了基本类型和包装类型,肯定有些时候要在它们之间进行转换。把基本类型转换成包装类型的过程叫做装箱(boxing)。反之,把包装类型转换成基本类型的过程叫做拆箱(unboxing)。

    在 Java SE5 之前,开发人员要手动进行装拆箱,比如说:

    Integer chenmo = new Integer(10);  // 手动装箱
    int wanger = chenmo.intValue();  // 手动拆箱
    

    Java SE5 为了减少开发人员的工作,提供了自动装箱与自动拆箱的功能。

    Integer chenmo  = 10;  // 自动装箱
    int wanger = chenmo;     // 自动拆箱
    

    上面这段代码使用 JAD 反编译后的结果如下所示:

    Integer chenmo = Integer.valueOf(10);
    int wanger = chenmo.intValue();
    

    也就是说,自动装箱是通过 Integer.valueOf() 完成的;自动拆箱是通过 Integer.intValue() 完成的。理解了原理之后,我们再来看一道老马当年给我出的面试题。

    // 1)基本类型和包装类型
    int a = 100;
    Integer b = 100;
    System.out.println(a == b);
    
    // 2)两个包装类型
    Integer c = 100;
    Integer d = 100;
    System.out.println(c == d);
    
    // 3)
    c = 200;
    d = 200;
    System.out.println(c == d);
    

    答案是什么呢?有举手要回答的吗?答对的奖励一朵小红花哦。

    第一段代码,基本类型和包装类型进行 == 比较,这时候 b 会自动拆箱,直接和 a 比较值,所以结果为 true。

    第二段代码,两个包装类型都被赋值为了 100,这时候会进行自动装箱,那 == 的结果会是什么呢?

    我们之前的结论是:将“==”操作符应用于包装类型比较的时候,其结果很可能会和预期的不符。那结果是 false?但这次的结果却是 true,是不是感觉很意外?

    第三段代码,两个包装类型重新被赋值为了 200,这时候仍然会进行自动装箱,那 == 的结果会是什么呢?

    吃了第二段代码的亏后,是不是有点怀疑人生了,这次结果是 true 还是 false 呢?扔个硬币吧,哈哈。我先告诉你结果吧,false。

    为什么?为什么?为什么呢?

    事情到了这一步,必须使出杀手锏了——分析源码吧。

    之前我们已经知道了,自动装箱是通过 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);
    }
    

    难不成是 IntegerCache 在作怪?你猜对了!

    private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];
    
        static {
            // high value may be configured by property
            int h = 127;
            int i = parseInt(integerCacheHighPropValue);
            i = Math.max(i, 127);
            h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
            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;
        }
    }
    

    大致瞟一下这段代码你就全明白了。-128 到 127 之间的数会从 IntegerCache 中取,然后比较,所以第二段代码(100 在这个范围之内)的结果是 true,而第三段代码(200 不在这个范围之内,所以 new 出来了两个 Integer 对象)的结果是 false。

    看完上面的分析之后,我希望大家记住一点:当需要进行自动装箱时,如果数字在 -128 至 127 之间时,会直接使用缓存中的对象,而不是重新创建一个对象

    自动装拆箱是一个很好的功能,大大节省了我们开发人员的精力,但也会引发一些麻烦,比如下面这段代码,性能就很差。

    long t1 = System.currentTimeMillis();
    Long sum = 0L;
    for (int i = 0; i < Integer.MAX_VALUE;i++) {
        sum += i;
    }
    long t2 = System.currentTimeMillis();        
    System.out.println(t2-t1);
    

    sum 由于被声明成了包装类型 Long 而不是基本类型 long,所以 sum += i 进行了大量的拆装箱操作(sum 先拆箱和 i 相加,然后再装箱赋值给 sum),导致这段代码运行完花费的时间足足有 2986 毫秒;如果把 sum 换成基本类型 long,时间就仅有 554 毫秒,完全不一个等量级啊。

    05、最后

    谢谢大家的阅读,原创不易,喜欢就点个赞,这将是我最强的写作动力。如果你觉得文章对你有所帮助,也蛮有趣的,就关注一下我的公众号,谢谢。

    展开全文
  • java引用类型和基本类型比较

    千次阅读 2017-07-18 23:37:24
    当两个基本类型使用”==”比较时,他们比较的是值。 当两个引用类型使用”==”比较时,他们比较的是地址。 当两个引用类型使用方法equals()比较时,他们比较的是值。但当基本类型和他的包装类(引用类型)使用”==...

    引用类型和基本类型的分类,不在写了,网上有很多。

    我们知道:
    当两个基本类型使用”==”比较时,他们比较的是
    当两个引用类型使用”==”比较时,他们比较的是地址
    当两个引用类型使用方法equals()比较时,他们比较的是

    但当基本类型和他的包装类(引用类型)使用”==”比较时,
    他们的结果又是如何呢?

    下面我们使用Integer和int进行说明。
    Integer是int的包装类。 int 基本类型, Integer 为引用类型。
    看个例子:

    int i = 1234;
    Integer i1 = new Integer(1234);
    Integer i2 = new Integer(1234);
    System.out.print("i1 == i2 : "+(i1 == i2));
    System.out.println("\ti1.equals(i2) : "+(i1.equals(i2)));
    System.out.print("i == i1 : "+(i == i1));
    System.out.println("\t\ti1.equals(i) : "+(i1.equals(i)));
    System.out.print("i == i2 : "+(i == i2));
    System.out.println("\t\ti2.equals(i) : "+(i2.equals(i)));

    打印:
    i1 == i2 : false i1.equals(i2) : true
    i == i1 : true i1.equals(i) : true
    i == i2 : true i2.equals(i) : true

    我们可以看到 i == i1, i == i2, i1 != i2,
    但使用equals()他们都是相等的。

    接着我们来看看jdk1.8中Integer类中的方法equals()

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

    可以观察到使用equals(),他们比较的是

    总结:当比较基本类型和他的包装类(引用类型)使用”==”和方法equals()比较时,他们比较的都是

    Integer和其它基本类型都相同,大家有兴趣可以去证明,在此我都不在写了。

    展开全文
  • new Double(100) == new Double(100) 为false用new Double(100).doubleValue() == new Double(100).doubleValue() 为true 或者用equals,Double重写了object的equals方法,可以进行值比较基本类型的封装类都重写了...

    new Double(100)  == new Double(100)    为false

    用new Double(100).doubleValue()  == new Double(100).doubleValue()  为true 

    或者用equals,Double重写了object的equals方法,可以进行值比较


    基本类型的封装类都重写了equals方法,进行值比较

    展开全文
  • java中基本类型与装箱基本类型“==”比较出现的几种情况java有一个类型系统有两部分组成,包含基本类型(primitive),例如:int、double等,还有引用类型(reference type),例如:String、List。每个基本类型都有...

    java中基本类型与装箱基本类型“==”比较出现的几种情况

    java有一个类型系统有两部分组成,包含基本类型(primitive),例如:int、double等,还有引用类型(reference type),例如:String、List。每个基本类型都有一个对应的引用类型,称为装箱基本类型(boxed promitive)。装箱基本类型中对应于int、double的是Integer、Double。

    Java 1.5发行版本中增加了自动装箱和自动拆箱,自动装箱和自动拆箱就是我们所知道的“语法糖”,这些特性模糊了但并没有完全抹去基本类型和装箱基本类型之间的区别。这两种类型之间真正是有差别的,要很清楚的使用的是哪种类型,并且要对这两种类型进行谨慎的选择,这些都非常重要。

    在基本类型和装箱类型之间有三个主要区别。

    • 第一:基本类型只有值,而装箱基本类型则具有与他们的值不同的同一性。换句话说,两个装箱基本类型可以具有相同的值和不同的同一性。
    • 第二:基本类型只有功能完备的值,而每个装箱基本类型除了它对应基本类型的所有功能值之外,还有个非功能值:null。
    • 第三:基本类型通常比装箱基本类型更节省时间和空间。

    如果你不小心上面的三点,这三点区别都会让你陷入麻烦之中。

    先看一个简单的例子程序

    如下

    package com.wrh.firstpro;
    
    public class EqualsDemo06 {
    
        public static void main(String[] args) {
            System.out.println(myCompare(new Integer(4),new Integer(4)));
        }
        public static int myCompare(Integer i1,Integer i2){
    
            return i1<i2?-1:((i1==i2)?0:1);
        }
    
    }
    

    程序的输出结果是:1
    但是这两个Integer实例都是表示相同的值4,为什么函数myCompare返回的是1,而不是我们想象中的0呢?
    原因如下:此分析参考《Effective Java中文版》第49条

    对表达式 i1<i2执行计算会导致first和second引用的Integer实例被自动拆箱;也就是说,它提取了他们的基本类型值。计算动作要检查产生的第一个int值是否小于第二个。答案是否定的。下一个测试就是执行计算表达式i1==i2,它在两个对象上执行同一性的比较。如果i1和i2引用表示同一个int值的不同的Integer的实例,这个比较操作就会返回false,因此此函数错误的返回:1;

    但是,我将这个文件生成的.class文件反编译后,代码如下:

    package com.wrh.firstpro;
    
    import java.io.PrintStream;
    
    public class EqualsDemo06
    {
      public static void main(String[] paramArrayOfString)
      {
        System.out.println(myCompare(new Integer(4), new Integer(4)));
      }
    
      public static int myCompare(Integer paramInteger1, Integer paramInteger2) {
        return paramInteger1 == paramInteger2 ? 0 : paramInteger1.intValue() < paramInteger2.intValue() ? -1 : 1;
      }
    }

    发现,编译器将return i1<i2?-1:((i1==i2)?0:1);变成了

    return paramInteger1 == paramInteger2 ? 0 : paramInteger1.intValue() < paramInteger2.intValue() ? -1 : 1;

    因此,我们根据反编译后的代码分析运行结果:1的原因如下:先进行两个Integer实例的同一性分析,不相等,然后通过Integer.intValue()将两个Integer实例自动拆箱来比较大小,由于这两个Integer实例表示相同的数值,因此,得到结果1

    修正上面这个问题的方法如下:
    添加两个int型的中间变量,在这些中间变量上执行所有的比较操作可以避免同一性的比较。

    public static int myCompare(Integer i1,Integer i2){
            int temp1=i1;
            int temp2=i2;
            return temp1<temp2?-1:((temp1==temp2)?0:1);
        }

    对封装基本类型引用==操作符几乎总是错误的

    第一个例子程序:两个都是通过new出来的Integer的实例进行“==”比较

    package com.wrh.firstpro;
    
    public class EqualsDemo02 {
    
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            Integer i7=new Integer(4);
            Integer i8=new Integer(4);
            System.out.println("i7==i8?"+(i7==i8));
            System.out.println("i7.equals(i8)?"+i7.equals(i8));
        }
    
    }

    运行结果如下:

    i7==i8?false
    i7.equals(i8)?true

    反编译的代码如下:

    public class EqualsDemo02
    {
      public static void main(String[] paramArrayOfString)
      {
        Integer localInteger1 = new Integer(4);
        Integer localInteger2 = new Integer(4);
        System.out.println(new StringBuilder().append("i7==i8?").append(localInteger1 == localInteger2).toString());
        System.out.println(new StringBuilder().append("i7.equals(i8)?").append(localInteger1.equals(localInteger2)).toString());
      }
    }

    产生这个的原因在于应用“==”对两个new出来的Integer类型的实例进行比较时,即时表示相同的数值,由于Integer类型的数据进行比较还要进行同一性的比较,因此不相等。而equals的比较结果是与我们的预期是一样的。

    总结:应用“==”对两个new出来的Integer类型的实例进行比较时,即时表示相同的数值,由于Integer类型的数据进行比较还要进行同一性的比较,因此不相等

    第二个例子程序:两个通过自动装箱得到的Integer实例进行“==”比较

    在继续往下面来看

    package com.wrh.firstpro;
    
    public class EqualsDemo03 {
    
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            Integer i3=3;
            Integer i4=3;
            System.out.println(i3==i4);
            System.out.println(i3.equals(i4));
    
        }
    
    }
    

    运行结果如下:

    true
    true

    与上一个例子相比的区别在于将

    Integer i7=new Integer(4);
    Integer i8=new Integer(4);

    换成了

    Integer i3=3;
    Integer i4=3;

    就导致了该程序的运用==比较时,判断是相等的,即Integer i3=3;Integer i4=3;使得i3、i4的同一性的相同的。
    总结:通过“==”比较两个自动装箱的Integer实例时,只要两者所表示的数值时相同的,结果就是相等的,因此他们的同一性是相同的。

    上面例子的反编译代码如下

    
    public class EqualsDemo03
    {
      public static void main(String[] paramArrayOfString)
      {
        Integer localInteger1 = Integer.valueOf(3);
        Integer localInteger2 = Integer.valueOf(3);
        System.out.println(localInteger1 == localInteger2);
        System.out.println(localInteger1.equals(localInteger2));
      }
    }

    第三个例子程序:一个是通过new出来的Integer实例,一个是自动装箱而得到的Integer实例进行“==”比较

    程序如下:

    package com.wrh.firstpro;
    
    public class EqualsDemo07 {
    
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            Integer i1=1;
            Integer i2=new Integer(1);
            System.out.println(i1==i2);
            System.out.println(i2.equals(i1));
    
        }
    
    }
    

    程序运行结果如下:

    false
    true

    结果比较好理解,这里不再分析。

    第四个例子程序:“==”左右两边都是Integer实例存在运算符运算的比较

    继续来看例子

    package com.wrh.firstpro;
    
    public class EqualsDemo04 {
    
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            Integer i1=1;
            Integer i2=2;
            Integer i3=3;
            System.out.println(i3==(i1+i2));
            System.out.println(i3.equals(i1+i2));
    
        }
    
    }
    

    运行结果如下

    true
    true

    即上面的比较都是先进行自动拆箱后然后进行数值上大小的比较

    通过反编译后的代码相信就可以很好的分析出答案了,代码如下

    public class EqualsDemo04
    {
      public static void main(String[] paramArrayOfString)
      {
        Integer localInteger1 = Integer.valueOf(1);
        Integer localInteger2 = Integer.valueOf(2);
        Integer localInteger3 = Integer.valueOf(3);
        System.out.println(localInteger3.intValue() == localInteger1.intValue() + localInteger2.intValue());
        System.out.println(localInteger3.equals(Integer.valueOf(localInteger1.intValue() + localInteger2.intValue())));
      }
    }

    总结:包装类的“==”运算在遇到算术运算的情况下会自动拆箱,进行其代表的数值大小的比较

    第五个例子程序

    package com.wrh.firstpro;
    
    public class EqualsDemo05 {
    
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            Integer i6=4;
            Long    i5=4L;
            //System.out.println(i5==i6);//不能编译,Integer类型和Long类型不能用“==”比较
            System.out.println(i6.equals(i5));
        }
    
    }
    

    运行结果是:false,这个结果比较好理解

    反编译后的代码如下:

    public class EqualsDemo05
    {
      public static void main(String[] paramArrayOfString)
      {
        Integer localInteger = Integer.valueOf(4);
        Long localLong = Long.valueOf(4L);
    
        System.out.println(localInteger.equals(localLong));
      }
    }

    总结

    (1)反编译的代码中Integer.valueOf()和Integer.intValue()进行了自动装箱和自动拆箱。
    (2)应用“==”对两个new出来的Integer类型的实例进行比较时,即时表示相同的数值,由于Integer类型的数据进行比较还要进行同一性的比较,因此不相等
    (3)通过“==”比较两个自动装箱的Integer实例时,只要两者所表示的数值时相同的,结果就是相等的,因此他们的同一性是相同的。
    (4)通过equals来对来比较的时候,只要同类型(包括能自动装箱和拆箱)代表的数值时相同的,就是相等的。

    其它类型与Integer类型的自动装箱和拆箱的原理相同,这里不再赘述。

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

    千次阅读 2019-04-24 17:41:19
    基本数据类型的包装类型比较分为两种类型: 相同类型比较 Number类型比较时,只要有一个调用了拆箱,就可以用“==”比较,无论是调用intValue还是longValue。当然对于包装类的比较,建议使用equals比较。 Integer ...
  • QML 基本类型

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

    万次阅读 多人点赞 2018-01-04 17:30:32
    java基本类型与引用类型 目录 java基本类型与引用类型 目录 一基本数据类型 二引用类型 三基本类型与引用类型的区别 默认值 内存分配 自动装箱自动拆箱 自动装箱拆箱带来的问题 程序的性能 空指针异常 ...
  • 基本类型的包装类对象使用 == 和 equals进行比较的结果 1、值不同,使用==和equals比较都返回false 2、值相同 使用==比较基本类型基本类型基本类型-包装对象返回true 包装对象-包装对象返回...
  • 基本类型通过==比较的是它们的值大小,而引用类型比较的是他们的引用地址。 基本类型和包装类型通过==比较的是值的大小,通过equals比较的也是值得大小。 public boolean equals(Object obj) { if (obj ...
  • Java:简述Java数据类型(基本类型,对象类型)之间的比较       Java的数据类型分为两种: 基本类型:byte(8),short(16),int(32),long(64),float(32),double(64),char(16),boolean(1)...
  • 基本数据类型与其包装类的比较

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

    千次阅读 2015-06-20 17:02:54
    **Delphi与JAVA基本数据类型对比**
  • Java 基本类型 和 对象类型 比较

    千次阅读 2014-05-02 19:38:15
    Java 不同类型数据之间的比较,要注意
  • Java基本类型比较与哈希处理

    千次阅读 2018-03-20 21:58:18
    Java基本类型有byte, short , long ,int ,char , double , float,boolean基本类型比较看似简单,其实涉及的知识还是比较零散的,在JVM体系中,基本类型是存放在堆栈的栈区,栈对于线程来说是私有的变量。...
  • 基本类型long,用==直接比较内容大小 包装类型Long,自动装箱的时候调用Long.valueOf()方法,将long转成Long,如果是-128到127的范围内,取缓存。 public static void main(String[] args) throws Exception { ...
  • 基本类型中,两个数值之间的比较==和equals()方法,比较的都是两个操作数的地址,地址相同,则返回值为true。在对象中,不管是自己写的对象还是java中已经有的对象,如果这个类对象复写了继承自Object类的equals()...
  • Java基本数据类型比较

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

    千次阅读 2016-05-25 11:11:17
    java基本类型与包装类型 基本数据类型:byte,int, short, long, boolean,char, float,double等 包装类型 : Byte,Integer,Short,Long,Boolean,Character,Float,Double等 基本类型(primitive type)...
  • Java基本数据类型类型转换

    千次阅读 多人点赞 2019-12-10 23:39:00
    本文关键字:8种、基本数据类型、整数类型、浮点类型、字符类型、布尔类型
  • Java 基本类型与引用类型

    千次阅读 2019-03-27 20:55:51
    Java 基本类型与引用类型 一、基本数据类型 java 中一共分为 8 种基本数据类型:byte、short、int、long、float、double、char、boolean, 其中 byte、short、int、long 是整型。float、double 是浮点型,char 是...
  • 基本数据类型和包装类进行比较

    千次阅读 2018-08-16 09:46:46
    1、基本型和基本型封装型进行“==”运算符的比较基本型封装型将会自动拆箱变为基本型后再进行比较,因此Integer(0)会自动拆箱为int类型再进行比较,显然返回true;  int a = 220;  Integer b = 220;  System...
  • (1)对于字符串变量来说,使用“==”和“equals()”方法比较字符串时,其比较方法不同。  “==”比较两个变量本身的值,即两个对象在内存中的首地址。  “equals()”比较字符串中所包含的内容是否相同。  ...
  • 使用Java的包装类和基本类型比较的时候发现了包装本身存在的坑,参考的JDK版本是1.8.0_121,下面是例子代码:  Short packShort=1; short baseShort=1; Integer packInt=1; int baseInt=1; //用Short的equals()...
  • 基本类型与引用类型

    千次阅读 2016-03-25 13:04:33
    基本类型与引用类型
  • Java 基本类型 引用类型

    千次阅读 2017-06-01 15:48:09
    Java基本类型共有八种,基本类型可以分为三类,字符类型char,布尔类型boolean以及数值类型byte、short、int、long、float、double。数值类型又可以分为整数类型byte、short、int、long和浮点数类型float、double。...
  • JavaScript 基本数据类型

    千次阅读 多人点赞 2020-11-07 20:29:35
    JavaScript 基本数据类型String类型字符串属性和方法字符串属性字符串方法Number类型算术运算符赋值运算符比较运算符逻辑运算符类型判断Boolean类型Undefined类型Null类型 String类型 字符串是存储字符(比如 ...
  • c、 c++、 java 基本数据类型 对比辨析 一、java   1.数据类型表 二、C++   1.数据类型表 一、C   1.数据类型

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,474,917
精华内容 589,966
关键字:

对比的基本类型