Java用重写的equals()判断实例变量是否相等

/*

经评论区提醒。一开始的重载写错了，应该为重写。

重载：多态的一种表现。

重写：方法覆盖。

/*

 

 

本人初学者，将自己学习的对Java的理解记录在博客下，希望大家能帮我指正错误！

 

两个对象相等：a == b

即判断引用是否相同。

例如定义实例对象Data，这个实例对象用于处理year，month，day三个元素。

Data a = new Data();
Data b = a;

那么（a == b )为true，即这两个的引用是相等的，b是a的一个别名。

 

 

在更多的情况下，我们希望检查两个对象中的值是否是相等的，比如

Data a = new Data(int year1,int month1,int day1);
Data b = new Data(int year2,int month2,int day2);

对象a 和b 的三个元素是否相等。在较多的情况下，如果这三个是相等的话，我们就认为a 和b 是相等的。（这里假设Data中只有这三个实例变量）

 

 

这时候就可以用到equals()方法了。这些类会从Object类中继承equals方法。但是有时候继承得到的equals()方法不能满足我们的要求。比如：

 

public class HelloWorl
{	
	public static void main(String[] args)
	{	
		Data a = new Data(2017,7,28);
		Data c = new Data(2017,7,28);
		
		if(a.equals(c)) System.out.println("true");
		else System.out.println("false");
		
		Data d = a;
		if(a.equals(d)) System.out.println("true");
	}
}
 

class Data
{
	int year;
	int month;
	int day;
	Data(int year,int month,int day)
	{
		this.year = year;
		this.month = month;
		this.day = day;
	}
}

 

在这里我们声明了Data对象a和c，给定了相同的三个元素，在许多程序中，会要求认为这两个对象是相等的。

但这里程序运行的结果为

 

false
true

 

这是因为继承自Object类的equals()方法只判断两个对象是否有相同的引用。引用类型的变量存储的并不是 “值”本身，而是于其关联的对象在内存中的地址。

 

如果应用相同，则返回true，如果不同，则返回false。

 

那么如果我们要实现自己的要求，比如，三个元素相同即认为对象a和b是相等的，要怎么办呢？这时候就要对equals()方法进行重写，也就是我们不用系统给的equals()了，我们写自己的equals()

 

public class HelloWorl
{	
	public static void main(String[] args)
	{	
		Data a = new Data(2017,7,28);		
		Data c = new Data(2017,7,28);
		if(a.equals(c)) System.out.println("true");
		else System.out.println("false");
		
		Data d = a;
		if(a.equals(d)) System.out.println("true");
	}
}
 

class Data
{
	int year;
	int month;
	int day;
	Data(int year,int month,int day)
	{
		this.year = year;
		this.month = month;
		this.day = day;
	}
	public boolean equals(Object x)
	{
		if(this == x) return true;
		if(x == null) return false;	//能调用这个方法，this肯定不为null，所以不判断this
		if(this.getClass() != x.getClass()) return false; //如果不死同一个类，则必然false
		Data that = (Data)x; //将Object类型的x转换为Data型。因为上一行已经判断了x是否为Data型，所以可以直接转换
		
		if(this.year != that.year) return false;
		if(this.month != that.month) return false;
		if(this.day != that.day) return false;
		
		return true;		
	}	
}

在Data类中重写了方法equals()，现在代码运行的结果为

 

 

true
true

于是我们就实现了自己的equals()方法，满足了自己的特殊要求。

 

 

另外，在系统自带的String对象中，equals()也是经过重写的。（对，是重写，不是重载）

 

因为equals经常和hashCode配合使用，下一步我打算学习一下hashCode

 

 

    public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;

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

这是java里String数据类型对hashCode的实现。

 

类似的，

（摘自算法第四版）java令所有数据类型都继承了一个能够返回一个32比特整数的hashCode()方法。每一种数据类型的hashCode()方法必须与equals()方法一致。

如果 

a.equals(b) == true   

则必有

a.hashCode() == b.hashCode()

 

如果

a.hashCode() != b.hashCode()

则

 a.equals(b) == false

 

如果两个家伙的hashCode返回值相同，则还要调用equals去判断。

 

那么。为什么在计算hashCode的循环中，有一个常数31呢？

我在 算法第四版 上找到了一个可能的原因：

散列表的用例希望hashCode()方法能够将键平均地散布为所有可能的32为整数

也就是说，对于任意一个对象x，调用x.hashCode()，都会等可能地得到一个32位整数值。

 

这样的话，在接下来可能进行的查找操作中，就可以将时间和内存的分配变得更加合理