Java：ArrayList中的contains方法

我们先看一下调用的效果：

import java.util.ArrayList;
piblic class Test {
	public static void main(String [] args){
		ArrayList<String> list =new ArrayList<String>();//jdk7.0及以上版本，可以不加new后的泛型类型
		list.add("tom");
		String name="tom";
		System.out.println(list.contains(name));
	}
}
/*运行结果
true*/

那么，contains方法是如何实现判断的呢：

public boolean contains(Object o) {//contains方法传入参数为对象o，即此时o为name，所以name为一个上转型对象
	return indexOf(o) >= 0;//调用下面indexOf方法,并判断是否小于零，返回布尔类型的结果
}
 
public int indexOf(Object o) {//contains中的o传入到这里，name依旧为上转型对象
	if (o == null) {//o不为null，执行else
		for (int i = 0; i < size; i++)
			if (elementData[i]==null)
				return i;
	} else {
		for (int i = 0; i < size; i++)//for循环遍历list中每一个元素；其中size为全局变量，this.size：表示list的元素个数;
		if (o.equals(elementData[i]))//①
			return i;//返回找到相同时，元素的位置
	}
	return -1;
}

①此时o调用equals方法，由于o为String类对象，o为上转型对象，所以此时出现多态性，o调用String类中重写过的equals方法：对比调用对象和传入对象地址中存的字符串是否相同，如果是，返回true，如果不是返回false。elementData为存着list元素的数组，所以这个判断语句的作用就是，当发现list已有的元素中，有想要的寻找的元素，就进入if分支。

• 此时，我们改变传入对象的值进行分析：

//调用
import java.util.ArrayList;
piblic class Test {
	public static void main(String [] args){
		ArrayList<String> list =new ArrayList();
		list.add("tom");
		String name=null;
		System.out.println(list.contains(name));
	 }
}
/*运行结果
false*/

//进行分析
public boolean contains(Object o) {//contains方法传入参数为对象o，即此时o为name，所以name为一个上转型对象
	return indexOf(o) >= 0;//调用下面indexOf方法,并判断是否小于零，返回布尔类型的结果
}

public int indexOf(Object o) {//contains中的o传入到这里，name依旧为上转型对象
	if (o == null) {//o为null，执行if下true分支
		for (int i = 0; i < size; i++)//for循环遍历list中每一个元素
		if (elementData[i]==null)//判断是否有元素存值为空
			return i;//返回找到相同时，元素的位置
	} else {
		for (int i = 0; i < size; i++)
		if (o.equals(elementData[i]))
		return i;
	}
	return -1;
}

• 然后，我们改变传入的对象的类型进行分析

//调用
import java.util.ArrayList;
piblic class Test {
	public static void main(String [] args){
		ArrayList<String> list =new ArrayList();
		list.add("tom");
		Test test=new Test;
		String name="tom";
		System.out.println(list.contains(name));
	}
}
/*运行结果
false*/

//进行分析
public boolean contains(Object o) {//contains方法传入参数为对象o，即此时o为test，所以test为一个上转型对象
	return indexOf(o) >= 0;//调用下面indexOf方法,并判断是否小于零，返回布尔类型的结果
}
 
public int indexOf(Object o) {//contains中的o传入到这里，test依旧为上转型对象
	if (o == null) {//o不为null
		for (int i = 0; i < size; i++)
		if (elementData[i]==null)
			return i;
	} else {
		for (int i = 0; i < size; i++)//for循环遍历list中每一个元素
		if (o.equals(elementData[i]))//②
		return i;
	}
	return -1;
}

②此时test为上转型对象。但是由于test并没有重写equals方法，所以调用的为原来的Obj类中的equals方法：对比调用对象和传入参数（即list中元素）的地址是否相同。Test对象和String类对象没有关系所以显然地址不一样。

• 那么，如果元素为对象，我们想通过某个属性来判断是否存在时，该怎么做呢？
  方法：通过在该对象类中，重写合适的equals方法

• 例，我们想存入学生对象，并通过唯一id判断学生是否已存在

//Student类
public class Student{
	String id;
	String name;
	public  Student() {
	}
	public Student (String id){
		this.id=id;
	}
	@Override
	public boolean equals(Object obj) {//重写Object类中的equals方法
		Student student =(Student)obj;//对象下转型，因为调用contains方法的为元素，本例中则为Student类的对象，故obj为上转型对象，要使用子类新的成员变量，则需要下转型
		return this.id.equals(student.id);//改写为id调用的equals方法，id为String类，故调用String中的equals方法，比较字符串是否一致，达到比较id内容的目的
	}
}

//主函数
public class Test{
	public static void main(String [] args){
	ArrayList<Student> list = new ArrayList();
	Student stu1=new Student("12345");
	Student stu2=new Student("12345");
	list.add(stu1);
	System.out,println(list.contains(stu2));
	}
}

//进行分析
public boolean contains(Object o) {//contains方法传入参数为对象o，即此时o为stu2，所以o为一个上转型对象
	return indexOf(o) >= 0;//调用下面indexOf方法,并判断是否小于零，返回布尔类型的结果
}
 
public int indexOf(Object o) {//contains中的o传入到这里，依旧为上转型对象
	if (o == null) {//o不为null
		for (int i = 0; i < size; i++)
		if (elementData[i]==null)
			return i;
	} else {
		for (int i = 0; i < size; i++)//for循环遍历list中每一个元素
		if (o.equals(elementData[i]))//此处出现多态，stu2调用Student类中重写过的equals方法，与list中每个学生对象的id进行比对
		return i;
	}
	return -1;
}

优化：

//Student类
public class Student{
	String id;
	String name;
	public  Students() {
	}
	public Students (String id){
		this.id=id;
	}
	@Override
	public boolean equals(Object obj) {//重写Object类中的equals方法
		if(obj instanceof Student){//判断对比对象是否能下转型，避免发生异常
			Student student =(Student)obj;
			return this.id.equals(student.id);
		}
		return false;
	}
}