Java面试题----Java基础----hashCode()相同 equals()也为true吗

答案：
不是
解释：
两者都是用来比较两个对象是否相等

equals：（效率低）
如果重写了方法，一般是对象内容相同返回true否则返回false
如果未重写方法，是两个对象==时返回true否则返回false
hashCode:（效率高）
作用是获取哈希码，也称为散列码。它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置

如果equals为true，则hashCode相等
如果hashCode相等，equals不一定相等
也就是说equals是可靠的相等
所以判断对象相等时，先判断hashCode是否相等，不相等则对象一定不等。hashCode相等再判断equals是否相等。

一、什么是hashCode：
对象的哈希值就是一个普通的十进制数组，源于父类Object hashCode();

源码：public native int hashCode();
如果没有重写父类，哈希值是将对象的内部地址转换为一个int数值，没有特别意义；
但是如果子类重写父类方法，哈希值就会是自定义的哈希值；

举例：
① 两个String时，hashCode值是相同的；String中重写了hashCode()

String string1 = new String("abc");
String string2 = new String("abc");
System.out.println(string1.hashCode()==string2.hashCode());

运行结果 true
②未重写hashcode的类Car,两个对象时，hashCode是不同的

public class Car {
	private String name;
	public Car(String name) {
		this.name = name;
	}
}

Car c1 = new Car("bmw");
Car c2 = new Car("bmw");
System.out.println(c1.hashCode() == c2.hashCode());

运行结果 false

二、hashCode的重写与作用
什么时候需要重写hashCode()？到底是干嘛用的？
举例：现在我们需要上面Car的name相同就认为两个对象相等。

hashCode()和equal()一样都是基本类Object里的方法，而和equal()一样，Object里hashCode()里面只是返回当前对象的地址，如果是这样的话，那么我们相同的一个类，new两个对象，由于他们在内存里的地址不同，则他们的hashCode（）不同，所以这显然不是我们想要的相等效果，所以我们必须重写我们类的hashCode()方法，即一个类，在hashCode()里面返回唯一的一个hash值。

重写hashCode来进行对比 代码如下：

public class Car {
	private String name;
	public Car(String name) {
		this.name = name;
	}
	
	@Override
	public int hashCode() {
		return name.hashCode();
	}
}

Car c1 = new Car("bmw");
Car c2 = new Car("bmw");
System.out.println(c1.hashCode() == c2.hashCode());

运行结果 true

当然也可以只重写一个equal()，然后利用equal()去对比。
hashCode一般在集合中使用， hashSet的特性（即不包含一样的对象）的实现就使用了hashCode方法，具体如下：

将对象放入到集合中时，首先判断要放入对象的hashcode值与集合中的任意一个元素的hashcode值是否相等，如果不相等直接将该对象放入集合中。如果hashcode值相等，然后再通过equals方法判断要放入对象与集合中的任意一个对象是否相等，如果equals判断不相等，直接将该元素放入到集合中，否则不放入。
也就是说，如果我们使用HashSet集合存储对象，你要想保证元素的唯一性，就必须重写hashCode()和equals()方法。
具体看下面示例代码：

Student类没有重写equals和hashCode

public class Student{
	String name;
	Integer age;

	public Student(String name, Integer age) {
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Integer getAge() {
		return age;
	}

	public void setAge(Integer age) {
		this.age = age;
	}
	}

运行下面测试方法 放两次 new Student(“程1”,18)对象

public class TestHashCode {
	public static void main(String[] arg){
		Student s1 = new Student("程1",18);
		Student s2 = new Student("程2",19);
		Student s3 = new Student("程3",20);
		Student s4 = new Student("程4",21);
		Student s5 = new Student("程1",18);

		HashSet<Student> set = new HashSet<>();
		set.add(s1);
		set.add(s2);
		set.add(s3);
		set.add(s4);
		set.add(s5);

		for (Student student : set) {
			System.out.println(student.name+"的年龄是:"+student.age);
		}
	}
}

运行结果

程2的年龄是:19
程1的年龄是:18
程4的年龄是:21
程1的年龄是:18
程3的年龄是:20

结果可以看出，在没有重写equals和hashCode时，set保证不了元素的唯一性。

下面我们重写Student的equals方法，只要名字相同，年龄一样就返回true。

public class Student{
	String name;
	Integer age;

	public Student(String name, Integer age) {
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Integer getAge() {
		return age;
	}

	public void setAge(Integer age) {
		this.age = age;
	}

	@Override
	public boolean equals(Object o) {
		if(o == null){
			return false;
		}
		if(this == o){
			return true;
		}
		if(getClass() != o.getClass()){
			return false;
		}
		Student obj= (Student) o;
		if(!age.equals(obj.getAge()) ){
			return false;
		}
		if(name == null){
			if(obj.getName() != null){
				return false;
			}
		}else if(!getName().equals( obj.getName())){
			return false;
		}
		return true;
	}
	}

运行结果

程2的年龄是:19
程1的年龄是:18
程4的年龄是:21
程1的年龄是:18
程3的年龄是:20

观察结果发现还是保证不了唯一性，继续重写hashCode方法，用name的哈希值与age进行固定运算返回int值（让相同元素的hashCode相同）

public class Student{
	String name;
	Integer age;

	public Student(String name, Integer age) {
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Integer getAge() {
		return age;
	}

	public void setAge(Integer age) {
		this.age = age;
	}

	@Override
	public boolean equals(Object o) {
		if(o == null){
			return false;
		}
		if(this == o){
			return true;
		}
		if(getClass() != o.getClass()){
			return false;
		}
		Student obj= (Student) o;
		if(!age.equals(obj.getAge()) ){
			return false;
		}
		if(name == null){
			if(obj.getName() != null){
				return false;
			}
		}else if(!getName().equals( obj.getName())){
			return false;
		}
		return true;
	}

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

运行结果

程1的年龄是:18
程2的年龄是:19
程3的年龄是:20
程4的年龄是:21

观察结果发现，实现了元素的唯一性。

当我们只重写的equals时，set调用add()会先判断hashCode是否有已经存在的，而没有重写的hashCode是根据对象地址给的哈希值，自然就认为是两个不同的对象，会直接存入set中，就不会再进行equals比较了，因此无法保证元素的唯一性。所以，要使用HashSet集合存储对象，要保证元素的唯一性，就必须重写hashCode()和equals()方法