java中的==运算符、equals()方法

时间：2022-05-26 16:15:56

1.hashcode()

首先来看一下什么是哈希码(HashCode)
在Java中，哈希码代表对象的特征。
例如对象 String str1 = “aa”, str1.hashCode= 3104
String str2 = “bb”, str2.hashCode= 3106
String str3 = “aa”, str3.hashCode= 3104
根据HashCode由此可得出str1!=str2,str1==str3

哈希码产生的依据：哈希码并不是完全唯一的，它是一种算法，让同一个类的对象按照自己不同的特征尽量的有不同的哈希码，但不表示不同的对象哈希码完全不同。也有相同的情况，看程序员如何写哈希码的算法。

下面给出几个常用的哈希码的算法。
1：Object类的hashCode.返回对象的内存地址经过处理后的结构，由于每个对象的内存地址都不一样，所以哈希码也不一样。
2：String类的hashCode.根据String类包含的字符串的内容，根据一种特殊算法返回哈希码，只要字符串内容相同，返回的哈希码也相同。
3：Integer类，返回的哈希码就是Integer对象里所包含的那个整数的数值，例如Integer i1=new Integer(100),i1.hashCode的值就是100 。由此可见，2个一样大小的Integer对象，返回的哈希码也一样。

我们可以通过一个实例看验证一下以上算法：
Object obj1 = new Object();
Object obj2 = new Object();
System.out.println(obj1.hashCode()); //31843011
System.out.println(obj2.hashCode()); //25860399

结果验证了算法的实现，每个Object对象的内存地址都不一样，所以哈希码也不一样。

String str3 = new String(“abc”);
String str4 = new String(“abc”);
System.out.println(str3.hashCode()); //96354
System.out.println(str4.hashCode()); //96354

结果验证了算法的实现，在String类中只要字符串的内容相同，那么返回的哈希码也相同。

因为String类重写了hashCode()方法，我们来看一下它的源代码：

public int hashCode() {
int h = hash;
if (h == 0) {
int off = offset;
char val[] = value;
int len = count; 

       for (int i = 0; i < len; i++) {  
           h = 31*h + val[off++];  
       }  
       hash = h;  
   }  
   return h;

}

所以相同字符串的String对象的hashCode值一定相等，但是字符串内容不相同的hashCode值可能会相等，因为String的hashCode的值域范围是有限的，而字符串的长度和排列组合方式是无穷多种的。

java类也会重写hashCode(必须与equals一起重写):

@Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        result = prime * result + ((salary == null) ? 0 : salary.hashCode());
return result;
    }

@Override
    public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Employee other = (Employee) obj;
if (name == null) {
if (other.name != null)
return false;
        } else if (!name.equals(other.name))
return false;
if (salary == null) {
if (other.salary != null)
return false;
        } else if (!salary.equals(other.salary))
return false;
return true;
    }

重写完或两个对象equals为true，则hashCode()相等。

在重写hashCode要遵守hashCode常规协定：

一致性

在 Java 应用程序执行期间，在对同一对象多次调用 hashCode 方法时，必须一致地返回相同的整数，前提是将对象进行 equals 比较时所用的信息没有被修改。

equals

如果根据 equals(Object) 方法，两个对象是相等的，那么对这两个对象中的每个对象调用 hashCode 方法都必须生成相同的整数结果，注：这里说的equals(Object) 方法是指Object类中未被子类重写过的equals方法。

附加

如果根据 equals(java.lang.Object) 方法，两个对象不相等，那么对这两个对象中的任一对象上调用 hashCode 方法不 要求一定生成不同的整数结果。但是，程序员应该意识到，为不相等的对象生成不同整数结果可以提高哈希表的性能。

2.==运算符

java中的==是比较两个对象在JVM中的地址。比较好理解。看下面的代码：

public class ComAddr{
2     public static void main(String[] args) throws Exception {
3         String s1 = "nihao";
4         String s2 = "nihao";
5         String s3 = new String("nihao");
6         System.out.println(s1 == s2);    //    true
7         System.out.println(s1 == s3);    //    false
8     }
9 }

上述代码中：

　　(1)s1 == s2为true，是因为s1和s2都是字符串字面值”nihao”的引用，指向同一块地址，所以相等。

　　(2)s1 == s3为false，是因为通过new产生的对象在堆中，s3是堆中变量的引用，而是s1是指向字符串字面值”nihao”的引用，地址不同所以不相等。

3.equals()

equals是根类Obeject中的方法。源代码如下：

public boolean equals(Object obj) {
return (this == obj);
}

可见默认的equals方法，直接调用==，比较对象地址。
不同的子类，可以重写此方法，进行两个对象的equals的判断。
String类源码中重写的equals方法如下，

public boolean equals(Object anObject)
{
//如果是同一个对象
if (this == anObject)
        {
return true;
        }
        //如果传递进来的参数是String类的实例
 if (anObject instanceof String)
 {
 String anotherString = (String)anObject;
 int n = count;//字符串长度
 if (n == anotherString.count) //如果长度相等就进行比较
 {
 char v1[] = value;//取每一个位置的字符
 char v2[] = anotherString.value;
 int i = offset;
 int j = anotherString.offset;
 while (n-- != 0) //对于每一位置逐一比较
 {
 if (v1[i++] != v2[j++])
 return false;
 }
 return true;
 }
 }
 return false;
}

从上面的代码中可以看到，

　　(1)String类中的equals首先比较地址，如果是同一个对象的引用，可知对象相等，返回true。

　　(2)若果不是同一个对象，equals方法挨个比较两个字符串对象内的字符，只有完全相等才返回true，否则返回false。

demo：

public class StringTest {
    public static void main(String[] args) {

String str1 = "sachin tendulkar";
String str2 = "amrood admin";
String str3 = "amrood admin";

// checking for equality
        boolean retval1 = str2.equals(str1);
        boolean retval2 = str2.equals(str3);

// prints the return value
System.out.println("str2 is equal to str1 = " + retval1);
System.out.println("str2 is equal to str3 = " + retval2);        
     }
}

java类中重载的equals方法如下，

@Override
    public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Employee other = (Employee) obj;
if (name == null) {
if (other.name != null)
return false;
        } else if (!name.equals(other.name))
return false;
if (salary == null) {
if (other.salary != null)
return false;
        } else if (!salary.equals(other.salary))
return false;
return true;
    }

demo：

public class EqualsTest {
    public static void main(String[] args) {
Employee alice1=new Employee("Alice", "1000");
Employee alice2=alice1;
Employee alice3=new Employee("Alice", "1000");
Employee bob=new Employee("Bob", "2100");

System.out.println("alice1=alice2:"+(alice1==alice2));//true
System.out.println("alice1=alice3:"+(alice1==alice3));//false
System.out.println("alice1.equals(alice3):"+(alice1.equals(alice3))); //true
System.out.println("alice1.equals(bob):"+(alice1.equals(bob)));//false
    }
}

总结：

(1)绑定。当equals方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码。

(2)绑定原因。Hashtable实现一个哈希表，为了成功地在哈希表中存储和检索对象，用作键的对象必须实现 hashCode 方法和 equals 方法。同(1)，必须保证equals相等的对象，hashCode 也相等。因为哈希表通过hashCode检索对象。

(3)默认。

==默认比较对象在JVM中的地址。

hashCode 默认返回对象在JVM中的存储地址。

equal比较对象，默认也是比较对象在JVM中的地址，同==
标签：

相关文章