java short比较_Java 中基于各种数据类型分析 == 和 equals 的区别

前言

Java 中的数据类型，可分为两类：基本数据类型，也称原始数据类型。byte,short,char,int,long,float,double,boolean 它们之间的比较，应用双等号(==),比较的是它们的值。

复合数据类型(类)。当它们用双等号进行比较的时候，比较的是它们在内存中的存放地址，所以，除非是同一个 new 出来的对象，它们的比较后的结果为 true，否则比较后结果为 false。 Java 当中所有的类都是继承于 Object 这个基类的，在 Object 中的基类中定义了一个 equals 的方法，这个方法的初始行为是比较对象的内存地址，但在一些类库当中这个方法被覆盖掉了，如 String,Integer,Date 在这些类当中 equals 有其自身的实现(在重写 equals 方法的时候，有必要重写对象的 hashCode 方法，从而保证程序完整性)，而不再是比较类在堆内存中的存放地址了。

对于复合数据类型之间进行 equals 比较，在没有覆写 equals 方法的情况下，它们之间的比较还是基于它们在内存中的存放位置的地址值的，因为 Object 的 equals 方法也是用双等号进行比较的，所以比较后的结果跟双等号的结果相同。

分析

一、int 和 Integerint 是基本数据类型，Integer 是 int 的包装类，也叫做复合数据类型。

Integer 变量必须实例化后才能使用；int 变量不需要；

Integer 实际是对象的引用，指向此 new 的 Integer 对象；int 是直接存储数据值 ；

Integer 的默认值是 null；int 的默认值是0。

1、Integer 对象使用 new 关键字生成

Integer i = new Integer(100);

Integer j = new Integer(100);

System.out.println("i == j:" + (i == j)); //falseSystem.out.println("i.equals(j):" + (i.equals(j))); //trueSystem.out.println("i.hashCode():" + i.hashCode());

System.out.println("j.hashCode():" + j.hashCode());

System.out.println("i,it's memory address:" + System.identityHashCode(i));

System.out.println("j,it's memory address:" + System.identityHashCode(j));

执行结果为：

i == j:false

i.equals(j):true

i.hashCode():100

j.hashCode():100

i,it's memory address:356573597

j,it's memory address:1735600054

正如上文提到的那样，复合数据类型使用双等号的时候是比较其在内存中的地址是否相同。一般而言，Object 的 hashCode()默认是返回内存地址的，在本例中直接输出对象的 hashCode 可以发现两者是一致的，那为什么==比较结果为 false呢？原因在于hashCode()可以重写，所以 hashCode()不能代表对象在内存的地址。System.identityHashCode(Object)方法可以得到对象的内存地址结果(严格意义上来讲，System.identityHashCode 的返回值和内存地址不相等的，该值是内存地址通过算法换算的一个整数值)，不管该对象的类是否重写了 hashCode()方法。

如上图所示，Integer 类中关于 equals()方法和 hashCode()方法进行了重写，所以如果想比对内存地址的不同，需要使用System.identityHashCode(Object)方法。

2、表面上不是 new 关键字生成的 Integer 对象

Integer i = 100;

Integer j = 100;

System.out.println("i == j:" + (i == j)); //trueSystem.out.println("i.equals(j):" + (i.equals(j))); //trueSystem.out.println("i.hashCode():" + i.hashCode());

System.out.println("j.hashCode():" + j.hashCode());

System.out.println("i,it's memory address:" + System.identityHashCode(i));

System.out.println("j,it's memory address:" + System.identityHashCode(j));

执行结果为：

i == j:true

i.equals(j):true

i.hashCode():100

j.hashCode():100

i,it's memory address:21685669

j,it's memory address:21685669

这里就不得不提出另一种情况：

Integer ii = 128;

Integer jj = 128;

System.out.println("ii == jj:" + (ii == jj)); //trueSystem.out.println("ii.equals(jj):" + (ii.equals(jj))); //trueSystem.out.println("ii.hashCode():" + ii.hashCode());

System.out.println("jj.hashCode():" + jj.hashCode());

System.out.println("ii,it's memory address:" + System.identityHashCode(ii));

System.out.println("jj,it's memory address:" + System.identityHashCode(jj));

​

//结果为ii == jj:false

ii.equals(jj):true

ii.hashCode():128

jj.hashCode():128

ii,it's memory address:2133927002

jj,it's memory address:1836019240

对于两个非 new 生成的 Integer 对象，进行比较时，如果两个变量的值在区间 -128 到 127 之间，则比较结果为 true，如果两个变量的值不在此区间，则比较结果为 false。通过打印出来的地址可以看出来，当不在指定区间范围时，实际上是两个不同的对象。 具体原因： Java 在编译 Integer i = 100 ;时，会翻译成为 Integer i = Integer.valueOf(100)。而 Java API 中对 Integer 类型的valueOf 的定义如下，对于-128 到 127 之间的数，会存储在缓存中，Integer i = 127 时，会直接从缓存中获取，下次再 Integer j = 127时，同样从缓存中取，而不会 new 个新对象。

public static Integer valueOf(int var0) {

return var0 >= -128 && var0 <= Integer.IntegerCache.high ? Integer.IntegerCache.cache[var0 + 128] : new Integer(var0);

}

其中 IntegerCache 类是 Integer 类的内部类，源代码如下：

private static class IntegerCache {

static final int low = -128;

static final int high;

static final Integer[] cache;

​

private IntegerCache() {