Java 集合的Contains和Remove方法

一、包含与删除两种方法解析

1.boolean contains(Object o);判断集合中是否包含某个元素。

1. package com.bjpowernode.java_learning;
2.  
3. import java.util.*;
4.  
5. ​
6.  
7. public class D85_1_ContainsMethod {
8.  
9. public static void main(String[] args) {
10.  
11. //创建集合
12.  
13. Collection c = new ArrayList();
14.  
15. //创建两个Integer类型的对象
16.  
17. Integer i1 = new Integer(10);
18.  
19. //添加元素
20.  
21. c.add(i1);
22.  
23. //判断集合中是否包含11
24.  
25. System.out.println(c.contains(i1));
26.  
27. ///创建Integer类型的对象
28.  
29. Integer i2 = new Integer(10);
30.  
31. System.out.println(c.contains(i2));
32.  
33. //这里包含了i2说明了，contains底层调用了equals方法。如果equals返回了true，就是包含
34.  
35. Manager85 m1 = new Manager85(52,"jho");
36.  
37. c.add(m1);
38.  
39. Manager85 m2 = new Manager85(52,"jho");
40.  
41. System.out.println(c.contains(m2));
42.  
43. }
44.  
45. }
46.  
47. class Manager85{
48.  
49. int no;
50.  
51. String name;
52.  
53. Manager85(int no,String name){
54.  
55. this.no = no;
56.  
57. this.name = name;
58.  
59. }
60.  
61. public boolean equals(Object o){
62.  
63. if(this==o) return true;
64.  
65. if(o instanceof Manager85) {
66.  
67. Manager85 m = (Manager85)o;
68.  
69. if(this.no==m.no && this.name.equals(m.name)){
70.  
71. return true;
72.  
73. }
74.  
75. }
76.  
77. return false;
78.  
79. }
80.  
81. //总结创建一个类，要重写equals方法，才能对类中的数据进行对比，否则继承原来的equals只能是对比对象的地址
82.  
83. }

2.boolean remove(Object o);删除集合中某个元素。

总结：从这两次输出的结果就可以看出来，remove方法与contains方法在用法上是一致的

他们的底层全部都调用了equals方法来进行比较，因为在使用这个方法的时候，必须保证我们的原始类中equals方法已经被重写，否则就会得到意想不到的结果。

1. package com.bjpowernode.java_learning;
2.  
3. ​
4.  
5. import java.util.*;
6.  
7. ​
8.  
9. public class D85_2_RemoveMethod {
10.  
11. public static void main(String[] args) {
12.  
13. //创建集合对象
14.  
15. Collection c = new ArrayList();
16.  
17. Integer i1 = new Integer(10);
18.  
19. //添加元素
20.  
21. c.add(i1);
22.  
23. //删除
24.  
25. Integer i2 = new Integer(10);
26.  
27. c.remove(i2);
28.  
29. System.out.println(c.size());
30.  
31. Manager85 m1 = new Manager85(10,"ji");
32.  
33. c.add(m1);
34.  
35. Manager85 m2 = new Manager85(10,"ji");
36.  
37. c.remove(m2);
38.  
39. System.out.println(c.size());
40.  
41. }
42.  
43. }

二、深入remove方法

（1）迭代器的remove方法​；

（2）集合自身的remove方法

1. package com.bjpowernode.java_learning;
2.  
3. ​
4.  
5. import java.util.*;
6.  
7. import java.lang.Iterable;
8.  
9. ​
10.  
11. public class D85_3_DeepIntoRemoveMethod {
12.  
13. public static void main(String[] args) {
14.  
15. Collection c = new ArrayList();
16.  
17. c.add(1);//这里复习了自动装箱，int类型直接转化为Integer类型
18.  
19. c.add(2);
20.  
21. c.add(3);
22.  
23. //遍历
24.  
25. Iterator it = c.iterator();
26.  
27. while(it.hasNext()) {
28.  
29. Object element = it.next();
30.  
31. //删除
32.  
33. it.remove();//通过迭代器的remove方法删除
34.  
35. }
36.  
37. System.out.println(c.size());
38.  
39. Collection c2 = new ArrayList();
40.  
41. c2.add(1);//这里复习了自动装箱，int类型直接转化为Integer类型
42.  
43. c2.add(2);
44.  
45. c2.add(3);
46.  
47. Iterator it2 = c2.iterator();
48.  
49. while(it2.hasNext()) {
50.  
51. Object element = it2.next();
52.  
53. c2.remove(element);
54.  
55. }
56.  
57. }
58.  
59. }

解释：

（1）如果要是删除集合里的许多元素（一两个无所谓，直接用集合的remove方法了），这时候推荐使用代码中的第一种方法，迭代器的remove方法进行删除；

（2）之所以不推荐第二种，用集合自身所带的remove方法进行删除，是因为​会报截图中的错误。产生这种错误是因为，当你初始化完一个迭代器之后，用迭代里的元素去删除集合里的元素时，删除第一个的时候还没有报错，但是删除第二的时候，迭代器初始化后的内容，与此时的集合内容不一样了（也就是集合少了一个元素，而迭代器还是完好的）​产生了冲突，所以报错，推荐使用第一种方法。​

三、源码：

D85_1_ContainsMethod.java

D85_2_RemoveMethod.java

D85_3_DeepIntoRemoveMethod.java

https://github.com/ruigege66/Java/blob/master/D85_1_ContainsMethod.java

https://github.com/ruigege66/Java/blob/master/D85_2_RemoveMethod.java

https://github.com/ruigege66/Java/blob/master/D85_3_DeepIntoRemoveMethod.java

以上就是Java 集合的Contains和Remove方法的详细内容，更多关于Java Contains和Remove的资料请关注服务器之家其它相关文章！

原文链接：https://www.cnblogs.com/ruigege0000/p/12329513.html