java把现实中的任何事物都当做一个对象(Object), Java是面向对象的。此处的Object在Java中被定义为一个顶级父类，它是任何类父类，我们可以显示的继承它，也可以隐式继承，如以下实例：
public class Dog extends Object{
}
与
public class Dog{
}
完全等价。那么Object有什么样的作用？为什么每个类要去继承Object呢？首先来看一下Object中包含的2个常用方法。
1. equals(Object obj)
2. toString()
其中的方法会被高频率的使用，为了实现代码复用，java 设计者就把这些常用的方法集中的放到了一个类中，这个类就是Object.
看equals之前需要先看下“==”，因为“==”是判断相等，equals也是判断相等，只是”==”主要用于判断基本数据类型的相等性，当然也可以直接判断两个对象。而equals主要判断对象内容。其中有很多细节，下面逐个说明：
先看“==”判断基本数据类型
public static void main(String[] args) {
int i = 1;
int j = 1;
boolean flag0 = true;
boolean flag1 = false;
System.out.println("i==j:"+(i==j));
System.out.println("flag0==flag1:"+(flag0==flag1));
}
运行结果：
i==j:true
flag0==flag1:false
以上实例非常简单，不多说明。
下面看一下对象的比较 :
public static void main(String[] args) {
Dog dog0 = new Dog();
Dog dog1 = new Dog();
System.out.println(("dog0==dog1:")+(dog0==dog1));
}
运行结果：dog0==dog1:false
以上实例中的“==”，比较的是dog0的内存首地址和dog1 的内存首地址，由于dog0和dog1所指向的对象是在内存中开辟的两个空间，所以首地址是不一样的，此处打印输出false.
那么有没有办法看到内存首地址是多少呢？
有句话是说“办法总比问题多”，如果想看到内存首地址，我们需要再认识另外一个函数toString(),当我们直接打印某个对象引用的时候，该方法就会得到调用，看一个实例：
public static void main(String[] args) {
Dog dog0 = new Dog();
System.out.println(("dog0:")+dog0);
System.out.println(("dog0.toString():")+dog0.toString());
打印输出：
dog0:Dog@6b97fd
dog0.toString():Dog@6b97fd
两者完全等价，也就是说当我们直接打印输出引用与在引用上调用toString方法两者完全等价。
目前看到的Dog@6b97fd对我们来说没有任何的意义，为了让其变得有意义，我们可以对它进行重写。比如以上实例打印dog引用时，把dog的dogName打印输出，修改以上实例如下：
public class Dog{
private String dogName;
public String getDogName() {
return dogName;
}
public void setDogName(String dogName) {
this.dogName = dogName;
}
public String toString() {
return "dog's name is:"+dogName;
}
}
入口函数：
public class EqualsDemo {
public static void main(String[] args) {
Dog dog0 = new Dog();
dog0.setDogName("xiaobai");
System.out.println(("dog0:")+dog0);
}
}
打印输出：dog0:dog's name is:xiaobai
在此有个特殊情况，如果直接定义两个内容相同的String常量，两者会指向同样一个对象：
public static void main(String[] args) {
String str0 = "Hello";
String str1 = "Hello";
System.out.println("str0==str1"+(str0==str1));
}
打印输出：str0==str1:true
但是如果通过new的方式产生了String常量，则不会指向同样的对象，如一下实例：
public static void main(String[] args) {
String str0 = "Hello";
String str1 = new String("Hello");
System.out.println("str0==str1:"+(str0==str1));
}
运行程序，打印输出：str0==str1:false
Equals 方法主要是比较对象内容，但是在默认情况下，比较的是内存首地址。看个实例：
创建两个类：
public class Dog{
}
另外一个类：
public class EqualsDemo {
public static void main(String[] args) {
Dog dog0 = new Dog();
Dog dog1 = new Dog();
System.out.println(("dog0.equals(dog1):")+dog0.equals(dog1));
}
}
打印输出：dog0.equals(dog1):false
可以通过覆盖equals方法来比较两个对象的内容
下面看一个equals使用的例子，该实例中想通过判断dog 的名字，如果名字相等就认为两个对象相等，如果名字不相等就认为两个对象不相等。
public class Dog {
private String dogName;
public String getDogName() {
return dogName;
}
public void setDogName(String dogName) {
this.dogName = dogName;
}
public boolean equals(Object obj) {
if (obj == null)
return false;
Dog other = (Dog) obj;
if (dogName.equals(other.dogName)){
return true;
}else{
return false;
}
}
}
入口函数如下：
public static void main(String args[]){
Dog dog0 = new Dog();
dog0.setDogName("xiaobai");
Dog dog1 = new Dog();
dog1.setDogName("xiaobai");
System.out.println("dog0.equals(dog1):"+dog0.equals(dog1));
}
运行结果：dog0.equals(dog1):true
hashCode方法
HashSet和HashMap 使用后台数组（backing array）作为桶，并使用链表（linked list）存储键／值对。
桶的后台数组：如下所示
1）使用键（key）和值（value）将一个对象放入 map 中时，会隐式调用 hashCode() 方法，返回哈希值（hash code value），比如 123。两个不同的键能够返回一样的哈希值。良好的哈希算法（hashing algorithm）能够将数值分散开。在上面的例子中，我们假设 (“John”,01/01/1956) 的键和 (“Peter”, 01/01/1995) 的键返回相同的哈希值，都是 123。
2）当返回一个 hashCode，例如是 123，初始的 HashMap 容量为 10，它如何知道存储到后台数组（backing array）的哪个索引（index）呢？HashMap 内部会调用 hash(int ) 和 indexFor(int h, int length) 方法。这被称为哈希函数（hashing function）。
简要解释下这个函数：
hashCode() % capacity
123%10=3
456%10=6
这表示，“hashCode = 123”存储在备份数组的索引3上。
容量为 10 的情况下，你可能得到的数字在 0 到 9 之间。
一旦 HashMap 达到容量的 75%，也就是哈希因子(hash factor)默认值 0.75，后台数组（backing array）的容量就会加倍，发生重散列（rehashing）为新的 20 的容量重新分配桶。
hashCode() % capacity
123%20=3
456%20=16
如上图所示，键／值对以链表形式存储。两个不同的键可以产生一样的 hashCode，例如123，并存储在同一个 bucket 中，理解这点至关重要。例如，上面例子中的 “John, 01/01/1956” 和 “Peter, 01/01/1995“ 。你如何只检索 “John, 01/01/1956” 呢？此时你的 key 所属类的 equals() 方法会被调用。它遍历 bucket 为 “123” 的 LinkedList 中的每个条目，使用 equals() 方法找到并检索出键为 “John, 01/01/1956” 的条目。这就是在你的类中实现 hashCode() 和 equals() 方法重要性的原因。如果你使用一个现有的包装类，如 Integer 或 String 作为键，它们已经实现了这两个方法。如果你使用自己写的类作为键，如 “John, 01/01/1956” 这样含有名字和出生日期属性的“MyKey”，你有责任正确地实现这些方法。
不同的对象调用 hashCode() 方法应该返回不同的值。如果不同的对象返回相同的值，会导致更多的键／值对存储在同一个 bucket 中。这会降低 HashMap 和 HashSet 的性能。
便于理解的补充
public class EqualsDemo1 {
public static void main(String[] args) {
Car car1 = new Car(10000 , "保时捷");
Car car2 = new Car(10000 , "保时捷");
Set<Car> set = new HashSet<>();
set.add(car1);
set.add(car2);
Map<Car , Integer> key2car = new HashMap<>();
key2car.put(car1 , 111);
key2car.put(car2 , 222);
for (Car newkey :key2car.keySet())
{
System.out.println(newkey.toString());
}
// System.out.println(set.size());
}
}
public class Car {
int price ;
String name ;
public Car(int price, String name) {
this.price = price;
this.name = name;
}
@Override
public String toString() {
return "Car{" +
"price=" + price +
", name='" + name + '\'' +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Car car = (Car) o;
if (price != car.price) return false;
return name.equals(car.name);
}
@Override
public int hashCode() {
int result = price;
result = 31 * result + name.hashCode();
return result;
}
}
如上代码，如果去掉hashCode ， 那么两个车对象就不会进入到桶的同一个位置，这时系统就会默认这两个车对象不是相等的，所以不会调用equals方法，所以set集合中，map集合中还是存在两个元素
如果set集合中的 元素或者map集合中的Key是String Integer类型的话，不需要自定义hashCode和equals,
如果set集合中的 元素或者map集合中的Key 是自定义类 的话，需要自定义hashCode 和equals
