先上代码:
第一步：新建一个学生类
package ExceptionDemo;
/**
* 学生信息类
* @author zhang
*
*/
public class Student implements Comparable{
String name ;
int age ;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
/*System.out.println("每一个名字的hashCode:"+name.hashCode());*/
System.out.println("result:"+result);
return result;
}
@Override
public boolean equals(Object obj) { //关注红色字体方法的调用
Student stu = (Student)obj;
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
if(this.age == stu.age) {
return true;
} else if(this.age < stu.age) {
return false;
} else {
return false;
}
}
}
第二歩：在main方法中使用集合向该集合中添加Student对象
package ExceptionDemo;
import java.util.ArrayList;
/**
* 异常的学习
* @author zhang
*
*/
public class Test {
/**
* 入口方法
* @param args
*/
public static void tell(Father father){
father.say();
}
public static void main(String[] args) {
Student stu1 = new Student();
stu1.age = 40;
stu1.name = "zhangsan";
Student stu2 = new Student();
stu2.age = 10;
stu2.name = "zhangsan";
Student stu3 = new Student();
stu3.age = 10;
stu3.name = "zhangsan";
Student stu4 = new Student();
stu4.age = 20;
stu4.name = "zhaoliu";
ArrayList<Student> al = new ArrayList<Student>();
al.add(stu1);
al.add(stu2);
al.add(stu3);
al.add(stu4);
//遍历集合，indexOf不是获取集合中元素在集合中的索引，而是获取与当前元素相匹配的
//第一个元素的位置，返回的集合中是第一个匹配元素的位置
for(Student stu:al) {
System.out.println(stu.age);
System.out.println(al.indexOf(stu));
}
}
}
程序执行的结果为：
40开始执行equals方法
0
10
开始执行equals方法
开始执行equals方法
1
10
开始执行equals方法
开始执行equals方法
1
20
开始执行equals方法
开始执行equals方法
开始执行equals方法
开始执行equals方法
3
起初本人对indexOf方法认识，是认为该方法是获取集合中元素的索引，但是事实并不是这样，
先看java低层如何对indexOf方法是如何实现的：
/**
* Returns the index of the first occurrence of the specified element
* in this list, or -1 if this list does not contain the element.
* More formally, returns the lowest index <tt>i</tt> such that
* <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt>,
* or -1 if there is no such index.
*/
public int indexOf(Object o) {
if (o == null) {
for (int i = 0; i < size; i++)
if (elementData[i]==null)
return i;
} else {
for (int i = 0; i < size; i++)
if (o.equals(elementData[i])) //关注红色字体方法的调用
return i;
}
return -1;
}
由源代码可知，该方法返回的是第一个与o对象相匹配的元素的索引，也就是说，如果集合中存在多个相同的对象，equals方法比较的结果是第一个与之相匹配的元素的索引，然后返回i,不再向后进行比较。当Student类未重写equals方法和hashCode方法的时候，可以返回每一个元素的索引。此时调用的equals方法是Object类中的equals方法，也就是下面的方法
public boolean equals(Object obj) { //关注红色字体方法的调用
return (this == obj);
}
当Student类重写了equals方法和hashCode方法的时候，此时调用的equals方法是Student类中的equals方法
@Override
public boolean equals(Object obj) { //关注红色字体方法的调用
System.out.println("开始执行equals方法");
Student stu = (Student)obj;
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
if(this.age == stu.age) {
return true;
} else if(this.age < stu.age) {
return false;
} else {
return false;
}
}
此时输出的结果就是本例中输出的结果，最终的原因就是Student类对Object类中的Object方法进行了重写，导致在调用indxeOf方法的时候，在indexOf方法内部调用子类的equals方法，使得比较的结果发生了变化。