这篇博客探讨了Java中集合接口`Collection`的`contains()`方法的工作原理，指出其依赖于对象的`equals()`方法。当对象的类重写了`equals()`方法时，`contains()`方法将比较对象内容；否则，它将比较对象引用。文中通过示例展示了`contains()`方法在不同情况下如何判断集合中是否存在某个对象，并解释了`containsAll()`方法的类似行为。
Collection接口中的常用方法二
这个方法判断的是我们的调用这个方法的集合是不是包含了我们的obj对象,如果是包含了的话我们这里就是会返回一个true,如果是没有包含我们的obj对象的话,这个时候就会返回一个false
- 那么这个方法如何判断我们的这个集合中是不是包含了我们的obj对象?----这个在contain()方法的底层可以发现.我们的contain()方法在底层的代码中是调用了对象obj的equals()方法和我们的集合中的每一个元素进行了比较,也就是我们的这个对象包不包含在我们的这个集合中我们是要通过我们传入的对象obj的模板类中的equals()方法去判断到底包不包含
- 这里其实我们也就知道了,如果参数对象的模板类中重写了equals()方法,那么我们的比较的就是内容相不相同,如果我们的参数对象对象创建的模板类中的equals()方法没有进行重写,这个时候我们比较的就是我们的集合中的元素和我们的obj对象的地址相不相同
也就是我们的contains()方法判断包不包含时是通过看参数对象的模板类中有没有重写equals()方法判断的
- 参数对象的模板类中重写了equals()方法,就会调用我们参数对象的重写后的equals()方法去和我们的集合中的每个元素去比较,如果我们重写后equals()方法判断相等了,这个时候我们的contains()方法就返回一个true,也就表示包含
- 参数对象的模板类中没有重写equals()方法,这个时候就是调用我们参数对象从Object类中继承下来的equals()方法(而我们Object类中的equals()方法是通过==来实现的,比较的使我们两个对象的地址是否相同),那么这个时候就是使用我们的参数对象调用继承了Object类中的equals()方法去一个一个和我们的集合中的元素进行比较,如果判断出集合中有元素和我们的参数对象相同的话,这个时候我们也是返回一个true,如果遍历完集合之后都没有和我们的参数对象相同的元素,这个时候就返回一个false
这里我们举一个具体的例子
eg:
- 这个例子中我们的Dog类中没有重写equals()方法,也就是比较的是内容
package 集合;
import java.util.Collection;
import java.util.ArrayList;
public class FangfaER {
public static void main(String[] args) {
Collection c1= new ArrayList();
boolean b = c1.add(123);
boolean b1 = c1.add("abc");
boolean b2 = c1.add(new Dog());
boolean b3 = c1.add(new Dog("二哈",12));
Dog d = new Dog("小黑",1);
boolean b4 = c1.add(d);
/*
这个时候我们的返回值就应该是true,因为我们的这里的123其实是一个包装类,而我们的包装类中重写了我们的equals()方法.比较的也就是内容
这个时候我们的两个内容都是123,这个时候我们的contain()方法判断的结果也就应该是true
*/
System.out.println(c1.contains(123));
/*
这个时候我们返回值也应该是true,因为我们的String类中也是重写了我们的equals()方法,这个时候我们的判断的也就是两个内容,
这个时候两个内容都是abc,这个时候我们的contains()方法比较的结果也就应该是true
*/
System.out.println(c1.contains("abc"));
/*
这个时候的结果应该是一个false,应为我们在Dog类中并没有去重写equals()方法,这个时候我们比较的是地址,这两个对象比较的都是地址,
这个时候我们和我们集合中比较的对象是我们new出来的,我们new出来的对象都是独一无二的,这个时候我们的这两个对象的地址也就不可能相同,
也就是不包含,也即是判断的结果为false
*/
System.out.println(c1.contains(new Dog()));
/*
这个时候到的结果也应该为false,这个解释和我们的上面的new Dog()解释是一样的
*/
System.out.println(c1.contains(new Dog("二哈", 12)));
/*
这个时候我们输出的结果为true,这个时候我们我们比较的是同一个地址,我们是先创建好了对象,这个时候我们是通过一个引用指向了一个对象,染回我们装入
集合的和我们在contains()方法中传入的实参都是同一个Dog对象
*/
System.out.println(c1.contains(d));
}
}
class Dog{
private String name;
private int age;
public Dog(String name, int age) {
this.name = name;
this.age = age;
}
public Dog(){
}
@Override
public String toString() {
return "Dog{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
- 上面的最后一个比较中我们在集合中添加的和我们的contains()方法的参数是同一个对象,是同一个对象,这个时候我们的地址都是相同的,所以我们不管是Dog类中有没有重写我们的equals()方法,这个时候我们的这个输出结果都是true
eg:这里我们举一个例子
- 这个例子中我们的Dog2类中重写了equals()方法,重写之后是比较的内容
package 集合;
import java.util.Collection;
import java.util.ArrayList;
import java.util.Objects;
public class FangfaER2 {
public static void main(String[] args) {
Collection c1= new ArrayList();
boolean b = c1.add(123);
boolean b1 = c1.add("abc");
boolean b2 = c1.add(new Dog2());
boolean b3 = c1.add(new Dog2("二哈",12));
Dog2 d = new Dog2("小黑",1);
boolean b4 = c1.add(d);
/*
这个时候我们的返回值就应该是true,因为我们的这里的123其实是一个包装类,而我们的包装类中重写了我们的equals()方法.比较的也就是内容
这个时候我们的两个内容都是123,这个时候我们的contain()方法判断的结果也就应该是true
*/
System.out.println(c1.contains(123));
/*
这个时候我们返回值也应该是true,因为我们的String类中也是重写了我们的equals()方法,这个时候我们的判断的也就是两个内容,
这个时候两个内容都是abc,这个时候我们的contains()方法比较的结果也就应该是true
*/
System.out.println(c1.contains("abc"));
/*
这个时候这里的返回值应该是true,因为我们这里在Dog2类中重写了equals()方法,这个时候比较的就是两个对象的内容了,这个时候这两个对象
都是空内容,这个时候也是相等,我们的equals()方法就会返回一个true,这个时候我们的contains()方法也就返回一个true
*/
System.out.println(c1.contains(new Dog2()));
/*
这个时候返回值也是true,这个时候的原因和我们的上面的原因一样,因为这个时候我们的Dog2类中重写了equals()方法,这个是偶比较的就是内容
*/
System.out.println(c1.contains(new Dog2("二哈", 12)));
/*
这个时候我们的参数对象我们的集合中的元素对象是同一个,这个时候我们无论Dog2类中有没有重写equals()方法,这个时候我们的contains()方法都是
返回一个true
*/
System.out.println(c1.contains(d));
}
}
class Dog2{
private String name;
private int age;
public Dog2(String name, int age) {
this.name = name;
this.age = age;
}
public Dog2(){
}
@Override
public String toString() {
return "Dog{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Dog2 dog2 = (Dog2) o;
return age == dog2.age &&
Objects.equals(name, dog2.name);
}
}
-
这个时候由于我们的Dog2类中重写了equals()方法,这个时候我们举的例子都是返回true
-
当我们使用实际对象是ArrayList的Collection接口引用调用contains(Object obj)方法判断我们的obj对象存不存在时
- 这个时候我们的obj在我们调用contains()方法的第几个位置,这个时候我们就要调用几次我们的equals()方法
- 这个是因为我们的ArrayList是有序的
这个方法时传入一个集合,判断我们调用这个方法的集合是不是包含了参数集合对象
- 这个时候其实和我们上面是一样的,我们是通过参数集合中的每一个对象分别去和调用集合中的元素一一进行比较,这个时候也是使用的我们的参数集合中的每一个元素的模板类的equals()方法去比较
eg:
package 集合;
import java.util.Collection;
import java.util.ArrayList;
public class ContainsAllDemo {
public static void main(String[] args) {
Collection coll = new ArrayList();
coll.add(123);
coll.add(1234567890);
coll.add("abc");
coll.add(456);
coll.add(new Dog3("大黄",1));
Collection coll2 = new ArrayList();
coll2.add(123);
coll2.add("abc");
coll2.add(456);
coll2.add(new Dog3("小黑",12));
/*
这个时候我们输出的应该是一个false,因为我们的coll都不包含我们的coll2中的所有的元素,这个时候我们的containsAll()方法的返回值也就是一个false
*/
System.out.println(coll.containsAll(coll2));
}
}
class Dog3{
private String name;
private int age;
public Dog3(){
}
public Dog3(String name, int age){
this.name=name;
this.age=age;
}
public boolean equals(Object o){
if(o==this) {
return true;
}else if(o==null||o.getClass()!=getClass()){
return false;
}
else{
Dog3 dog = (Dog3)o;
if((dog.name==this.name)&&(dog.age==this.age)){
return true;
}else{
return false;
}
}
}
@Override
public String toString() {
return "Dog3{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
- 这里我们是重写了equals()方法了,如果这里我们没有重写这个equals()方法,那么我们这里比较的也还是地址,这个时候我们重写了equals()方法了,这个时候我们就是比较的内容
扫一扫
1140
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
