答案：
不是
解释：
两者都是用来比较两个对象是否相等
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()方法
