java中的==运算符、equals()方法
2016-01-10 11:31
489 查看
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"; // che b5b4 cking 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中的地址,同==
相关文章推荐
- java数组元素重复次数最大值
- Spring学习笔记 5. 尚硅谷_佟刚_Spring_自动装配
- Java基础问题(二)
- 《Java语言程序设计基础篇》第8版第11章代码
- SpringMVC中使用Interceptor拦截器
- java资源下载之官网地址
- 上机题目(初级)-小明的筷子(Java)
- Java中Spring获取bean方法小结
- Spring boot quick start
- SpringMVC 中Transactional注解的巨坑
- java对文件压缩与解压缩操作
- 基于Java实现杨辉三角 LeetCode Pascal's Triangle
- Java EE V7.0学习笔记- 安装 WebSphere Developer Tools
- 上机题目(初级)-计算两个正整数的最大公约数和最小公倍数(Java)
- 从零开始写javaweb框架笔记9-细节完善与代码优化-完善控制器层
- 最大堆的插入/删除/调整/排序操作(图解+程序)(JAVA)
- java中的四种访问权限
- scala出现异常:Exception in thread "main" java.lang.StackOverflowError
- spring jmx 整合
- Java